Atom USING [MakeAtom],

Basics USING [],

BasicTime USING [GMT, Now, nullGMT],

Commander USING [CommandProc, Register],

CommanderOps USING [ArgumentVector, Failed, Parse],

Convert USING [AppendInt],

DFUtilities USING [DirectoryItem, FileItem, IncludeItem, ParseFromStream, ProcessItemProc, SyntaxError],

IO USING [Close, EndOfStream, GetCedarToken, GetChar, GetIndex, PeekChar, PutChar, PutF1, PutFR, PutFR1, PutRope, SkipWhitespace, STREAM, TokenKind],

List USING [Compare, CompareProc, Sort],

PFS USING [EnumerateForNames, Error, FileInfo, GetName, NameProc, OpenFileFromStream, PATH, PathFromRope, RopeFromPath, StreamOpen],

PFSNames USING [ReplaceShortName, ShortName, ShortNameRope, StripVersionNumber],

Process USING [CheckForAbort],

RefText USING [InlineAppendChar, TrustTextAsRope],

Rope USING [ActionType, Compare, Concat, Equal, Fetch, FindBackward, Flatten, FromRefText, Length, Map, Match, ROPE, SkipOver, SkipTo],

SymTab USING [Create, FetchText, Ref, Store],

TiogaAccess USING [Create, Put, TiogaChar, WriteFile, Writer];

name: ROPE,

refs: LIST OF IdRef ¬ NIL,

reserved: ATOM ¬ NIL];

fileName: ROPE, -- file name where reference occurs

index: INT,  -- index where reference occurs

defn: BOOL]; -- indicates a defining reference

CommandObject = [in, out, err: STREAM, commandLine, command: ROPE, ...]

sense: BOOL ¬ TRUE;

FOR index: INT IN [0..Rope.Length[arg]) DO

};

Takes an open stream and adds the info to the xref.

blockLevel: INTEGER ¬ 0;

parenLevel: INTEGER ¬ 0;

lastId: REF IdEntry ¬ NIL;

lastPos: INT ¬ 0;

inDirectory: BOOL ¬ FALSE;

inType: BOOL ¬ FALSE;

AddRef: PROC [newRef: LIST OF IdRef] = {

curFileName: ROPE ¬ PFS.RopeFromPath[PFS.GetName[PFS.OpenFileFromStream[stream]].fullFName];

IF NOT switches['f] THEN curFileName ¬ GetShortName[curFileName];

ReportName[curFileName];

filesRead ¬ filesRead + 1;

IF fileListTail = NIL

IF symTab = NIL THEN InitTable[];

IF switches['t]

IO.Close[stream];

};

reserved: ROPE ¬ "RECORD POINTER REF VAR LIST ARRAY SEQUENCE DESCRIPTOR PROCEDURE PROC PORT SIGNAL ERROR PROCESS PROGRAM MONITOR DEFINITIONS ZONE RELATIVE LONG TYPE FRAME TO ORDERED UNCOUNTED PAINTED BASE OF PACKED RETURNS SAFE UNSAFE MONITORED OVERLAID COMPUTED MACHINE DEPENDENT DIRECTORY IMPORTS EXPORTS SHARES LOCKS USING PUBLIC PRIVATE CEDAR CHECKED TRUSTED UNCHECKED ENTRY INTERNAL INLINE READONLY CODE ABS ALL AND APPLY CONS MAX MIN MOD NOT OR ORD PRED LENGTH NEW START SUCC VAL FORK JOIN LOOPHOLE NARROW ISTYPE SIZE FIRST LAST NIL TRASH NULL IF THEN ELSE WITH FROM FOR DECREASING IN THROUGH UNTIL WHILE REPEAT FINISHED RETURN EXIT LOOP GOTO GO FREE WAIT RESTART NOTIFY BROADCAST STOP RESUME REJECT CONTINUE RETRY TRANSFER STATE OPEN ENABLE ANY EXITS END ENDLOOP ENDCASE BEGIN DO SELECT ";

builtIn: ROPE ¬ "TRUE FALSE INT CARD INTEGER CARDINAL BOOL BOOLEAN UNSPECIFIED CHARACTER CHAR WORD REAL NAT TEXT STRING MONITORLOCK CONDITION MDSZone StringBody ATOM UNWIND ABORTED ";

symTab ¬ SymTab.Create[1253];

AddReserved[symTab, reserved];

AddReserved[symTab, builtIn];

};

THROUGH [0..indent) DO IO.PutChar[out, ' ]; ENDLOOP;

IO.PutF1[out, " reading %g\n", [rope[name]]];

};

Now we can put out the cross-reference

tc: TiogaAccess.TiogaChar ¬ [

PutRope: PROC [rope: ROPE] = {

PutRopeBold: PROC [rope: ROPE] = {

PutRopeItalic: PROC [rope: ROPE] = {

PutCharB: Rope.ActionType = {

PutChar: PROC [c: CHAR] = {

EndNode: PROC [delta: INTEGER ¬ 0, format: ATOM ¬ NIL] = {

writer: TiogaAccess.Writer ¬ IF brief THEN NIL ELSE TiogaAccess.Create[];

st: IO.STREAM ¬ IF brief THEN PFS.StreamOpen[PFS.PathFromRope[arg], $create] ELSE NIL;

buffer: REF TEXT ¬ NEW[TEXT[12]];

IF filesRead = 1

IF NOT brief THEN TiogaAccess.Put[writer, tc];

tc.comment ¬ TRUE;

tc.endOfNode ¬ FALSE;

tc.propList ¬ NIL;

IO.PutF1[out, " xref output to %g\n", [rope[arg]]];

PutRope[arg];

EndNode[1];

PutRope[IO.PutFR1["taken on %g", [time[BasicTime.Now[]]]]];

IF NOT brief THEN EndNode[0];

PutRope[IO.PutFR["# files: %g, # tokens: %g, # unique tokens: %g",
[integer[filesRead]], [integer[tokensRead]], [integer[uniqueTokensRead]] ]];

EndNode[1];

FOR each: LIST OF ROPE ¬ fileListHead, each.rest WHILE each # NIL DO

EndNode[-2];

tc.comment ¬ FALSE;

idList ¬ List.Sort[idList, MySort];

IF switches['d] THEN {

SELECT TRUE FROM

symTab ¬ NIL;

xrefName ¬ NIL;

filesRead ¬ 0;

};

! CommanderOps.Failed => {msg ¬ errorMsg; GO TO failed}];

When parsing the command line, be prepared for failure. The error is reported to the user

Each argument can either be a switch specification or a genuine argument to be processed. The first argument (argv[0]) is not examined, because by convention it is the name of the command as given by the user.

arg: ROPE ¬ argv[i];

Process.CheckForAbort[];

SELECT TRUE FROM

ENDLOOP;

failed => {result ¬ $Failure};

next: INT ¬ Rope.SkipTo[rope, pos, " "];

flat: ROPE ¬ Rope.Flatten[rope, pos, next-pos];

new: REF IdEntry ¬ NEW[IdEntry ¬ [name: flat, reserved: Atom.MakeAtom[flat]]];

[] ¬ SymTab.Store[symTab, flat, new];

pos ¬ Rope.SkipOver[rope, next, " "];

IF pos = len THEN EXIT;

ENDLOOP;

less => RETURN [less];

greater => RETURN [greater];

ENDCASE => RETURN [Rope.Compare[name1, name2, TRUE]];

The name does not have the desired extension

This name does not have the desired extension, and does not have a dot, so let's try to add the desired extension.

snPath: PFS.PATH = PFS.PathFromRope[Rope.Concat[sn, ext]];

newPath: PFS.PATH = PFSNames.StripVersionNumber[
PFSNames.ReplaceShortName[path, PFSNames.ShortName[snPath]]];

realPath: PFS.PATH = PFS.FileInfo[newPath ! PFS.Error => GO TO beep].fullFName;

ret ¬ PFS.RopeFromPath[realPath];

EXITS beep => ret ¬ NIL;

};