DIRECTORY Atom, Basics, BasicTime, List, CommanderBackdoor, CommanderRegistry, CommanderOps, Commander, CommanderSys, Convert, IO, ProcessProps, RefText, Rope, UXStrings;
CommanderOpsImpl: CEDAR MONITOR
IMPORTS Atom, BasicTime, List, Commander, CommanderRegistry, CommanderSys, Convert, IO, ProcessProps, RefText, Rope, UXStrings
EXPORTS CommanderOps, CommanderBackdoor
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;
ArgumentVector: TYPE ~ REF ArgumentVectorRep;
ArgumentVectorRep: TYPE ~ CommanderOps.ArgHandleObject;
QuoteTreatment: TYPE ~ CommanderOps.QuoteTreatment;
CommandToolData: TYPE ~ CommanderBackdoor.CommandToolData;
PrivateDataRep: PUBLIC TYPE ~ RECORD [
parseRecord: REF ParseRecord Ź NIL,
nestedMsg: ROPE Ź NIL -- used for inhibiting unwanted repetition of messages
];
doubleQuote: CHAR = '";	doubleQuoteRope: ROPE = Rope.FromChar[doubleQuote];
openParen: CHAR = '(;	openParenRope: ROPE = Rope.FromChar[openParen];
closeParen: CHAR = ');	closeParenRope: ROPE = Rope.FromChar[closeParen];
Failed: PUBLIC ERROR [errorMsg: ROPE] ~ CODE;

scratchRIS: IO.STREAM Ź NIL;
ObtainRIS: ENTRY PROC [rope: ROPE] RETURNS [ris: IO.STREAM] = {
ris Ź IO.RIS[rope, scratchRIS];
scratchRIS Ź NIL;
};
ReleaseRIS: ENTRY PROC [stream: IO.STREAM] = { scratchRIS Ź stream };

seprChars: REF READONLY TEXT Ź " \t\r\l";
breakChars: REF READONLY TEXT Ź "\"@|(,){;}";
CmdTokenBreak: PROC [char: CHAR] RETURNS [IO.CharClass] = {
FOR i: NAT IN [0..breakChars.length) DO
IF char = breakChars[i] THEN RETURN [break]
ENDLOOP;
FOR i: NAT IN [0..seprChars.length) DO
IF char = seprChars[i] THEN RETURN [sepr]
ENDLOOP;
RETURN [other]
};

Token: TYPE ~ CommanderOps.Token;
nullToken: Token ~ CommanderOps.nullToken;

GetCmdToken: PUBLIC PROC [stream: IO.STREAM] RETURNS [token: Token Ź nullToken] = {
skip: INT Ź 0;
token.start Ź IO.GetIndex[stream];
[token: token.value, charsSkipped: skip] Ź IO.GetTokenRope[stream, CmdTokenBreak ! IO.EndOfStream => CONTINUE];
token.start Ź token.start + skip;
token.literal Ź token.value;
SELECT TRUE FROM
Rope.Equal[token.value, doubleQuoteRope] => {
IO.Backup[self: stream, char: doubleQuote];
{  startIndex: INT ~ token.start Ź IO.GetIndex[stream];
rope: ROPE ~ IO.GetRopeLiteral[stream ! IO.Error, IO.EndOfStream => GOTO MisMatch];
length: INT ~ IO.GetIndex[stream] - startIndex;
token.value Ź rope;
IO.SetIndex[stream, startIndex];
token.literal Ź IO.GetRope[stream, length];
};
};
Rope.Equal[token.value, openParenRope] => {
startIndex: INT ~ token.start Ź IO.GetIndex[stream]-1;
DO
subtoken: Token ~ GetCmdToken[stream];
IF subtoken.literal = NIL THEN ERROR Failed["Unmatched parentheses in command line"];
IF Rope.Equal[subtoken.literal, closeParenRope] THEN {
length: INT ~ IO.GetIndex[stream] - startIndex;
IO.SetIndex[stream, startIndex];
token.literal Ź IO.GetRope[stream, length];
token.value Ź Rope.Substr[token.literal, 1, length-2];
EXIT;
};
ENDLOOP;
};
Rope.Equal[token.literal, "$"] => {
IF NOT IO.EndOf[stream] THEN SELECT IO.PeekChar[stream] FROM
doubleQuote, openParen => {
rest: Token ~ GetCmdToken[stream];
token.literal Ź token.value Ź Rope.Concat[token.literal, rest.literal];
};
ENDCASE;
};
ENDCASE => NULL;
EXITS MisMatch => ERROR Failed["Mismatched double quotes in command line"]
};

ParseToList: PUBLIC PROC [cmd: Commander.Handle, quoteTreatment: QuoteTreatment] RETURNS [list: LIST OF ROPE, length: NAT Ź 0] ~ {
head: LIST OF ROPE ~ LIST[ArgN[cmd, 0, quoteTreatment]];
last: LIST OF ROPE Ź head;
DO
arg: ROPE ~ NextArgument[cmd, quoteTreatment];
IF arg = NIL THEN EXIT;
last Ź last.rest Ź LIST[arg];
length Ź length + 1;
ENDLOOP;
list Ź head.rest;
head.rest Ź NIL;
};

Parse: PUBLIC PROC [cmd: Commander.Handle, quoteTreatment: QuoteTreatment] RETURNS [argv: ArgumentVector] ~ {
n: NAT ~ NumArgs[cmd]; 
argv Ź NEW[ArgumentVectorRep[n]];
argv[0] Ź ArgN[cmd, 0, quoteTreatment];
FOR i: NAT IN [1..n) DO
IF (argv[i] Ź NextArgument[cmd, quoteTreatment]) = NIL THEN ERROR;
ENDLOOP;
IF NextArgument[cmd, quoteTreatment] # NIL THEN ERROR;
};

ParseToTList: PROC [cmd: Commander.Handle] RETURNS [list: LIST OF Token, length: NAT Ź 0] ~ {
head: LIST OF Token ~ LIST[nullToken];
last: LIST OF Token Ź head;
cmds: IO.STREAM Ź ObtainRIS[cmd.commandLine];
DO
token: Token ~ GetCmdToken[cmds];
IF token.value = NIL THEN EXIT;
last Ź last.rest Ź LIST[token];
length Ź length + 1;
ENDLOOP;
list Ź head.rest;
head.rest Ź NIL;
ReleaseRIS[cmds];
};

ParseRecord: TYPE = RECORD [
argumentList: LIST OF Token Ź NIL,
argumentPointer: INT Ź 0,
argumentListTail: LIST OF Token Ź NIL,
commandLine: ROPE
];

GetParseRecord: PROC [cmd: Commander.Handle] RETURNS [pr: REF ParseRecord] ~ {
data: CommandToolData Ź GetCommandToolData[cmd];
private: REF PrivateDataRep Ź data.private;
pr Ź private.parseRecord;
IF pr = NIL OR pr.commandLine # cmd.commandLine THEN {
pr Ź NEW[ParseRecord Ź []];
pr.argumentListTail Ź pr.argumentList Ź ParseToTList[cmd].list;
pr.commandLine Ź cmd.commandLine;
private.parseRecord Ź pr;
};
};

NumArgs: PUBLIC PROC [cmd: Commander.Handle] RETURNS [n: INT Ź 1] ~ {
pp: REF ParseRecord Ź GetParseRecord[cmd];
FOR tail: LIST OF Token Ź pp.argumentList, tail.rest UNTIL tail = NIL DO n Ź n + 1 ENDLOOP;
};
NextArgument: PUBLIC PROC [cmd: Commander.Handle, quoteTreatment: QuoteTreatment] RETURNS [arg: ROPE Ź NIL] ~ {
pp: REF ParseRecord Ź GetParseRecord[cmd];
IF pp.argumentListTail = NIL THEN RETURN;
arg Ź SELECT quoteTreatment FROM
stripQuotes => pp.argumentListTail.first.value,
leaveQuotes => pp.argumentListTail.first.literal,
ENDCASE => ERROR;
pp.argumentListTail Ź pp.argumentListTail.rest;
pp.argumentPointer Ź pp.argumentPointer + 1;
};
ArgN: PUBLIC PROC [cmd: Commander.Handle, n: INT, quoteTreatment: QuoteTreatment] RETURNS [arg: ROPE Ź NIL] ~ {
pp: REF ParseRecord Ź GetParseRecord[cmd];
IF n = 0 THEN {
pp.argumentListTail Ź pp.argumentList;
pp.argumentPointer Ź 0;
RETURN [cmd.command]
};
n Ź n - 1;
IF n < 0 THEN RETURN [NIL];
IF n < pp.argumentPointer THEN {
pp.argumentListTail Ź pp.argumentList;
pp.argumentPointer Ź 0;
};
UNTIL n = pp.argumentPointer DO
IF pp.argumentListTail = NIL THEN RETURN [NIL];
pp.argumentListTail Ź pp.argumentListTail.rest;
pp.argumentPointer Ź pp.argumentPointer + 1;
ENDLOOP;
IF pp.argumentListTail = NIL THEN RETURN [NIL];
arg Ź SELECT quoteTreatment FROM
stripQuotes => pp.argumentListTail.first.value,
leaveQuotes => pp.argumentListTail.first.literal,
ENDCASE => ERROR;
pp.argumentListTail Ź pp.argumentListTail.rest;
pp.argumentPointer Ź pp.argumentPointer + 1;
};
PutProp: PUBLIC PROC [cmd: Commander.Handle, key, val: REF] ~ {
IF cmd # NIL THEN {
new: Atom.PropList Ź List.PutAssoc[key: key, val: val, aList: cmd.propertyList];
IF new # cmd.propertyList THEN ERROR Failed["PutProp failed"];
};
};

GetProp: PUBLIC PROC [cmd: Commander.Handle, key: REF] RETURNS [value: REF] ~ {
value Ź CommanderRegistry.GetProp[cmd, key];
IF value = NIL AND cmd # NIL THEN value Ź List.Assoc[key: key, aList: cmd.propertyList];
IF value = NIL THEN value Ź ProcessProps.GetProp[key];
IF value = NIL THEN WITH key SELECT FROM
atom: ATOM => { value Ź CommanderSys.GetEnv[Atom.GetPName[atom]] };
ENDCASE => NULL;
};

DoSubstitutions: PROC [cmd: Commander.Handle, rope: ROPE] RETURNS [ROPE] ~ {
size: INT Ź Rope.Size[rope];
index: INT Ź FindTerminator[rope, INT.LAST, "$", 0]+1;
length: NAT Ź 0;
FOR cur: INT Ź index, FindTerminator[rope, INT.LAST, "$", index]+1 UNTIL cur >= size DO
numeric: BOOL Ź TRUE;
subst: ROPE Ź NIL;
IF cur < size AND (SELECT Rope.Fetch[rope, cur] FROM doubleQuote, openParen => TRUE ENDCASE => FALSE)
THEN {
res: REF;
commandLine: ROPE Ź NIL; {
ris: IO.STREAM ~ ObtainRIS[rope];
IO.SetIndex[ris, cur];
commandLine Ź GetCmdToken[ris].value;
length Ź IO.GetIndex[ris] - cur;
ReleaseRIS[ris];
};
[subst, res] Ź DoCommandRope[commandLine: commandLine, parent: cmd];
IF res = $Failure THEN Failed[NIL];
subst Ź RemoveEOL[subst];
}
ELSE {
text: REF TEXT Ź RefText.ObtainScratch[100];
text.length Ź 0;
WHILE INT[cur + text.length] < size DO
c: CHAR ~ Rope.Fetch[rope, cur + text.length];
IF c IN ['A..'Z] OR c IN ['a..'z] OR c IN ['0..'9] OR c = '_
THEN {
text Ź RefText.AppendChar[text, c];
numeric Ź numeric AND c IN ['0..'9];
}
ELSE EXIT;
ENDLOOP;
IF numeric
THEN {
i: CARD Ź CARD.LAST;
i Ź Convert.CardFromRope[RefText.TrustTextAsRope[text] ! Convert.Error => CONTINUE];
WITH GetProp[cmd, $CommandFileArgumentVector] SELECT FROM
argv: ArgumentVector => {
IF i+1 < argv.argc THEN {
subst Ź argv[i+1];
};
};
ENDCASE => NULL;
}
ELSE {
atom: ATOM ~ Atom.MakeAtomFromRefText[text];
WITH GetProp[cmd, atom] SELECT FROM
rope: ROPE => subst Ź rope;
ENDCASE => NULL;
};
length Ź text.length;
RefText.ReleaseScratch[text];
};
IF subst # NIL
THEN {
rope Ź Rope.Replace[base: rope, start: cur-1, len: length+1, with: subst];
index Ź cur-1 + Rope.Size[subst];
size Ź Rope.Size[rope];
}
ELSE { index Ź cur + length };
ENDLOOP;
RETURN [rope]
};

FindTerminator: PROC [rope: ROPE, maxNest: INT, terminators: REF TEXT, start: INT Ź 0] RETURNS [INT] = {
IsTerminator: PROC [c: CHAR] RETURNS [BOOL] ~ INLINE {
FOR k: NAT IN [0..terminators.length) DO
IF c = terminators[k] THEN RETURN [TRUE];
ENDLOOP;
RETURN [FALSE]
};
end: INT ~ Rope.Size[rope];
i: INT Ź start;
state: {outside, insideQuotes} Ź outside;
nest: INT Ź 0;
WHILE i < end DO
c: CHAR ~ rope.Fetch[i];
SELECT state FROM
outside => {
SELECT c FROM
openParen => { nest Ź nest + 1 };
closeParen => { nest Ź nest - 1 };
doubleQuote => { state Ź insideQuotes };
ENDCASE => IF nest <= maxNest AND IsTerminator[c] THEN EXIT;
};
insideQuotes => {
IF c = '\\
THEN { i Ź i + 1 }
ELSE IF c = doubleQuote THEN {
IF end > (i + 1) AND rope.Fetch[i+1] = doubleQuote
THEN { i Ź i + 1 }
ELSE { state Ź outside };
};
};
ENDCASE => ERROR;
i Ź i + 1;
ENDLOOP;
IF state = insideQuotes THEN ERROR Failed["Mismatched double quotes in command line"];
RETURN [i]
};

GetPrivate: PROC [cmd: Commander.Handle] RETURNS [REF PrivateDataRep] ~ {
IF cmd # NIL THEN {
pd: CommandToolData ~ GetCommandToolData[cmd];
IF pd # NIL THEN RETURN [pd.private];
};
RETURN [NIL]
};

PutMsg: PROC [cmd: Commander.Handle, rope: ROPE] ~ {
data: CommandToolData ~ GetCommandToolData[cmd];
private: REF PrivateDataRep Ź GetPrivate[cmd];
parentPrivate: REF PrivateDataRep Ź GetPrivate[data.parentCommander];
IF rope # NIL AND cmd # NIL AND (private=NIL OR private.nestedMsg # rope) THEN {
len: INT ~ Rope.Size[rope];
IO.PutRope[cmd.err, rope];
IF len = 0 OR Rope.Fetch[rope, len-1] # '\n THEN { IO.PutRope[cmd.err, "\n"] };
};
IF parentPrivate # NIL THEN parentPrivate.nestedMsg Ź rope;
};

EnsureWhitespace: PROC [rope: ROPE] RETURNS [ROPE] ~ {
pre: ROPE ~ IF Rope.Match[" *", rope] THEN NIL ELSE " ";
post: ROPE ~ IF Rope.Match["*\n", rope] THEN NIL ELSE "\n";
RETURN [Rope.Cat[pre, rope, post]]
};

RemoveEOL: PROC [rope: ROPE] RETURNS [ROPE] ~ {
IF Rope.Match["*\n", rope] THEN rope Ź Rope.Substr[rope, 0, Rope.Size[rope]-1];
RETURN [IF rope = NIL THEN "" ELSE rope]
};

DoCommand: PUBLIC PROC [commandLine: ROPE, parent: Commander.Handle] RETURNS [result: REF] ~ {
cmd: Commander.Handle ~ CreateFromStreams[parentCommander: parent];
msg: ROPE Ź NIL;
[result: result, msg: msg] Ź ExecuteCommand[cmd, commandLine];
};
DoCommandRope: PUBLIC PROC [commandLine, in: ROPE Ź NIL, parent: Commander.Handle]
RETURNS [out: ROPE, result: REF] ~ {
outStream: IO.STREAM Ź IO.ROS[];
cmd: Commander.Handle ~ CreateFromStreams[in: IO.RIS[in], out: outStream, parentCommander: parent];
msg: ROPE Ź NIL;
[result: result, msg: msg] Ź ExecuteCommand[cmd, commandLine];
out Ź IO.RopeFromROS[outStream];
};
ProcessPropsDiffer: PROC [cmd: Commander.Handle] RETURNS [List.AList] ~ {
differ: List.AList Ź NIL;
Do: PROC [key, val: REF] ~ {
IF ProcessProps.GetProp[key] # val THEN differ Ź Atom.PutPropOnList[propList: differ, prop: key, val: val];
};
Do[$CommanderHandle, cmd];
Do[$StdIn, cmd.in];
Do[$StdOut, cmd.out];
Do[$ErrOut, cmd.err];
RETURN [differ]
};

CommandWithProcessProps: PROC [cmd: Commander.Handle] RETURNS [result: REF, msg: ROPE] ~ {
commandToolData: CommandToolData ~ GetCommandToolData[cmd];
differ: List.AList Ź ProcessPropsDiffer[cmd];
IF commandToolData = NIL OR commandToolData.verbose THEN {
IO.PutRope[cmd.err, " *** "];
IO.PutRope[cmd.err, cmd.command];
IO.PutRope[cmd.err, cmd.commandLine];
};
IF differ = NIL
THEN { [result: result, msg: msg] Ź cmd.procData.proc[cmd] }
ELSE {
Inner: PROC ~ { [result: result, msg: msg] Ź cmd.procData.proc[cmd] };
ProcessProps.AddPropList[propList: differ, inner: Inner];
};
};

ExecuteCommand: PUBLIC PROC [cmd: Commander.Handle, wholeCommandLine: ROPE]
RETURNS [result: REF Ź NIL, msg: ROPE Ź NIL] ~ {
residual: ROPE Ź wholeCommandLine;
data: CommandToolData ~ GetCommandToolData[cmd];
WHILE residual # NIL DO
data.private.nestedMsg Ź NIL;
BEGIN
ENABLE {
Failed => { msg Ź errorMsg; GOTO Failure };
};
line: ROPE ~ residual;
commandLineIndex: INT Ź 0;
command: ROPE Ź NIL; {
cmds: IO.STREAM Ź ObtainRIS[line];
command Ź IO.GetTokenRope[cmds, CmdTokenBreak ! IO.EndOfStream => CONTINUE].token;
commandLineIndex Ź IO.GetIndex[cmds];
ReleaseRIS[cmds];
cmds Ź NIL;
};
IF command = NIL THEN RETURN;
residual Ź NIL; -- in case CommandSetup raises an error
residual Ź CommandSetup[cmd, line, command, commandLineIndex];
[result: result, msg: msg] Ź CommandWithProcessProps[cmd];
EXITS
Failure => { result Ź $Failure };
END;
PutMsg[cmd, msg];
PutProp[cmd, $Result, result];
PutProp[cmd, $Msg, msg];
ENDLOOP;
};
DoLookup: PROC [cmd: Commander.Handle, command: ROPE] ~ {
unabbreviated: ROPE Ź command;
cmd.procData Ź Commander.Lookup[command];
IF cmd.procData = NIL THEN {
result: REF Ź NIL;
[result: result] Ź ExecuteBasicCommand[cmd: cmd, command: "PreRegister", commandLine: command !
Failed => ERROR Failed[Rope.Cat["Failed in PreRegister ", command, ": ", errorMsg]]
];
WITH result SELECT FROM
rope: ROPE => unabbreviated Ź rope;
ENDCASE => NULL;
cmd.procData Ź Commander.Lookup[unabbreviated];
IF cmd.procData = NIL THEN {
ERROR Failed[Rope.Cat["PreRegister ", command, " failed to register ", unabbreviated]];
};
};
cmd.command Ź unabbreviated;
};

CommandSetup: PROC [cmd: Commander.Handle, wholeCommandLine, command: ROPE, commandLineIndex: INT] RETURNS [residual: ROPE Ź NIL] ~ {
DoLookup[cmd, command];
IF NOT cmd.procData.interpreted
THEN { cmd.commandLine Ź EnsureWhitespace[Rope.Substr[base: wholeCommandLine, start: commandLineIndex]] }
ELSE {
redirectFrom: ROPE Ź NIL;
redirectTo: ROPE Ź NIL;
append: BOOL Ź FALSE;
skip: INT Ź 0;
NoteRedirection: PROC [pos: INT, in: BOOL] ~ {
SELECT Rope.Fetch[wholeCommandLine, pos-1] FROM
' , '\t => {
ris: IO.STREAM ~ ObtainRIS[wholeCommandLine];
fName: ROPE;
IF in AND redirectFrom # NIL THEN ERROR Failed["Error: Multiple input redirection"];
IF NOT in AND redirectTo # NIL THEN ERROR Failed["Error: Multiple output redirection"];
IO.SetIndex[ris, pos + 1];
IF NOT in AND NOT IO.EndOf[ris] AND IO.PeekChar[ris] = '> THEN {
append Ź TRUE;
[] Ź IO.GetChar[ris];
};
fName Ź GetCmdToken[ris].literal;
IF fName = NIL THEN ERROR Failed["Error: Invalid redirection syntax"];
fName Ź DoSubstitutions[cmd, fName];
IF in THEN redirectFrom Ź fName ELSE redirectTo Ź fName;
wholeCommandLine Ź Rope.Replace[base: wholeCommandLine, start: pos, len: IO.GetIndex[ris]-pos];
length Ź Rope.Size[wholeCommandLine];
ReleaseRIS[ris];
};
ENDCASE => { skip Ź 1 }; -- was not a redirection because no leading whitespace
};
length: INT Ź Rope.Size[wholeCommandLine];
break: INT Ź -1;
pipe: BOOL Ź FALSE;
FOR cur: INT Ź commandLineIndex, FindTerminator[wholeCommandLine, 0, "|;<>", cur+skip] WHILE cur < length DO
skip Ź 0;
SELECT Rope.Fetch[wholeCommandLine, cur] FROM
'; => { break Ź cur; EXIT };
'| => {
break Ź cur; pipe Ź TRUE;
IF redirectTo # NIL THEN ERROR Failed["Error: Multiple output redirection"];
EXIT;
};
'< => { NoteRedirection[pos: cur, in: TRUE] };
'> => { NoteRedirection[pos: cur, in: FALSE] };
ENDCASE => { skip Ź 1 }; -- should never happen
ENDLOOP;
IF break < 0 THEN break Ź length;
IF break < length THEN residual Ź Rope.Substr[base: wholeCommandLine, start: break];
IF pipe OR redirectTo # NIL OR redirectFrom # NIL
THEN {
DoLookup[cmd, "RedirectIO"];
cmd.commandLine Ź Rope.Cat[
IF redirectFrom # NIL THEN Rope.Concat[" -from ", redirectFrom] ELSE NIL,
IF redirectTo # NIL THEN Rope.Concat[IF append THEN " -append " ELSE " -to ", redirectTo] ELSE NIL,
IF pipe THEN " -pipe" ELSE NIL,
EnsureWhitespace[Rope.Substr[base: wholeCommandLine, start: 0, len: break]]];
}
ELSE {
cmd.commandLine Ź DoSubstitutions[cmd, EnsureWhitespace[Rope.Substr[base: wholeCommandLine, start: commandLineIndex, len: break-commandLineIndex]]];
};
};
};

ExecuteBasicCommand: PROC [cmd: Commander.Handle, command, commandLine: ROPE] RETURNS [result: REF, msg: ROPE] ~ {
cmd.command Ź command;
cmd.commandLine Ź EnsureWhitespace[commandLine];
cmd.procData Ź Commander.Lookup[command];
IF cmd.procData = NIL THEN {
ERROR Failed[Rope.Concat["Unknown command: ", command]];
};
[result: result, msg: msg] Ź CommandWithProcessProps[cmd];
IF result = $Failure THEN ERROR Failed[msg];
};
looksItalic: ROPE ~ "ABCDEFGHiJKLMNOPQRSTUVWXYZ";
PutItalics: PROC [stream: IO.STREAM, rope: ROPE] ~ {
IO.PutF[stream, "%l%g%l\n",
[rope[looksItalic]],
[rope[rope]],
[rope["I"]]
];
};

BeforeProcessing: PROC [cmd: Commander.Handle, startTime: CommanderSys.EGMT, commandLine: ROPE] ~ {
data: CommandToolData ~ GetCommandToolData[cmd];
IF data.recent = NIL THEN data.recent Ź NEW[CommanderBackdoor.CommandHistoryElement];
data.recent­ Ź [
commandNumber: data.recent.commandNumber+1,
wholeCommandLine: commandLine,
result: NIL,
msg: NIL,
startTime: startTime.gmt,
seconds: 0,
allocations: 0,
pageFaults: 0,
subHistory: NIL
];
IF data.Before # NIL THEN data.Before[cmd];
};

AfterProcessing: PROC [cmd: Commander.Handle, startTime: CommanderSys.EGMT, result: REF, msg: ROPE] ~ {
data: CommandToolData ~ GetCommandToolData[cmd];
endTime: CommanderSys.EGMT ~ CommanderSys.ExtendedNow[];
intSeconds: INT ~ BasicTime.Period[from: startTime.gmt, to: endTime.gmt];
microseconds: INT ~ endTime.usecs - startTime.usecs;
seconds: REAL ~ REAL[intSeconds] + REAL[microseconds]/1.0E+6;
IF data.recent = NIL THEN data.recent Ź NEW[CommanderBackdoor.CommandHistoryElement];
data.recent.result Ź result;
data.recent.msg Ź msg;
data.recent.seconds Ź seconds;
data.recent.subHistory Ź data.childHistory;
IF data.keepHistory THEN {
data.history Ź CONS[data.recent­, data.history];
data.childHistory Ź NIL;
IF data.parentCommander # NIL THEN GetCommandToolData[data.parentCommander].childHistory Ź data.history;
};
IF data.After # NIL THEN data.After[cmd];
};

ReadEvalPrintLoop: PUBLIC PROC [cmd: Commander.Handle] RETURNS [hadFailure: BOOL Ź FALSE] ~ {
data: CommandToolData ~ GetCommandToolData[cmd];
REPLoop: PROC ~ {
IF data.parentCommander # NIL THEN data.history Ź GetCommandToolData[data.parentCommander].childHistory;
DO
SetProcess[cmd, CommanderSys.CurrentProcess[]];
IF data.Prompt # NIL THEN data.Prompt[cmd];
BEGIN
result: REF Ź NIL;
msg: ROPE Ź NIL;
line: ROPE Ź IO.GetLineRope[stream: cmd.in !
IO.EndOfStream => EXIT;
IO.Rubout => GOTO Rubout;
];
startTime: CommanderSys.EGMT ~ CommanderSys.ExtendedNow[];
BeforeProcessing[cmd, startTime, line];
[result: result, msg: msg] Ź ExecuteCommand[cmd: cmd, wholeCommandLine: data.recent.wholeCommandLine !
UNWIND => {
AfterProcessing[cmd, startTime, $Failure, "Aborted"];
};
];
AfterProcessing[cmd, startTime, result, msg];
IF data.statistics THEN {
IO.PutF[cmd.out, " %l{ %6.2f sec }%l\n",
[rope["i"]],
[real[data.recent.seconds]],
[rope["I"]]
]
};
IF result = $Failure THEN {
hadFailure Ź TRUE;
IF data.stopOnFailure THEN EXIT;
};
EXITS
Rubout => { PutItalics[cmd.err, " -- <DEL>"]; IO.Reset[cmd.in] };
END;
ENDLOOP;
};
ProcessUNCAUGHT: PROC [sig: ROPE] RETURNS [reject: BOOL] ~ {
DO
action: ErrorAction;
commandLine: ROPE;
[action, commandLine] Ź ErrorPrompt[AdamOrEve[cmd], sig];
SELECT action FROM
continue => RETURN [reject: FALSE];
reject => RETURN [reject: TRUE];
command => [] Ź ExecuteCommand[cmd, commandLine];
ENDCASE => ERROR;
ENDLOOP;
};
REPBase: PROC ~ {
DO
ok: BOOL Ź TRUE;
aborted: BOOL Ź FALSE;
ok Ź CommanderSys.UNCAUGHTProtect[REPLoop, ProcessUNCAUGHT !
IO.Error => {
IF stream = cmd.in OR stream = cmd.err THEN CONTINUE
};
ABORTED => { SetProcess[cmd, NIL]; aborted Ź TRUE; ok Ź FALSE; CONTINUE }
];
IF ok THEN EXIT;
IF aborted THEN { PutItalics[cmd.err, " -- Aborted"]; IO.Reset[cmd.in] };
ENDLOOP;
SetProcess[cmd, NIL];
};
Action: PROC ~ IF AlreadyProtected[cmd] THEN REPLoop ELSE REPBase;
differ: List.AList ~ ProcessPropsDiffer[cmd];
IF differ = NIL
THEN Action[]
ELSE { ProcessProps.AddPropList[propList: differ, inner: Action] };
};
AdamOrEve: PUBLIC PROC [cmd: Commander.Handle] RETURNS [Commander.Handle] ~ {
THROUGH [0..1000) DO
data: CommandToolData ~ GetCommandToolData[cmd];
IF data = NIL OR data.parentCommander = NIL THEN RETURN [cmd];
cmd Ź data.parentCommander;
ENDLOOP;
ERROR; -- paranoia against circularities
};

AbortCommander: PUBLIC ENTRY PROC [cmd: Commander.Handle] ~ {
ENABLE UNWIND => NULL;
data: CommandToolData ~ GetCommandToolData[cmd];
IF data # NIL AND data.process # NIL AND data.process­ # NIL THEN {
CommanderSys.AbortProcess[data.process­];
};
};

SetProcess: PUBLIC ENTRY PROC [cmd: Commander.Handle, process: PROCESS] ~ {
data: CommandToolData ~ GetCommandToolData[cmd];
IF data # NIL AND data.process # NIL THEN { data.process­ Ź process };
};

AlreadyProtected: ENTRY PROC [cmd: Commander.Handle] RETURNS [BOOLEAN] ~ {
data: CommandToolData ~ GetCommandToolData[cmd];
RETURN [data # NIL AND data.process # NIL AND data.process­ = CommanderSys.CurrentProcess[]];
};

GetCommandToolData: PUBLIC PROC [cmd: Commander.Handle] RETURNS [CommandToolData] ~ {
WITH GetProp[cmd, cmd] SELECT FROM
data: CommandToolData => RETURN [data];
ENDCASE => RETURN [NIL];
};

ErrorAction: TYPE ~ {continue, reject, command};
ErrorPrompt: PROC [cmd: Commander.Handle, sig: ROPE] RETURNS [errorAction: ErrorAction Ź continue, commandLine: ROPE Ź NIL] ~ {
ENABLE IO.Error, IO.EndOfStream, IO.Rubout => GOTO SkipIt;
in: IO.STREAM ~ cmd.in;
out: IO.STREAM ~ cmd.err;
IO.PutRope[out, "\n*** Uncaught ERROR or SIGNAL: "];
IO.PutRope[out, sig];
WITH GetProp[cmd, "DebugUNCAUGHT"] SELECT FROM
rope: ROPE => {
SELECT TRUE FROM
Rope.Equal[rope, "n", FALSE] => RETURN [continue];
Rope.Equal[rope, "y", FALSE] => RETURN [reject];
ENDCASE => NULL;
};
ENDCASE => NULL;
IO.PutRope[out, "\n*** Do you want to try to debug this? (y, n, s <flags>, ! <command>, or ?) "];
IO.Flush[out];
SELECT IO.PeekChar[in] FROM
'\r, '\n => [] Ź IO.GetChar[in];
ENDCASE;
DO
line: ROPE ~ IO.GetLineRope[in];
c: CHAR ~ IF Rope.IsEmpty[line] THEN '? ELSE Rope.Fetch[line, 0];
SELECT c FROM
'n, 'N => RETURN [continue];
'y, 'Y => RETURN [reject];
's, 'S => RETURN [command, Rope.Concat["StackTrace", Rope.Substr[line, 1]]];
'! => RETURN [command, Rope.Substr[line, 1]];
ENDCASE => IO.PutRope[out, "\n*** Type 'y' to REJECT the signal and land in the system debugger, 'n' to get back to top level, 's <flags>' to invoke the StackTrace command, '! <command>' to execute a commander command and return to the error prompt: "];
ENDLOOP;
EXITS
SkipIt => RETURN [continue];
};
defaultPrompt: ROPE Ź "Commander %l%% %l";
DefaultPrompter: PROC [cmd: Commander.Handle] ~ {
prompt: ROPE ~ WITH GetProp[cmd, $Prompt] SELECT FROM
rope: ROPE => rope,
ENDCASE => defaultPrompt;
IO.PutF[cmd.err, prompt, [rope["b"]], [rope["B"]]];
};

CreateFromStreams: PUBLIC PROC [in, out, err: IO.STREAM Ź NIL, parentCommander: Commander.Handle Ź NIL] RETURNS [cmd: Commander.Handle] ~ {
data: CommandToolData Ź NEW[CommanderBackdoor.CommandToolDataRep];
init: PROC [cmd: Commander.Handle] Ź NIL;
oldPropList: Atom.PropList Ź NIL;
data.private Ź NEW[PrivateDataRep];
cmd Ź NEW[Commander.CommandObject];
IF parentCommander = NIL
THEN {
data.Prompt Ź DefaultPrompter;
data.keepHistory Ź TRUE;
}
ELSE {
p: CommandToolData Ź GetCommandToolData[parentCommander];
IF in = NIL THEN in Ź parentCommander.in;
IF out = NIL THEN out Ź parentCommander.out;
IF err = NIL THEN err Ź parentCommander.err;
IF p # NIL THEN {
data.Lookup Ź p.Lookup;
data.verbose Ź p.verbose;
init Ź p.InitChild;
data.process Ź p.process;
data.keepHistory Ź p.keepHistory;
};
data.parentCommander Ź parentCommander;
oldPropList Ź parentCommander.propertyList;
};
IF data.process = NIL THEN data.process Ź NEW[PROCESS Ź NIL];
IF in = NIL THEN in Ź IO.noInputStream;
IF out = NIL THEN out Ź IO.noWhereStream;
IF err = NIL THEN err Ź out;
cmd.in Ź in;
cmd.out Ź out;
cmd.err Ź err;
cmd.propertyList Ź CONS[NEW[Atom.DottedPairNode Ź [key: cmd, val: data]], oldPropList];
IF init # NIL THEN init[cmd];
};

XRDoCommanderCommands: PROC [commandLine: POINTER TO Basics.RawChars] RETURNS [BOOL] ~ {
cmd: Commander.Handle ~ CreateFromStreams[in: IO.RIS[UXStrings.ToRope[commandLine]]];
RETURN ReadEvalPrintLoop[cmd];
};
ExternalNames: PROC = TRUSTED MACHINE CODE {
"^ExternalNames\n";
"XRDoCommanderCommands XR_DoCommanderCommands\n";
};
ExternalNames[];


END.

Ź &v Ź ViewerIO.CreateViewerStreams[name: "CommanderOps"];
Ź CommanderOpsImpl.ReadEvalPrintLoop[CommanderOpsImpl.CreateFromStreams[in: &v.in, out: &v.out]]

   ^  
CommanderOpsImpl.mesa
Copyright Ó 1989, 1990, 1991 by Xerox Corporation.  All rights reserved.
Michael Plass, July 23, 1992 10:39 am PDT
Last changed by Pavel on April 30, 1990 1:29 pm PDT
Swinehar, December 11, 1990 3:31 pm PST
Willie-s, July 9, 1992 12:53 pm PDT


Properties maintained or used by this module:
Commander properties:
Prompt
Result
Msg
CommandFileArgumentVector
DebugUNCAUGHT
Process Properties:
CommanderHandle
StdIn
StdOut
ErrOut

Constants
Errors
Tokenizing
-- This allocates rather awfully; clean up when possible. - mfp
Parsing (Public)
The arguments to the command.
position of next argument to fetch
List of unfetched arguments
used to check if the command line has been parsed already for the current command


Properties and Substitution
Strictly, I suppose we should register the rest of this stuff back with CommanderRegistry, but it hardly seems worth it to me - mfp
Returns the index of the first terminator, skipping quoted strings.
Execution


Sets up cmd, including PreRegister if needed; raises Failed if there is a problem.
Executes with a minimum of bells&whistles; raises Failed if there is a problem.

Read-Eval-Print Loop
CommanderBackdoor Procedures
Backstop Error Catcher
Creation
C Language Hook
A simple (minded?) hook for doing a command from a c program.  No frills; useful for installation code inside packaged worlds.
Ę$X  NewlineDelimiter
(cedarcode) style codeK
Ďe=HK)K3K'K#K Ďk	v)ŞK KĎnKM(~K 'K KK-K 7K3K%:&K#KĎc6LKhead-KKKKKKKKKK 	KKKEKH
-K 
K	?KKK


EK K)K-
;'K+K&K)KKKK K!
*K 
SKK"K+&oK!!KStartOfExpansion6[pattern: ROPE, object: ROPE, case: BOOL _ TRUE]--K[self: STREAM, char: CHAR])+7KSK/KK K+KK++K6K?K&&K1U.6K/K K+K66KKKK#<K"KGKKKKK3JKK 9
	K	8KK%.KKKKKKKK 9mKK!K''K1BKK%6KK 	]K	&KK-K!!KKKKKKKKK 	"KK""	&KKQQKK NK00K	+K"6KK??K!!KKKK 
	EK#*K$[KK 9oK#*K) K//K11KK//K,,KK "oK#*K&&KKKK
K K&&KKK
/K//K,,KK
/ K//K11KK//K,,KK #?5[key: REF ANY, val: REF ANY, aList: List.AList]KPPK>KKK 	OK,,KK
	7XK	#6	(K9CKKK 
LKK6KWK	KeK	K!KK%%K	 KKKDK#KKK,K&K'.


<K##K
$KK
K
KKJT*9KKKKKK",#KKKKKK	KJJK!!KKKKKKK 	hKC6(K)KKKKK	K)K	KK!K"K(K
<K
K2KKKKKK
KK4VK
KK 	
IK..K%KKKK 4K00K	".K3E
PKKK	OKK ;KK 
6K8K;K"KK 
	/K0OK
(KK 	
^KCCKK>>KK 
wK	 K./cKK>>K5[key: REF ANY, val: REF ANY, aList: List.AList] KK IKK!DkKKKKKK	KK 

ZK;;K--:KK!K#%K
K8<K;FK99KKK +
|K
"K00KK+KKK	K"K
$RK%KKKKK '7K>>K::K!!KK5[key: REF ANY, val: REF ANY, aList: List.AList]KK5[key: REF ANY, val: REF ANY, aList: List.AList]KKK "9KK))K__K
DSKK#KK//KRWKKKKK 4JRKKeiKKKK.%/K-KK
-TK.WK@K	KKK!!K	-FK$K8KI_K%%KKK 6OKK*KKKlK		#-KKK.LKKK&.K&/K /KK!K>T	1KK
&IKcK
KMMKKKKKK /
rKOKK00K))K38KK::K,KK K 1


4KKKKKK 1cK00K*UK++KKK	KKKKKKK+KK 
1
gK00K8K:IK#4K	=K*UKKKK++K0KKFhKK)KK ]K00KFhK//K+KK,KKKK:K''ffK55KKK--&(KKKKKKK KK.AKKK

<KKK99K
#K

 K11KKKKK	<K4KK
IKKK	'IKKKK
		BK--
K	K?CK	MK00K>KKK !(KK =KK00CK))KKK 

"KK00K
FKK 
JK00K
	0]KK U"K'KKK K04K
:K
KK24K.K2K
0KKKK_aKK KK K	AK
K

K
<LK!-KđýKK
KK*15K	KK13KK &K'BK)K!K#K#KKKK99K)K,K,KKKKK!!KK''K++KK=K'K)KKKKK<WKKK XK~K.!UKK
,KK1KK K KK K::K``K      a´  j  