<<>> <> <> <> <> <> <> <<>> 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 <<-- This allocates rather awfully; clean up when possible. - mfp>> 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, " -- "]; 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 , ! , 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 ' to invoke the StackTrace 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]]