commandLineStream: IO.STREAM = IO.RIS[cmd.commandLine];

quiet: BOOL ~ FALSE;

name, def: ROPE;

args: LIST OF ROPE ¬ NIL;

aliasCell: AliasCell;

originalProc: Commander.CommandProc ¬ NIL;

{

};

aliasCell: AliasCell ¬ NARROW[cmd.procData.clientData];

aliasMode: REF ← CommanderOps.GetProp[cmd, $AliasMode];

newCommandLine: ROPE ¬ aliasCell.def;

commandLineStream: IO.STREAM = IO.RIS[cmd.commandLine];

SynonymRecord: TYPE = RECORD [key, val: ROPE];

synonyms: LIST OF REF SynonymRecord ¬ NIL;

gennum: CARD ¬ 1;

UniqueRope: PROC RETURNS [ROPE] = {

FOR l: LIST OF ROPE ¬ aliasCell.args, l.rest UNTIL l = NIL DO

FOR l: LIST OF REF SynonymRecord ¬ synonyms, l.rest UNTIL l = NIL DO

newCommandLine ¬ Rope.Concat[newCommandLine, IO.GetRope[commandLineStream]];

IO.Close[commandLineStream];

IF aliasCell.originalProc # NIL

};

matchList: LIST OF ROPE ¬ NIL;

EachCommand: Commander.EnumerateAction = {

[] ¬ Commander.Enumerate[EachCommand];

matchList ¬ RopeList.Sort[list: matchList, compareProc: RopeList.IgnoreCase];

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

};

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

RETURN[FALSE]

};

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

result ← s.GetRefAny[ ! IO.EndOfStream => CONTINUE];

IF result # NIL THEN msg ← s.GetLineRope[];

s.Close[];

};

};

child: Commander.Handle ~ CommanderOps.CreateFromStreams[parentCommander: cmd];

add: Atom.PropList ¬ NIL;

DO

UNTIL add = NIL DO

IF CommanderOps.ReadEvalPrintLoop[child].hadFailure THEN result ¬ $Failure;

};

IO.PutF1[cmd.out, "%g\n", [time[BasicTime.Now[]]]];

};

FirstArg : BOOLEAN ¬ TRUE;

nFlag : BOOLEAN ¬ TRUE;

sFlag : BOOLEAN ¬ TRUE;

argv: CommanderOps.ArgumentVector ¬ CommanderOps.Parse[cmd];

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

IF nFlag THEN cmd.out.PutChar['\n];

};

result ¬ $Failure;

msg ¬ cmd.commandLine;

IF Rope.Match[" *\n", msg] THEN msg ¬ Rope.Substr[msg, 1, Rope.Size[msg]-2];

};

result ¬ CommanderOps.GetProp[cmd, $Result];

IF result = $Failure THEN {

[result: result] ¬ CommanderOps.ExecuteCommand[cmd, cmd.commandLine];

};

pLen: INT = prefix.Size[];

cLen: INT = command.Size[];

c: CHAR;

first, afterLast: INT ¬ 0;

FOR afterLast ¬ 0, afterLast+1

is ¬ pLen <= afterLast-first AND prefix.Equal[command.Substr[start: first, len: pLen], FALSE];

};

prompt: ROPE = NARROW[List.Assoc[key: $Prompt, aList: cmd.propertyList]];

toGive: LIST OF ROPE ¬ NIL;

includeDuplicates: BOOL ¬ TRUE;

includePrompt: BOOL ¬ TRUE;

n: INT ¬ 10;

seen: SymTab.Ref;

commandToolData: CommanderBackdoor.CommandToolData ¬ CommanderBackdoor.GetCommandToolData[cmd];

h: CommanderBackdoor.CommandHistoryList ¬ commandToolData.history;

cls: IO.STREAM = IO.RIS[cmd.commandLine];

FOR i: INT ¬ cls.SkipWhitespace[], cls.SkipWhitespace[] WHILE NOT cls.EndOf[] DO

cls.Close[];

IF NOT includeDuplicates THEN seen ¬ SymTab.Create[case: FALSE];

WHILE n > 0 DO

FOR toGive ¬ toGive, toGive.rest WHILE toGive # NIL DO

result ¬ $OK;

EXITS

};

prefix: REF TEXT;

terminator: ROPE ¬ NIL;

terminatorSize: NAT ¬ 0;

line: REF TEXT ¬ NEW[TEXT[200]];

argv: CommanderOps.ArgumentVector ¬ CommanderOps.Parse[cmd];

IF argv.argc > 2 OR (argv.argc < 2 AND cmd.procData.clientData # $Indent) THEN {msg ¬ Rope.Concat["Usage: ", cmd.procData.doc]; GO TO oops};

SELECT cmd.procData.clientData FROM

DO

EXITS

};

old: Process.Priority ~ Process.GetPriority[];

new: Process.Priority ~ SELECT cmd.procData.clientData FROM

Process.SetPriority[new];

[result: result, msg: msg] ¬ CommanderOps.ExecuteCommand[cmd, cmd.commandLine !

Process.SetPriority[old];

};

args: [ switch ] propname [ defaultvalue ]

switches: -q => always quote; -s => never quote; -f => fail if property is undefined";

RETURN [SELECT c FROM IN ['a..'z], IN ['A..'Z], IN ['0..'9], '/, '*, '. => FALSE ENDCASE => TRUE ]

};

result ← List.Assoc[$Result, cmd.propertyList];

msg ← IO.PutFR1["previous Result = %g", IO.refAny[result]];

};

result ← CommanderOps.DoCommand[cmd.commandLine, cmd];

msg ← IO.PutFR1["Result = %g", IO.refAny[result]];

};

n: NAT ¬ 0;

arg: ROPE ← CommanderOps.NextArgument[cmd];

v: REF ¬ NIL;

quote: [0..2] ¬ 1;

demand: BOOL ¬ FALSE;

value: ROPE ¬ NIL;

default: ROPE ¬ NIL;

WHILE Rope.Match["-*", arg] DO

IF arg = NIL THEN CommanderOps.Failed[cmd.procData.doc];

default ¬ CommanderOps.NextArgument[cmd];

IF CommanderOps.NextArgument[cmd] # NIL THEN CommanderOps.Failed[cmd.procData.doc];

value ¬ default;

v ¬ CommanderOps.GetProp[cmd, Atom.MakeAtom[arg]];

IF v = NIL THEN WITH CommanderOps.GetProp[cmd, $CommandFileArgumentVector] SELECT FROM

WITH v SELECT FROM

IF quote = 1 THEN {

IF quote # 0 THEN value ¬ Convert.RopeFromRope[value, TRUE];

IO.PutRope[cmd.out, value];

IO.PutRope[cmd.out, "\n"];

};

depth: INT ¬ 5;

width: INT ¬ 32;

props: List.AList;

i: NAT ¬ 1;

token: Rope.ROPE;

any: BOOL ¬ FALSE;

verboseFlag: BOOL ¬ FALSE;

key: REF ANY;

argv: CommanderOps.ArgumentVector ¬ CommanderOps.Parse[cmd

{

EXITS oops => result ¬ $Failure;

};

commandToolData: CommanderBackdoor.CommandToolData ¬ CommanderBackdoor.GetCommandToolData[cmd];

cls: IO.STREAM = IO.RIS[cmd.commandLine];

trash: INT = cls.SkipWhitespace[];

key: ROPE = IF cls.EndOf[] THEN NIL ELSE cls.GetTokenRope[IO.IDProc].token;

[] ¬ cls.SkipWhitespace[];

IF NOT cls.EndOf[] THEN GOTO GiveUsage;

cls.Close[];

FOR h: CommanderBackdoor.CommandHistoryList ¬ commandToolData.history, h.rest WHILE h # NIL DO

EXITS

};

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

out: IO.STREAM ¬ cmd.out;

argv: CommanderOps.ArgumentVector ¬ CommanderOps.Parse[cmd: cmd];

IF argv.argc <= 1 THEN {

BEGIN

EXITS oops => result ¬ $Failure;

};

a: ARRAY [0..1] OF ROPE;

i: NAT ¬ 0;

imode: INTEGER ¬ 0;

DO

IF i # 2 THEN GOTO Fail ELSE {

EXITS Fail => ERROR CommanderOps.Failed[usageReregisterAs];

};

aList: List.AList;

key: REF ANY;

spec: RECORD [val: {list, rope}, place: {process, tool}] ~ SELECT cmd.procData.clientData FROM

argv: CommanderOps.ArgumentVector ¬ CommanderOps.Parse[cmd];

IF spec.place=process

IF spec.val=rope AND argv.argc # 3

};

result ¬ CommanderOps.DoCommand[commandLine: cmd.commandLine, parent: cmd];

};

seconds: CARD;

argv: CommanderOps.ArgumentVector ¬ CommanderOps.Parse[cmd];

IF argv.argc # 2 THEN {msg ¬ "Usage: Sleep seconds"; GO TO oops};

seconds ¬ Convert.CardFromRope[argv[1] ! Convert.Error => {msg ¬ "Bad arg"; GO TO oops}];

Process.Pause[Process.SecondsToTicks[seconds]];

EXITS oops => result ¬ $Failure;

};

fileStream: IO.STREAM ← NIL;

block: REF TEXT ← NEW[TEXT[512]];

{

EXITS oops => RETURN[$Failure, msg];

};

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

elapsedPulses: BasicTime.Pulses ¬ 0;

seconds: CARD ¬ 0;

startTime: BasicTime.GMT ¬ BasicTime.Now[];

startPulses: BasicTime.Pulses ¬ BasicTime.GetClockPulses[];

result ¬ CommanderOps.DoCommand[commandLine: cmd.commandLine, parent: cmd];

elapsedPulses ¬ BasicTime.GetClockPulses[] - startPulses;

seconds ¬ BasicTime.Period[from: startTime, to: BasicTime.Now[]];

IF seconds >= 10000

};

procData: Commander.CommandProcHandle;

n: INT ¬ 0;

FOR arg: ROPE ¬ CommanderOps.NextArgument[cmd], CommanderOps.NextArgument[cmd] UNTIL arg = NIL DO

IF n = 0 THEN { result¬$Failure; msg ¬ cmd.procData.doc };

};

commandToolData: CommanderBackdoor.CommandToolData ~ CommanderBackdoor.GetCommandToolData[cmd];

arg: ROPE ¬ CommanderOps.NextArgument[cmd];

sense: BOOL ¬ TRUE;

toggle: BOOL ¬ FALSE;

query: BOOL ¬ FALSE;

local: BOOL ¬ FALSE;

Do: PROC [old: BOOL] RETURNS [BOOL] = INLINE {

IF Rope.Equal[arg, "locally", FALSE] THEN {

SELECT TRUE FROM

FOR data: CommanderBackdoor.CommandToolData ¬ commandToolData, CommanderBackdoor.GetCommandToolData[data.parentCommander] UNTIL data = NIL DO

EXITS Usage => ERROR CommanderOps.Failed[cmd.procData.doc];

};

UNTIL aList = NIL DO

RETURN[dp];

};

IF any=NIL THEN out.PutRope["NIL"]

ELSE WITH any SELECT FROM

RETURN;

};

ENABLE Convert.Error => CommanderOps.Failed[cmd.procData.doc];

arg: ROPE ~ CommanderOps.NextArgument[cmd];

PutVersion[cmd.out, IF arg = NIL THEN 2 ELSE Convert.IntFromRope[arg]];

};

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

CommandObject = [

out: IO.STREAM = cmd.out;

SwitchIndex: TYPE = CHAR['a..'z];

switches: PACKED ARRAY SwitchIndex OF BOOL ← ALL[FALSE];

debug: BOOL ← FALSE;

args: LIST OF ROPE ← CommanderOps.ParseToList[cmd

zorch: ROPE ← NIL; -- holds the command to map

nTried: INT ← 0;

nFailed: INT ← 0;

WHILE args # NIL DO

IF switches['a] AND nFailed # 0 THEN GO TO oops;

IF switches['e] AND nFailed = nTried THEN GO TO oops;

EXITS oops => result ← $Failure;

};

P: PROC [i: INT] ~ { IF n > 0 THEN IO.PutF1[out, ".%g", [integer[i]]]; n ← n - 1 };

IO.Put1[out, [integer[SystemVersion.release.major]]]; n ← n - 1;

P[SystemVersion.release.minor];

P[SystemVersion.release.patch];

IO.PutRope[out, "\n"];

};

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

lenOld: INT = Rope.Size[old];

lenNew: INT = Rope.Size[new];

i: INT ¬ 0;

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

RETURN[base];

};

IF char = '\l OR char = '\r THEN RETURN[break];

RETURN[other];

};

Register: PROC [name: LONG STRING, proc: Commander.CommandProc, doc: LONG STRING, data: REF ¬ NIL, un: BOOL ¬ FALSE] = {

Register["GetProperties", PropertiesCommand, "Display command tool property list"];

Register["GetProcessProperties", PropertiesCommand, "Display process properties list", $ProcessProperties];

Register["SetProperty", SetPropertyCommand, "SetProperty propertyName value - change or add to the command tool property list"];

Register["SetProcessProperty", SetPropertyCommand, "SetProperty propertyName value - change or add to the process property list", $ProcessProperties];

Register["SetListProperty", SetPropertyCommand, "SetProperty propertyName elt elt ... - bind propertyName in the command tool property list to the LIST OF ROPE = [elt, elt, ...]", $List];

Register["SetListProcessProperty", SetPropertyCommand, "bind propertyName in the process property list to the LIST OF ROPE = [elt, elt, ...]", $ListProcessProperties];

Register["-", CommentCommand, "Comment", NIL, TRUE];

Register["--", CommentCommand, "Comment", NIL, TRUE];

Register["/", CommentCommand, "Comment", NIL, TRUE];

Register["//", CommentCommand, "Comment", NIL, TRUE];

Register["?", RegisteredHelpCommand, "List registered commands"];

Register["Abort", AbortCommand, "Abort -- Raises ABORTED"];

Register["Alias", AliasCommand, "Define a new command in terms of others, using blind string-matching for parameters.", NIL, TRUE];

Register["Aliases", AliasesCommand, "List all Aliases"];

Register["Answerback", AnswerbackCommand, "reads result and msg from command line"];

Register["Date", DateCommand, "Print date and time"];

Register["Echo", EchoCommand, "Print command line arguments\n\t-s supress whitespace\n\t-n no newline"];

Register["ERROR", ErrorCommand, "Error -- Raises unnamed ERROR"];

Register["Fail", FailCommand, "This command always fails"];

Register[";", FailSkipCommand, "Skip on failure"];

Register["Help", RegisteredHelpCommand, "List registered commands"];

Register["Indent", IndentCommand, "Indent n -- Indent n spaces", $Indent];

Register["PrefixLines", IndentCommand, "PrefixLines <string> - prefix each line of stdin with <string>", $PrefixLines];

Register["PrevResult", PrevResultCommand, "- print the result of the previous command"];

Register["ResultOf", ResultOfCommand, "<command> - print the result of the given command (uninterpreted)", NIL, TRUE];

Register["ReadTo", IndentCommand, "ReadTo <string> - Copy stdin to stdout until a line with just <string> is encountered.", $ReadTo];

Commander.Register["Synonym", ReregisterAsCommand, usageReregisterAs, NIL, TRUE];

Register["Shift", ShiftCommand, "Shift command-line (uninterpreted)", NIL, TRUE];

Register["ShiftInterp", ShiftCommand, "ShiftInterp command-line (interpreted)"];

Register["Command", ShiftCommand, "do command-line as a command"];

Register["Commander", CommanderCommand, "Make a nested commander"];

Register["Sleep", SleepCommand, "Sleep n -- pause for n seconds"];

Register["Time", TimeCommand, "Time command-line (uninterpreted)", NIL, TRUE];

Register["Unregister", UnregisterCommand, "Unregister commands\nUsage: Unregister commandname ..."];

Register["Verbose", ControlCommand, "Control command tracing (inverse of Terse)\nUsage: Verbose [locally] [on|off|toggle|?]", $Verbose];

Register["Terse", ControlCommand, "Control command tracing (inverse of Verbose)\nUsage: Terse [locally] [on|off|toggle|?]", $Terse];

Register["Statistics", ControlCommand, "Control statistics printing\nUsage: Statistics [locally] [on|off|toggle|?]", $Statistics];

Register["HistoryLog", ControlCommand, "Control history logging\nUsage: HistoryLog [locally] [on|off|toggle|?]", $HistoryLog];

Register["Version", VersionCommand, "Print Cedar version number"];

Register["ForegroundPriority", PriorityCommand, "(uninterpreted) Execute rest of command line at foreground priority", $Foreground, FALSE];

Register["BackgroundPriority", PriorityCommand, "(uninterpreted) Execute rest of command line at background priority", $Background, FALSE];

Register["NormalPriority", PriorityCommand, "(uninterpreted) Execute rest of command line at normal priority", $Normal, FALSE];

Commander.Register[key: "Redo", proc: RedoCommand, doc: "Redo <string> — redoes the last command that begins with string"];

Commander.Register[key: "History", proc: HistoryCommand, doc: "History <option>* <n> — lists the last n commands in this CommandTool viewer\n -%  omit % prompt\n +% include % prompt\n -d remove duplicate commands\n +d include duplicates"];

Commander.Register["Prop", PropCommand, docPropCommand];

Commander.Register["Map", MapCommand,
"maps the first argument as a command over the other arguments
-a return failure if any command fails
-e return failure if every command fails
-q quit on failure, return failure
-s quit on success, return success
"];

};