Atom USING [GetPName],

BasicTime USING [GMT, nullGMT, Period],

BcdDefs USING [NullVersion, VersionStamp],

Commander USING [CommandProc, Handle, Register],

CommandTool USING [ArgumentVector, DoCommand, Failed, GetProp, Parse],

Convert USING [RopeFromInt],

DFUtilities USING [DateToStream],

EditedStream USING [GetEcho, Rubout, SetEcho, SetMode, UnAppendBufferChars],

File USING [GetVolumeName, SystemVolume],

FileNames USING [GetShortName, ResolveRelativePath],

FS USING [Close, EnumerateForNames, Error, ExpandName, FileInfo, GetName, NameProc, Open, OpenFile],

IO USING [BreakProc, Close, EndOf, EndOfStream, Error, GetRefAny, GetToken, GetTokenRope, IDProc, PeekChar, PutChar, PutF, PutRope, RIS, SkipWhitespace, STREAM, TokenProc],

MBQueue USING [CreateMenuEntry],

Menus USING [AppendMenuEntry, ClickProc, CopyEntry, CreateMenu, FindEntry, Menu, MenuEntry, ReplaceMenuEntry],

PriorityQueue USING [Create, Insert, Ref, Remove, Size, SortPred],

Process USING [CheckForAbort],

ReadEvalPrint USING [Handle],

Rope USING [Cat, Compare, Concat, Equal, Fetch, Find, Flatten, FromChar, FromRefText, Index, Length, Match, Replace, ROPE, Run, SkipTo, Substr],

RopeList USING [Reverse],

ThisMachine USING [Name],

TiogaMenuOps USING [Open],

TiogaOps USING [FindDef, GetSelection, Location, LocOffset, Ref, Root],

UserCredentials USING [Get, Login],

UserProfile USING [CallWhenProfileChanges, Line, ProfileChangedProc, Token],

VersionMap USING [Length, Map, MapList, Range, RangeList, RangeToEntry, ShortNameToRanges],

VersionMapDefaults USING [GetMapList],

ViewerClasses USING [Viewer],

ViewerIO USING [GetBuffer, TypeChars],

ViewerOps USING [EnumerateViewers, EnumProc, FetchProp, PaintViewer],

ViewerTools USING [GetSelectionContents, SetSelection];

ENABLE {

token.length ← 0;

token ← commandLineStream.GetToken[IO.TokenProc, token].token;

name ← Rope.FromRefText[token];

[] ← commandLineStream.SkipWhitespace[FALSE];

IF NOT commandLineStream.EndOf[] AND commandLineStream.PeekChar[] = '( THEN {

token.length ← 0;

token ← commandLineStream.GetToken[CRBreak, token].token;

def ← Rope.FromRefText[token];

aliasCell ← NEW[AliasCellObject ← [args, def]];

Commander.Register[

IO.Close[commandLineStream];

EXITS Die => NULL;

};

token.length ← 0;

token ← commandLineStream.GetToken[IO.IDProc, token

new ← Rope.FromRefText[token];

IF RopeMemb[new, l.rest] THEN {

newCommandLine ← RopeSubst[old: l.first, new: new, base: newCommandLine];

ENDLOOP;

newCommandLine ← RopeSubst[old: l.first.val, new: l.first.key, base: newCommandLine];

ENDLOOP;

! IO.EndOfStream => CONTINUE; IO.Error => GO TO Nasty

].token;

ENABLE {

token.length ← 0;

token ← commandLineStream.GetToken[IO.TokenProc, token].token;

name ← Rope.FromRefText[token];

[] ← commandLineStream.SkipWhitespace[FALSE];

Get the rest of it!

token.length ← 0;

token ← commandLineStream.GetToken[CRBreak, token ! IO.EndOfStream => CONTINUE].token;

EXITS

};

Rope.Length[def] = 0 => def ← NIL;

Rope.Match["*\n", def] => {};

ENDCASE => def ← Rope.Concat[def, "\n"];

THEN RETURN [$Failure, "Can't find $ReadEvalPrintHandle"]

ELSE {

Various cases:

viewer: ViewerClasses.Viewer ← reph.viewer;

IF viewer # NIL THEN {

};

viewer: ViewerClasses.Viewer ← reph.viewer;

IF viewer # NIL THEN {

};

$CurrentSelection$ => replaced by the current selection up to but not including the first carriage return

$FileNameSelection$ => replaced by the current selection if it appears to be a file name, otherwise replaced by the name of the selected viewer

$ShortFileNameSelection$ => same as $FileNameSelection$ except that version number and directory are omitted

$SelectedViewerName$ => replaced by the name of the selected viewer

$ViewerPosition$ => replaced by the position of the current selection in a viewer

$MouseButton$ => "left", "middle", or "right"

$ShiftKey$ => "shift", "noShift"

$ControlKey$ "control", "noControl"

red => buttonRope ← "left";

yellow => buttonRope ← "middle";

blue => buttonRope ← "right";

ENDCASE => ERROR;

root: TiogaOps.Ref ← TiogaOps.Root[start.node];

offset: INT ← TiogaOps.LocOffset[loc1: [root, 0], loc2: start, skipCommentNodes: TRUE];

index ← offset;

viewerName ← viewer.file;

IF viewerName = NIL THEN viewerName ← viewer.name;

fileName ← viewer.file;

fileName ← Rope.Substr[fileName, 0, Rope.SkipTo[fileName, 0, "!"]];

};

It is likely that we have substitutions to do

def ← RopeSubst[old: "$CurrentSelection$", new: curSel, base: def, case: TRUE];

def ← RopeSubst[old: "$FileNameSelection$", new: fileName, base: def, case: TRUE];

def ← RopeSubst[old: "$ShortFileNameSelection$", new: shortFileName, base: def, case: TRUE];

def ← RopeSubst[old: "$SelectedViewerName$", new: viewerName, base: def, case: TRUE];

def ← RopeSubst[old: "$ViewerPosition$", new: Convert.RopeFromInt[index, 10, FALSE], base: def, case: TRUE];

def ← RopeSubst[old: "$MouseButton$", new: buttonRope, base: def, case: TRUE];

def ← RopeSubst[old: "$ControlKey$", new: controlRope, base: def, case: TRUE];

def ← RopeSubst[old: "$ShiftKey$", new: shiftRope, base: def, case: TRUE];

};

bufferContents: REF TEXT ← ViewerIO.GetBuffer[br.rep.in];

IF bufferContents # NIL AND bufferContents.length > 0 AND bufferContents[bufferContents.length - 1] # '\n THEN {

};

We get this whenever we rollback, or the credentials change.

user: ROPE ← UserCredentials.Get[].name;

IF NOT Rope.Equal[user, lastUser, FALSE] THEN {

};

RRA: EachCommandToolCommands is only for compatibility

IF asterisky

in ← cmd.in;

out ← cmd.out;

};

IF asterisky

};

startInteraction: StartInteraction,

endInteraction: EndInteraction,

options: [alwaysInteract: TRUE]

! EditedStream.Rubout => {result ← $Failed; msg ← " -- Aborted.\n"; CONTINUE}

];

[cmd: Handle] RETURNS [result: REF ← NIL, msg: ROPE ← NIL]

EachFile: FS.NameProc = {

PrintOneFile: PROC [item: FileItem] = {

TryPattern: PROC [pattern: ROPE] = {

SetLagPrefix: PROC [fileName: ROPE] = {

AddSortOption: PROC [option: ATOM] = {

RemSortOption: PROC [option: ATOM] = {

FNameToGName: PROC [name: ROPE] RETURNS [ROPE] = {

gHost: ROPE ← NIL;

gDir: ROPE ← NIL;

out: STREAM = cmd.out;

lagPrefix: ROPE ← NIL;

lagPrefixLen: INT ← 0;

patternsTried: INT ← 0;

filesSeen: INT ← 0;

bytesTotal: INT ← 0;

directoriesOnly: BOOL ← FALSE;

complexSorting: BOOL ← FALSE;

printKeep: BOOL ← FALSE;

narrowPrint: BOOL ← FALSE;

attachedPrint: BOOL ← FALSE;

briefPrint: BOOL ← FALSE;

remoteCheck: BOOL ← FALSE;

fullPrint: BOOL ← FALSE;

highestPrint: BOOL ← cmd.procData.clientData = $Highest;

oneLine: BOOL ← FALSE;

unattachedOnly: BOOL ← FALSE;

exactLevelMatch: BOOL ← FALSE;

gNamePrint: BOOL ← FALSE;

anglesRequired: INT ← 0;

sortData: LORA ← NIL;

sortDataTail: LORA ← NIL;

pq: PriorityQueue.Ref ← NIL;

argv: CommandTool.ArgumentVector ← CommandTool.Parse[cmd: cmd

ProcessSwitches: PROC [arg: ROPE] = {

ProcessSwitches[UserProfile.Token["ListCommand.DefaultSwitches"]];

FOR i: NAT IN [1..argv.argc) DO

IF patternsTried = 0 THEN TryPattern["*"];

IF oneLine THEN IO.PutChar[out, '\n];

IF filesSeen > 0 THEN {

EXITS

};

len: INT = Rope.Length[pattern];

pos: INT ← Rope.SkipTo[pattern, 0, ">"];

WHILE pos < len DO

};

fullFName, attachedTo: ROPE, created: GMT, bytes: INT, keep: CARDINAL];

[x: Item, y: Item, data: REF] RETURNS [BOOL]

xx: FileItem = NARROW[x];

yy: FileItem = NARROW[y];

options: LORA = NARROW[data];

FOR each: LORA ← options, each.rest WHILE each # NIL DO

RETURN [Rope.Compare[xx.fullFName, yy.fullFName, FALSE] = less];

};

[cmd: Handle] RETURNS [result: REF ← NIL, msg: ROPE ← NIL]

st: IO.STREAM ← cmd.out;

inStream: IO.STREAM ← IO.RIS[cmd.commandLine];

eachFile: PROC = {

DO

};

[cmd: Handle] RETURNS [result: REF ← NIL, msg: ROPE ← NIL]

st: IO.STREAM ← cmd.out;

inStream: IO.STREAM ← IO.RIS[cmd.commandLine];

useBin: BOOL ← cmd.procData.clientData = $Bin;

eachFile: PROC = {

DO

};

size: INT ← Rope.Length[short];

starPos: INT ← short.Index[0, "*"];

match: BOOL ← starPos # size;

hasDot: BOOL ← short.Index[0, "."] # size;

rangeList: VersionMap.RangeList ← NIL;

head: SourceFileList ← NIL;

tail: SourceFileList ← NIL;

shortShort: ROPE ← Rope.Flatten[short, 0, starPos];

shortShortLen: INT ← Rope.Length[shortShort];

mapList: MapList ← NIL;

IF size = 0 THEN RETURN;

IF which = NIL THEN which ← $Source;

IF mapList = NIL THEN mapList ← VersionMapDefaults.GetMapList[which];

rangeList ← VersionMap.ShortNameToRanges[mapList, short];

WHILE rangeList # NIL DO

RemoveDuplicates[head, removeDuplDates];

RETURN [head];

};

make a long name into a short one

assumes a valid long name, of course

first: INT ← 0;

last: INT ← Rope.Length[r];

FOR i: INT DECREASING IN [0..last) DO

RETURN [r.Substr[first, last - first]]

};

dot: INT ← 0;

len: INT ← Rope.Length[name];

pos: INT ← len;

WHILE (pos ← pos - 1) > 0 DO

RETURN [name, NIL];

};

IF sfl # NIL THEN {

};

This routine removes entries with duplicate names an (if removeDuplDates = TRUE) also removes entries with duplicate dates.

WHILE sfl # NIL DO

};

line: ROPE ← UserProfile.Line["SourceFileExtensions", "mesa tioga df cm config"];

in: STREAM ← IO.RIS[line, NIL];

DO

};

if old is not found in base, then value = base.

lenOld: INT = old.Length[];

lenNew: INT = new.Length[];

i: INT ← 0;

WHILE (i ← Rope.Find[s1: base, s2: old, case: case, pos1: i]) # -1 DO

RETURN[base];

};

FOR l: LIST OF ROPE ← lst, l.rest UNTIL l = NIL DO

RETURN[FALSE]

};

ENABLE UNWIND => NULL;

gennum ← gennum + 1;

RETURN[Rope.Concat[Rope.FromChar[c], Convert.RopeFromInt[gennum, 10, FALSE]]];

};

IF char = '\n THEN RETURN[break];

RETURN[other];

};

old: Menus.MenuEntry ← Menus.FindEntry[oldMenu, name];

IF old # NIL THEN Menus.AppendMenuEntry[newMenu, Menus.CopyEntry[old], 0];

};

Returns the enclosing ReadEvalPrint.Handle (NIL if no such handle).

DO

};

WITH ViewerOps.FetchProp[viewer, $ReadEvalPrint] SELECT FROM

};

listDoc: ROPE = "(List | LS) {switch | pattern}*\nswitch = -a: attached print, -b: brief format, -d: date sort, -f: full name print, -g: GName print, -k: keep print, -n: narrow print, -o: one line, -p: prefixes only, -r: remote check, -s: size sort, -u: un backed up, -x: exact level match";

Commander.Register[key: "///Commands/Alias", proc: Alias, doc: "Create an alias for a command", interpreted: FALSE];

Commander.Register[key: "///Commands/CreateButton", proc: CreateButton, doc: "Create a CommandTool herald button", interpreted: FALSE];

Commander.Register[key: "///Commands/ClearMenu", proc: ClearMenu, doc: "Reset the CommandTool menu"];

Commander.Register[key: "///Commands/Login", proc: Login, doc: "Login a new user"];

Commander.Register[key: "///Commands/NoteBootCommands", proc: NoteBootCommands, doc: "Perform commands for the first commander after a full boot"];

Commander.Register[key: "///Commands/NoteNewUser", proc: NoteNewUser, doc: "Perform commands for a new user"];

Commander.Register[key: "///Commands/NotePerCommandTool", proc: NotePerCommandTool, doc: "Perform commands for a login (or rollback)"];

Commander.Register[key: "///Commands/NotePerLogin", proc: NotePerLogin, doc: "Perform commands for a login (or rollback)"];

Commander.Register[key: "///Commands/RemoveButton", proc: CreateButton, doc: "Remove a CommandTool herald button"];

For List

For OpenR & FindR

UserProfile.CallWhenProfileChanges[WhenProfileChanges];

};