<<>> <> <> <> DIRECTORY Ascii, ColumnLs, Commander, CommanderOps, DFUtilities, FileNames, FS, IO, PFS, PFSNames, Process, Real, RefText, Rope, VFonts, ViewerClasses, ViewerIO; ColumnLsImpl: CEDAR PROGRAM IMPORTS Commander, CommanderOps, DFUtilities, FileNames, FS, IO, PFS, PFSNames, Process, Real, RefText, Rope, VFonts, ViewerIO EXPORTS ColumnLs ~ BEGIN <> ROPE: TYPE ~ Rope.ROPE; Font: TYPE ~ VFonts.Font; Viewer: TYPE ~ ViewerClasses.Viewer; CmdMode: TYPE ~ RECORD [ <> separateDirs: BOOL Ź TRUE, -- there are multiple directories, so list separately <> columnOrder: BOOL Ź FALSE, -- -c: column order (default is row order) fixed: BOOL Ź FALSE, -- -f: use fixed pitch font markDirectory: BOOL Ź FALSE, -- -F: place slash after subdirectory directoriesOnly: BOOL Ź FALSE, -- -d: sub-directories only, no files exactLevel: BOOL Ź FALSE, -- -x: if true, don't list names recursively separateByExtension: BOOL Ź FALSE, -- -se: list files according to extension extensionsOnly: BOOL Ź FALSE, -- -e: file extensions (suffixes following '.') noExtensions: BOOL Ź FALSE, -- -ne: list those files that have no extension period: BOOL Ź FALSE, -- -a: files with name beginning with period noBackup: BOOL Ź FALSE, -- -no~: omit files ending with ~ basesOnly: BOOL Ź FALSE, -- -b: names only, no extensions interfacesOnly: BOOL Ź FALSE, -- -i: mesa files without 'impl.mesa' in name implsOnly: BOOL Ź FALSE, -- -ni: impls without corresponding interfaces aisAbbrev: BOOL Ź FALSE, -- -ais: abbreviate color ais files totalOnly: BOOL Ź FALSE -- -tot: list total number of files only <> <> <> ]; <> GetColumnateMode: PROC [mode: CmdMode] RETURNS [ColumnateMode] ~ { RETURN[IF mode.fixed THEN fixed ELSE spaced]; }; CommandProc: Commander.CommandProc ~ { mode: CmdMode; n, nArgs: NAT Ź 0; once: BOOL Ź FALSE; argv: CommanderOps.ArgumentVector Ź CommanderOps.Parse[cmd]; FOR n: INT IN [1..argv.argc) DO a: ROPE Ź argv[n]; IF FirstChar[a, '-] THEN SELECT TRUE FROM Rope.Equal[a, "-c"] => mode.columnOrder Ź TRUE; Rope.Equal[a, "-f"] => mode.fixed Ź TRUE; Rope.Equal[a, "-F"] => mode.markDirectory Ź TRUE; Rope.Equal[a, "-d"] => mode.directoriesOnly Ź TRUE; Rope.Equal[a, "-x"] => mode.exactLevel Ź TRUE; Rope.Equal[a, "-se"] => mode.separateByExtension Ź TRUE; Rope.Equal[a, "-e"] => mode.extensionsOnly Ź TRUE; Rope.Equal[a, "-ne"] => mode.noExtensions Ź TRUE; Rope.Equal[a, "-a"] => mode.period Ź TRUE; Rope.Equal[a, "-no~"] => mode.noBackup Ź TRUE; Rope.Equal[a, "-b"] => mode.basesOnly Ź TRUE; Rope.Equal[a, "-i"] => mode.interfacesOnly Ź TRUE; Rope.Equal[a, "-ni"] => mode.implsOnly Ź TRUE; Rope.Equal[a, "-ais"] => mode.aisAbbrev Ź TRUE; Rope.Equal[a, "-tot"] => mode.totalOnly Ź TRUE; < mode.ragged _ TRUE;>> < mode.tabbed _ TRUE;>> < mode.minus1 _ TRUE;>> ENDCASE ELSE nArgs Ź nArgs+1; ENDLOOP; IF NOT mode.directoriesOnly OR NOT EnumerateSubdirs[cmd, mode] THEN { mode.separateDirs Ź mode.separateDirs AND nArgs > 1; WHILE n < argv.argc-1 DO a: ROPE Ź argv[n Ź n+1]; IF NOT FirstChar[a, '-] THEN once Ź EnumerateArgument[cmd, a, mode] OR once ELSE { IF (n Ź n+1) < argv.argc THEN SELECT TRUE FROM Equal[a, "-dfi"] => once Ź EnumerateDf[cmd, FALSE, argv[n], mode]; Equal[a, "-dfm"] => once Ź EnumerateDf[cmd, TRUE, argv[n], mode]; ENDCASE => n Ź n-1; }; ENDLOOP; IF NOT once THEN [] Ź EnumerateArgument[cmd, "", mode]; }; }; EnumerateDf: PROC [cmd: Commander.Handle, listImpl: BOOL, dfName: ROPE, mode: CmdMode] RETURNS [once: BOOL Ź TRUE] ~ { EachDf: PFS.NameProc ~ { ProcessItem: DFUtilities.ProcessItemProc ~ { Bad: PROC [name, ext: ROPE, bool: BOOL] RETURNS [b: BOOL] ~ { b Ź NOT Equal[Extension[name], ext] OR (Rope.Find[name,"impl",0,FALSE]#-1) = bool; }; WITH item SELECT FROM f: REF DFUtilities.FileItem => { name: ROPE Ź FileNames.StripVersionNumber[f.name]; IF NOT Equal[Extension[name], "mesa"] THEN RETURN; IF (Rope.Find[name, "impl", 0, FALSE] # -1) # listImpl THEN RETURN; IF mode.basesOnly THEN name Ź Base[name]; names Ź CONS[name, names]; }; ENDCASE; }; stream: IO.STREAM; names: LIST OF ROPE Ź NIL; stream Ź PFS.StreamOpen[name ! PFS.Error => { IF error.group # bug THEN IO.PutF1[cmd.out, "** %g\n", IO.rope[error.explanation]]; GOTO Bad; }]; DFUtilities.ParseFromStream[stream, ProcessItem, [FALSE, source, all, defining]]; IO.Close[stream]; Output[cmd, names, TRUE, mode]; EXITS Bad => NULL; }; PFS.EnumerateForNames[PFS.PathFromRope[FileNames.ResolveRelativePath[dfName]], EachDf ! PFS.Error => GOTO Bad]; EXITS Bad => NULL; }; Output: PROC [ cmd: Commander.Handle, names: LIST OF ROPE, rev: BOOL Ź FALSE, mode: CmdMode, indent: ROPE Ź NIL] ~ { length: NAT Ź 0; FOR l: LIST OF ROPE Ź names, l.rest WHILE l # NIL DO length Ź length+1; ENDLOOP; IF NOT mode.totalOnly THEN ColumnateNames[cmd, names, rev, GetColumnateMode[mode], mode.columnOrder,, indent]; IF mode.totalOnly OR length > 19 THEN IO.PutF1[cmd.out, "%g files\n", IO.int[length]] }; EnumerateSubdirs: PROC [cmd: Commander.Handle, mode: CmdMode] RETURNS [success: BOOL Ź TRUE] ~ { EachInfo: PFS.InfoProc ~ { Process.CheckForAbort[]; IF fileType = 1 THEN { name: ROPE Ź PFSNames.ShortName[fullFName].name.base; IF NOT FirstChar[name, '.] THEN names Ź CONS[name, names]; }; }; names: LIST OF ROPE Ź NIL; PFS.EnumerateForInfo[PFS.PathFromRope["*!H"], EachInfo ! PFS.Error => GOTO Bad]; Output[cmd, names, TRUE, mode]; EXITS Bad => RETURN[FALSE]; }; EnumerateArgument: PROC [ cmd: Commander.Handle, cmdArg: ROPE, mode: CmdMode] RETURNS [once: BOOL Ź FALSE] ~ { GetNames: PROC [arg: ROPE] RETURNS [names: LIST OF ROPE Ź NIL] ~ { EachName: PFS.NameProc ~ { item: ROPE; long: BOOL Ź PFSNames.ComponentCount[name] > nComponents; Process.CheckForAbort[]; <> IF mode.noExtensions AND Middle[PFSNames.ShortName[name].name.base, "."] THEN RETURN; SELECT TRUE FROM long AND directory AND NOT mode.extensionsOnly => { -- get subdirectory item Ź PFS.RopeFromPath[PFSNames.Directory[name]]; IF Equal[item, subDir] THEN RETURN; subDir Ź item; }; long AND mode.exactLevel => RETURN; ENDCASE => { -- item is a file item Ź PFSNames.ShortName[name].name.base; IF NOT mode.period AND Rope.Fetch[item, 0] = '. THEN RETURN; IF mode.noBackup AND LastChar[item, '~] THEN RETURN; IF mode.markDirectory AND FS.FileInfo[PFS.RopeFromPath[name]].fileType = 1 THEN item Ź Rope.Concat[item, "/"]; SELECT TRUE FROM mode.extensionsOnly => { IF (item Ź Extension[item]) = NIL THEN {IF PFS.FileInfo[name].fileType # 1 THEN item Ź "" ELSE RETURN}; IF names # NIL THEN FOR l: LIST OF ROPE Ź names, l.rest WHILE l # NIL DO IF Equal[item, l.first] THEN RETURN; ENDLOOP; }; mode.interfacesOnly => { IF NOT Equal[Extension[item], "mesa"] THEN RETURN; IF Rope.Find[item, "impl.mesa", 0, FALSE] # -1 THEN RETURN; }; mode.implsOnly => { n: INTEGER Ź Rope.Find[item, "impl", 0, FALSE]; IF (n = -1 OR NOT Equal[Extension[item], "mesa"]) OR FileExists[Rope.Concat[Rope.Substr[item,, n], Rope.Substr[item, n+4]]] THEN RETURN; }; mode.aisAbbrev => IF Equal[Extension[item], "ais"] THEN { Suffix: PROC [color: ROPE] RETURNS [ROPE] ~ { RETURN[Rope.Cat[base, "-", color, ".ais"]]; }; Ok: PROC [a, b: ROPE Ź NIL] RETURNS [ok: BOOL] ~ { ok Ź FileExists[Suffix[a]]; IF NOT ok AND b # NIL THEN ok Ź FileExists[Suffix[b]]; }; Find: PROC [f: ROPE] RETURNS [b: BOOL] ~ {b Ź Rope.Find[item, f, n] # -1}; n: INT Ź RevCharFind[item, '-]+1; base: ROPE Ź IF n > 1 THEN RopePiece[item, 0, n-2] ELSE NIL; IF base # NIL THEN SELECT TRUE FROM Find["red"] => IF Ok["grn", "green"] AND Ok["blu", "blue"] THEN item Ź Rope.Concat[base, " (color)"]; Find["grn"] OR Find["green"] => IF Ok["red"] AND Ok["blu", "blue"] THEN RETURN; Find["blu"] OR Find["blue"] => IF Ok["red"] AND Ok["grn", "green"] THEN RETURN; ENDCASE; }; ENDCASE; IF mode.basesOnly THEN item Ź Base[item]; }; names Ź CONS[item, names]; }; PFS.EnumerateForNames[PFS.PathFromRope[arg], EachName ! PFS.Error => GOTO Bad]; EXITS Bad => NULL; }; columnateMode: ColumnateMode Ź GetColumnateMode[mode]; star, directory, allName: BOOL Ź TRUE; nComponents: NAT Ź 0; arg, subDir: ROPE Ź NIL; arg Ź cmdArg; star Ź LastChar[arg, '*]; WHILE LastChar[arg, '*] DO arg Ź RopeShorten[arg, 1]; ENDLOOP; directory Ź Rope.IsEmpty[arg] OR LastChar[arg, '/] OR LastChar[arg, '>]; arg Ź FileNames.ResolveRelativePath[arg]; -- handle . or .. arg Ź Rope.Concat[arg, "*"]; -- ensure FName arg Ź FS.ExpandName[arg ! FS.Error => GOTO Bad].fullFName; allName Ź Middle[cmdArg, "*"] AND (Middle[cmdArg, ">"] OR Middle[cmdArg, "/"]); IF NOT directory AND NOT star THEN arg Ź RopeShorten[arg, 1]; -- remove '* nComponents Ź PFSNames.ComponentCount[PFS.PathFromRope[arg]]; IF mode.separateDirs AND directory THEN { IF once THEN IO.PutRope[cmd.out, "\n"]; IO.PutF[cmd.out, "%l%g%l\n", IO.rope["b"], IO.rope[cmdArg], IO.rope["B"]]; }; once Ź TRUE; IF mode.separateByExtension THEN { oldMode: CmdMode Ź mode; extensions, names: LIST OF ROPE; mode.extensionsOnly Ź TRUE; extensions Ź Alphabetize[GetNames[arg]]; mode.extensionsOnly Ź oldMode.extensionsOnly; mode.basesOnly Ź TRUE; FOR l: LIST OF ROPE Ź extensions, l.rest WHILE l # NIL DO none: BOOL Ź Rope.Equal[l.first, ""]; IO.PutF[cmd.out, "%l.%g:%l\n", IO.rope["b"], IO.rope[l.first], IO.rope["B"]]; IF none THEN {mode.noExtensions Ź TRUE; names Ź GetNames[Rope.Concat[arg, "!H"]]} ELSE names Ź GetNames[Rope.Cat[arg, ".", l.first, "!H"]]; Output[cmd, names, TRUE, mode, " "]; mode.noExtensions Ź oldMode.noExtensions; ENDLOOP; mode.basesOnly Ź oldMode.basesOnly; } ELSE { l: LIST OF ROPE Ź GetNames[Rope.Concat[arg, "!H"]]; IF mode.extensionsOnly THEN Output[cmd, Alphabetize[l],, mode] ELSE Output[cmd, l, TRUE, mode]; }; EXITS Bad => NULL; }; <> fixedCharWidth: NAT ~ 7; nSpacesInTab: NAT ~ 4; nPixelsInCR: NAT ~ 4; Name: TYPE ~ RECORD [rope: ROPE, width: INTEGER]; Names: TYPE ~ RECORD [length: NAT Ź 0, seq: SEQUENCE maxLength: NAT OF Name]; ColumnateMode: TYPE ~ ColumnLs.ColumnateMode; RopeWidth: PROC [name: ROPE, mode: ColumnateMode, font: Font] RETURNS [w: INTEGER] ~ { w Ź SELECT mode FROM fixed => fixedCharWidth*Rope.Length[name], tabbed => nPixelsInCR+VFonts.StringWidth[name, font], -- screwy, but needed for tabs ENDCASE => VFonts.StringWidth[name, font]; }; PadColumn: PROC [width: NAT, font: Font, mode: ColumnateMode] RETURNS [w: NAT] ~ { w Ź width+2*(IF mode = fixed THEN fixedCharWidth ELSE VFonts.StringWidth[" ", font]); IF mode = tabbed THEN { tabWidth: NAT ~ nSpacesInTab*VFonts.StringWidth[" ", font]; nTabs: NAT Ź width/tabWidth; IF width MOD tabWidth # 0 THEN nTabs Ź nTabs+1; w Ź nTabs*tabWidth; }; }; ColumnateNames: PUBLIC PROC [ cmd: Commander.Handle, names: LIST OF ROPE, reverseOrder: BOOL Ź FALSE, mode: ColumnateMode Ź tabbed, columnOrder: BOOL Ź FALSE, font: Font Ź NIL, rowIndentation: ROPE Ź NIL] ~ { IF names # NIL THEN { seq: REF Names; columnWidth, nNames: NAT Ź 0; IF font = NIL THEN font Ź defaultFont; FOR l: LIST OF ROPE Ź names, l.rest WHILE l # NIL DO nNames Ź nNames+1; ENDLOOP; seq Ź NEW[Names[nNames]]; FOR l: LIST OF ROPE Ź names, l.rest WHILE l # NIL DO width: INTEGER Ź RopeWidth[l.first, mode, font]; IF width > columnWidth THEN columnWidth Ź width; seq[IF reverseOrder THEN nNames-seq.length-1 ELSE seq.length] Ź [l.first, width]; seq.length Ź seq.length+1; ENDLOOP; columnWidth Ź PadColumn[columnWidth, font, mode]; DoColumnate[cmd, seq, mode, font, columnWidth, columnOrder, rowIndentation]; }; }; GetViewer: PROC [cmd: Commander.Handle] RETURNS [Viewer] ~ { RETURN[ViewerIO.GetViewerFromStream[cmd.out]]; }; ColumnWidth: PUBLIC PROC [ cmd: Commander.Handle, names: LIST OF ROPE, mode: ColumnateMode Ź tabbed, font: Font Ź NIL] RETURNS [columnWidth: NAT Ź 0] ~ { IF names # NIL THEN { viewer: Viewer Ź GetViewer[cmd]; viewerWidth: NAT Ź viewer.cw; f: Font Ź IF font # NIL THEN font ELSE defaultFont; FOR l: LIST OF ROPE Ź names, l.rest WHILE l # NIL DO width: INTEGER Ź RopeWidth[l.first, mode, f]; IF width > columnWidth THEN columnWidth Ź width; ENDLOOP; columnWidth Ź PadColumn[columnWidth, font, mode]; }; }; ColumnateGivenColumnWidth: PUBLIC PROC [ cmd: Commander.Handle, names: LIST OF ROPE, columnWidth: NAT, reverseOrder: BOOL Ź FALSE, mode: ColumnateMode Ź tabbed, columnOrder: BOOL Ź FALSE, font: Font Ź NIL, rowIndentation: ROPE Ź NIL] ~ { IF names # NIL THEN { seq: REF Names; nNames: NAT Ź 0; IF font = NIL THEN font Ź defaultFont; FOR l: LIST OF ROPE Ź names, l.rest WHILE l # NIL DO nNames Ź nNames+1; ENDLOOP; seq Ź NEW[Names[nNames]]; FOR l: LIST OF ROPE Ź names, l.rest WHILE l # NIL DO width: INTEGER Ź RopeWidth[l.first, mode, font]; seq[IF reverseOrder THEN nNames-seq.length-1 ELSE seq.length] Ź [l.first, width]; seq.length Ź seq.length+1; ENDLOOP; DoColumnate[cmd, seq, mode, font, columnWidth, columnOrder, rowIndentation]; }; }; DoColumnate: PROC [ cmd: Commander.Handle, names: REF Names, mode: ColumnateMode Ź tabbed, font: Font, columnWidth: NAT, columnOrder: BOOL, rowIndentation: ROPE] ~ { text1: REF TEXT Ź RefText.ObtainScratch[150]; SELECT mode FROM < {>> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <= names.length THEN EXIT;>> <> <= names.length THEN EXIT;>> <> <> <> <> <> <<};>> ragged, spaced => { text2: REF TEXT Ź RefText.ObtainScratch[150]; normSpaceWidth: NAT ~ VFonts.StringWidth[" ", font]; smallSpaceWidth: NAT ~ VFonts.StringWidth[" ", VFonts.EstablishFont["Timesroman", 8]]; rowIndentationWidth: NAT ~ VFonts.StringWidth[rowIndentation, font]; row, index, nDone: NAT Ź 0; viewerWidth: NAT Ź GetViewer[cmd].cw; nPixels, totWidth, nextTotal, nText1, nText2: INTEGER; nColumns: NAT Ź MAX[1, (viewerWidth-20-rowIndentationWidth)/columnWidth]; nRows: NAT Ź names.length/nColumns; IF names.length MOD nColumns # 0 THEN nRows Ź nRows+1; WHILE nDone < names.length DO IO.PutRope[cmd.out, rowIndentation]; nextTotal Ź totWidth Ź 0; FOR i: NAT IN [1..nColumns] DO name: Name Ź names[index]; nextTotal Ź nextTotal+columnWidth; totWidth Ź totWidth+name.width; nPixels Ź nextTotal-totWidth; IF i = nColumns THEN IO.PutRope[cmd.out, name.rope] ELSE { IF mode = ragged THEN { nText1 Ź Real.Round[REAL[nextTotal-totWidth]/REAL[normSpaceWidth]]; nText2 Ź 0; } ELSE { nText1 Ź nPixels MOD smallSpaceWidth; nText2 Ź nPixels/smallSpaceWidth-nText1; IF nText2 < 0 THEN {nText2 Ź 0; nText1 Ź nText1-1} }; totWidth Ź totWidth+nText1*normSpaceWidth+nText2*smallSpaceWidth; CharText[text1, nText1, ' ]; CharText[text2, nText2, ' ]; IF mode = ragged OR nText2 = 0 THEN IO.PutF[cmd.out, "%g%g", IO.rope[name.rope], IO.text[text1]] ELSE IO.PutFL[cmd.out, "%g%g%l%g%l", LIST[IO.rope[name.rope], IO.text[text1], IO.rope["s"], IO.text[text2], IO.rope["S"]]]; }; IF (nDone Ź nDone+1) >= names.length THEN EXIT; index Ź index+(IF columnOrder THEN nRows ELSE 1); IF index >= names.length THEN EXIT; ENDLOOP; IO.PutRope[cmd.out, "\n"]; row Ź row+1; IF columnOrder THEN index Ź row; ENDLOOP; RefText.ReleaseScratch[text2]; }; tabbed, fixed => { -- really just for fixed, but tabbed seems busted rowIndentationWidth: NAT ~ fixedCharWidth*Rope.Length[rowIndentation]; row, index, nDone: NAT Ź 0; viewerWidth: NAT Ź GetViewer[cmd].cw; nColumns: NAT Ź MAX[1, (viewerWidth-20-rowIndentationWidth)/columnWidth]; nRows: NAT Ź names.length/nColumns; IF names.length MOD nColumns # 0 THEN nRows Ź nRows+1; IO.PutF1[cmd.out, "%l", IO.rope["f"]]; WHILE nDone < names.length DO IO.PutRope[cmd.out, rowIndentation]; FOR i: NAT IN [1..nColumns] DO name: Name Ź names[index]; CharText[text1, (columnWidth-name.width)/fixedCharWidth, ' ]; IF i = nColumns THEN IO.PutRope[cmd.out, name.rope] ELSE IO.PutF[cmd.out, "%g%g", IO.rope[name.rope], IO.text[text1]]; IF (nDone Ź nDone+1) >= names.length THEN EXIT; index Ź index+(IF columnOrder THEN nRows ELSE 1); IF index >= names.length THEN EXIT; ENDLOOP; IO.PutRope[cmd.out, "\n"]; row Ź row+1; IF columnOrder THEN index Ź row; ENDLOOP; IO.PutF1[cmd.out, "%l", IO.rope["F"]]; }; ENDCASE; RefText.ReleaseScratch[text1]; }; <> Alphabetize: PROC [ropes: LIST OF ROPE] RETURNS [ret: LIST OF ROPE] ~ { IF ropes # NIL THEN { l: LIST OF ROPE Ź ropes.rest; ret Ź LIST[ropes.first]; WHILE l # NIL DO name: ROPE Ź l.first; rest: LIST OF ROPE Ź l.rest; IF Rope.Compare[ret.first, name, FALSE] = greater THEN ret Ź CONS[name, ret] ELSE FOR r: LIST OF ROPE Ź ret, r.rest DO IF r.rest = NIL OR Rope.Compare[r.rest.first, name, FALSE] = greater THEN { l.rest Ź r.rest; r.rest Ź l; EXIT; }; ENDLOOP; l Ź rest; ENDLOOP; }; }; Equal: PROC [r1, r2: ROPE] RETURNS [BOOL] ~ { RETURN[Rope.Equal[r1, r2, FALSE]]; }; Capitalize: PROC [r: ROPE] RETURNS [ROPE] ~ { c: CHAR Ź Rope.Fetch[r]; RETURN[IF c IN ['a..'z] THEN Rope.Replace[r, 0, 1, Rope.FromChar[c-'a+'A]] ELSE r]; }; Middle: PROC [searchee, target: ROPE] RETURNS [BOOL] ~ { location: INT Ź Rope.Find[searchee, target]; RETURN[location # -1 AND location # Rope.Length[searchee]-1]; }; Base: PROC [name: ROPE] RETURNS [ROPE] ~ { n: INT Ź RevCharFind[name, '.]; RETURN[IF n > 0 THEN RopePiece[name, 0, n-1] ELSE name]; }; Extension: PROC [name: ROPE] RETURNS [r: ROPE Ź NIL] ~ { n: INT Ź RevCharFind[name, '.]; IF n >= 0 THEN r Ź RopePiece[name, n+1, Rope.Length[name]-1]; }; CharText: PROC [text: REF TEXT, nSpaces: INT, char: CHAR] ~ { text.length Ź 0; THROUGH [1..nSpaces] DO text Ź RefText.AppendChar[text, char]; ENDLOOP; }; NChars: PROC [rope: ROPE, char: CHAR] RETURNS [retval: INT Ź 0] ~ { length: INT Ź Rope.Length[rope]; FOR n: INT Ź 0, n+1 WHILE n < length DO IF rope.Fetch[n] = char THEN retval Ź retval+1; ENDLOOP; RETURN[retval]; }; RopePiece: PROC [rope: ROPE, n1: INT, n2: INT] RETURNS [ROPE] ~ { IF n1 < 0 OR n2 < 0 THEN RETURN[NIL]; IF n2 > n1 THEN RETURN[Rope.Substr[rope, n1, n2-n1+1]]; RETURN[Rope.Substr[rope, n2, n1-n2+1]]; }; RevCharFind: PROC [rope: ROPE, char: CHAR] RETURNS [INT] ~ { n: INT Ź Rope.Length[rope]-1; WHILE n >= 0 AND Rope.Fetch[rope, n] # char DO n Ź n-1; ENDLOOP; RETURN[n]; }; FirstChar: PROC [rope: ROPE, char: CHAR] RETURNS [BOOL] ~ { RETURN[Rope.Length[rope] > 0 AND Rope.Fetch[rope, 0] = char]; }; LastChar: PROC [rope: ROPE, char: CHAR] RETURNS [BOOL] ~ { ropeLength: INT Ź Rope.Length[rope]; RETURN[ropeLength > 0 AND Rope.Fetch[rope, ropeLength-1] = char]; }; RopeShorten: PROC [rope: ROPE, n: INT] RETURNS [ROPE] ~ { ropeLength: INT Ź Rope.Length[rope]; IF ropeLength >= n THEN rope Ź Rope.Substr[rope, 0, ropeLength-n]; RETURN [rope]; }; MultiSkip: PROC [rope: ROPE, char: CHAR, nSkip: INT] RETURNS [ROPE] ~ { n: INT; limit: INT Ź Rope.Length[rope]-1; FOR n Ź 0, n+1 WHILE n < limit DO IF Rope.Fetch[rope, n] = char THEN nSkip Ź nSkip-1; IF nSkip = 0 THEN EXIT; ENDLOOP; RETURN[Rope.Substr[rope, n+1]]; }; FileExists: PROC [fileName: ROPE] RETURNS [exists: BOOL Ź TRUE] ~ { [] Ź FS.FileInfo[fileName ! FS.Error => {exists Ź FALSE; CONTINUE}]; }; <> usage: ROPE ~ " columnLs [option] a concise listing program, options are: -c\t\t\t\tcolumn (rather than row) ordered listing -f\t\t\t\tfixed width font -F\t\t\t\taffix trailing slash to a subdirectory -d\t\t\t\tdirectories only -x\t\t\t\texact level: list only files in current directory -se\t\t\t\tlist according to extensions -e\t\t\t\tfile extensions only -ne\t\t\t\tlist only files with no extension -a\t\t\t\tlist files with names beginning with a period -no~\t\t\tdon't list backup files (~) -b\t\t\t\tfile base name only -i\t\t\t\tlist interfaces only (.mesa) -ni\t\t\t\tlist impls without corresponding interfaces -ais\t\t\tabbreviate listing color ais files -tot\t\t\t\tlist total number of files only -dfi \tlist source interfaces from df file -dfm \tlist source implementations from df file."; defaultFont: Font ~ VFonts.EstablishFont["Tioga", 10]; Commander.Register["ColumnLs", CommandProc, usage]; END. .. <> <> <> <> <> <<~ {>> <> <> <> <> <<~ INLINE {>> <> <> <> <<};>> <> <] > nArgArrows;>> <> <> <> <> < {>> <> <> <> <> <<};>> < {>> <> <> <<};>> < {>> <> <> <> <> <<};>> < IF Equal[Extension[name], "ais"] THEN {>> <> <> <<};>> <> <> <> <<};>> <> <> < 1 THEN RopePiece[name, 0, n-2] ELSE NIL;>> <> < IF Ok["grn", "green"] AND Ok["blu", "blue"]>> <> <>> <> <>> <> <> <<};>> <> <> <<};>> <> <<};>> < GOTO Bad];>> < NULL;>> <<};>> <> <> <> <> <> <> <> <];>> <> <> < GOTO Bad].fullFName;>> <"] OR Middle[cmdArg, "/"]);>> <> <];>> <> <> <> <<};>> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<}>> <> <> <> <> <> <<};>> <> < NULL;>> <<};>> <<>> <> <> <> <> <];>> <> <> <> <> < {>> <> <> <> <> <> <> <> < RETURN[FALSE];>>