DIRECTORY
AMEvents USING [CallDebugger],
Atom USING [MakeAtom, GetProp, PutProp],
CIFS USING [Error, Open, GetFC, read],
ConvertUnsafe USING [AppendRope, ToRope],
Directory USING [Lookup, GetProps, Error],
File USING [Capability, nullCapability],
FileIO USING [Open, OpenFailed],
IO USING [CR, EndOf, EndOfStream, SyntaxError, Close, Flush, GetBlock, GetIndex, GetLength, int, GetCedarToken, PutChar, PutF, PutRope, ROPE, rope, RIS, SetIndex, SP, STREAM, TAB, GetToken, WhiteSpace, SkipOver, UserAborted],
IOExtras USING [GetCedarScannerToken, FromTokenProc],
Loader USING [Instantiate, Start, Error],
PrincOps USING [ControlModule],
Process USING [GetCurrent],
Rope USING [Cat, Concat, Equal, Fetch, Find, IsEmpty, Length, Replace, Substr, Text],
RopeInline USING [NewText],
RTProcess USING [GetTotalPageFaults, StartWatchingFaults],
SafeStorage USING [NWordsAllocated],
ShowTime USING [GetMark, Microseconds, Show],
System USING [GreenwichMeanTime],
Time USING [Current],
TiogaOps USING [AddLooks, CreateSimplePattern, FirstChild, GetRope, GoToPreviousCharacter, InsertChar, IsComment, Location, Next, NodeSearch, Paste, Pattern, Ref, SaveSpanForPaste, ViewerDoc, SelectPoint, LastLocWithin],
TiogaExtraOps USING [GetFile],
UserExec USING [HistoryEvent, ExecHandle, CheckForAbort, UserAbort, UserAborted, GetTheFile, GetStreams, ErrorThisEvent, GetDefaultExecHandle],
UserExecExtras USING [CreateEvent, NewErrorThisEvent],
UserExecPrivate USING [AcquireExec, EventFailed, ReleaseExec, Prompt, UpdateFrameCache, ExecPrivateRecord, StripComments, CreateSubEvent, methodList, MethodList, GetPrivateStuff, BlinkIcon, HistoryEventPrivateRecord],
UserProfile USING [Boolean, CallWhenProfileChanges, ProfileChangedProc],
ViewerClasses USING [Viewer],
ViewerOps USING [FindViewer]
;


UserExecMiscImpl: CEDAR PROGRAM 

IMPORTS AMEvents, Atom, CIFS, ConvertUnsafe, Directory, FileIO, IO, IOExtras, Loader, Rope, RopeInline, RTProcess, SafeStorage, ShowTime, Time, UserExec, Process, TiogaOps, TiogaExtraOps, UserExecExtras, UserExecPrivate, UserProfile, ViewerOps

EXPORTS UserExec, UserExecExtras, UserExecPrivate  

= BEGIN OPEN IO;
ExecHandle: TYPE = UserExec.ExecHandle;
HistoryEvent: TYPE = UserExec.HistoryEvent ;
ExecPrivateRecord: PUBLIC TYPE = UserExecPrivate.ExecPrivateRecord;
HistoryEventPrivateRecord: PUBLIC TYPE = UserExecPrivate.HistoryEventPrivateRecord;
DoIt: PUBLIC PROC [input: ROPE, exec: ExecHandle _ UserExec.GetDefaultExecHandle[], partOf: HistoryEvent _ NIL] = {
private: REF UserExecPrivate.ExecPrivateRecord;
execOwner: UNSAFE PROCESS;
event, subEvent: HistoryEvent;
privateEvent, privateSubEvent: REF UserExecPrivate.HistoryEventPrivateRecord;
abortIfSubEventFails: BOOLEAN;
start, current: INT _ 0;
length: INT;
mark: ShowTime.Microseconds _ 0; 
t0: System.GreenwichMeanTime;
nWords: LONG CARDINAL _ 0;
nFaults: INT _ 0; 
Release: PROC = TRUSTED {  -- Process
IF exec # NIL AND private.execState # destroyed AND UserExecPrivate.ReleaseExec[exec] THEN {
IF private.process = Process.GetCurrent[] THEN ERROR;
private.eventState _ readyForNext; 
IF private.execState = listening THEN UserExecPrivate.Prompt[private.eventNum, exec];
};
};
{ENABLE UNWIND => Release[];

ShowStats: PROC = {
IF showStats AND exec # NIL AND NOT private.dontPrompt THEN
 {
out: STREAM = UserExec.GetStreams[exec].out;
nw: INT _ SafeStorage.NWordsAllocated[] - nWords;
t: System.GreenwichMeanTime;
seconds: LONG CARDINAL;
nf: INT;
Put: PROC [char: CHAR] RETURNS[BOOL _ FALSE] = {out.PutChar[char]};
out.PutF["*n   {"]; 
TRUSTED {t _ Time.Current[]};
seconds _ t - t0;
IF seconds > 60 THEN {
out.PutF["%d minutes, %d seconds", int[seconds/60], int[seconds MOD 60]];
}
ELSE {
ShowTime.Show[from: mark, p: Put, places: 2]; 
out.PutRope[" seconds"];
};
IF nw > 0 AND nw < 10000000 THEN out.PutF[", %d words", int[nw]]; 
TRUSTED {nf _ RTProcess.GetTotalPageFaults[] - nFaults};
IF nf > 0 AND nf < 10000000 THEN  out.PutF[", %d page faults", int[nf]]; 
out.PutChar['}];
};
};

IF exec # NIL THEN {
private _ UserExecPrivate.GetPrivateStuff[exec];
execOwner _ private.execOwner;
IF UserExecPrivate.AcquireExec[exec] THEN TRUSTED {  -- Process 
IF private.process = Process.GetCurrent[] THEN ERROR; -- since Read Eval Print acquires exec first, this must be an event coming in from somewhere else.
IF private.execState = notListening OR private.execState = dormant THEN { 
IF partOf # NIL THEN privateEvent _ partOf.privateStuff;
UserExecPrivate.Prompt[
IF partOf # NIL THEN privateEvent.eventNum ELSE private.eventNum,  -- if partof was specified, then use its eventNumber.
exec];
}
ELSE IF private.eventState = readyForNext THEN private.eventState _ running
ELSE ERROR;
UserExec.GetStreams[exec].out.PutRope[input];
};
};
event _ IF partOf # NIL THEN partOf ELSE UserExecExtras.CreateEvent[exec, input];
subEvent _ event;
privateEvent _ event.privateStuff;
privateSubEvent _ subEvent.privateStuff;
length _ Rope.Length[input];
DO
stream: STREAM;
substr: ROPE _ NIL;
whiteSpace: BOOLEAN _ TRUE;
UserExec.CheckForAbort[exec];
IF current = length THEN EXIT;
start _ current;
WHILE current < length DO
char: CHARACTER _ Rope.Fetch[input, current];
TerminatesAtCurrent: PROC RETURNS[BOOL] = {
count: INT _ start;
fromTokenProc: IOExtras.FromTokenProc = {
count _ count + token.next;
IF token.kind = tokenCOMMENT AND closure.proc[closure.data, token.next - 1] = '\n  
THEN count _ count - 1;  -- cr is (incorrectly) included in comment. without this check, test would say that CR is not a legitimate terminator in this case
};
stream _ RIS[input, stream];
IO.SetIndex[stream, start];
IF NOT Rope.Equal[IO.GetCedarToken[stream! IO.EndOfStream => GOTO Yes], "_"] THEN RETURN[TRUE];
IO.SetIndex[stream, start];
DO
IOExtras.GetCedarScannerToken[stream, fromTokenProc !
IO.SyntaxError => CONTINUE  
];
IF count = current - 1 THEN GOTO Yes -- stopped just before the desired place.
ELSE IF count >= current THEN GOTO No;
ENDLOOP;
EXITS
No => RETURN[FALSE];
Yes => RETURN[TRUE];
};
current _ current + 1;
SELECT char FROM
SP => IF whiteSpace THEN start _ current; -- necessary (aesthetic) for compound events
'\\ => current _ current + 1; -- from the standpoint of terminating the input, ignore next character.
CR, TAB => {
IF whiteSpace THEN {start _ current; LOOP}
ELSE IF start = 0 AND current = length THEN substr _ input -- typical case
ELSE IF current = length OR TerminatesAtCurrent[] THEN substr _ Rope.Substr[base: input, start: start, len: current - start]
ELSE LOOP;
abortIfSubEventFails _ FALSE;
EXIT;
}; 
'; => {
IF  current = length OR TerminatesAtCurrent[] THEN {
substr _ Rope.Concat[Rope.Substr[base: input, start: start, len: current - start - 1], "\n"]; -- convert ; to CR so commands can all assume they are given a single line terminated by a CR.
abortIfSubEventFails _ TRUE;
EXIT;
};
}; 
ENDCASE => whiteSpace _ FALSE;
REPEAT
FINISHED => substr _ Rope.Substr[input, start, current]; -- e.g. terminate in ?
ENDLOOP; -- of WHILE loop that breaks into segments.

BEGIN
ENABLE {
IO.UserAborted => {
privateEvent.state _ aborted;
privateSubEvent.state _ aborted;
ShowStats[];
};  -- let error go through
UserExec.ErrorThisEvent => {
IF NOT Rope.IsEmpty[msg] THEN UserExec.GetStreams[exec].out.PutF["*n*e%g*s", rope[msg]];
privateEvent.state _ causedAnError; 
privateSubEvent.state _ causedAnError;
IF exec.viewer.iconic THEN UserExecPrivate.BlinkIcon[exec.viewer];
ShowStats[];
IF NOT abortIfSubEventFails THEN LOOP;  -- and go on with next subevent.
};  -- otherwise let error go through.
UserExecExtras.NewErrorThisEvent => {
IF NOT Rope.IsEmpty[msg] THEN UserExec.GetStreams[exec].out.PutF["*n*e%g*s", rope[msg]];
privateEvent.state _ causedAnError; 
privateSubEvent.state _ causedAnError;
UserExecPrivate.EventFailed[event: event, offender: offender];
IF exec.viewer.iconic THEN UserExecPrivate.BlinkIcon[exec.viewer];
ShowStats[];
IF NOT abortIfSubEventFails THEN LOOP;  -- and go on with next subevent.
};  -- otherwise let error go through.
UNWIND => {
privateEvent.state _ causedAnError;
privateSubEvent.state _ causedAnError;
IF exec.viewer.iconic AND private.execState # dormant THEN UserExecPrivate.BlinkIcon[exec.viewer];
};
};
inRopeStream: STREAM = RIS[rope: substr];
line: ROPE;
firstToken: ROPE;
firstToken _ IO.GetToken[inRopeStream];
IF Rope.IsEmpty[firstToken] THEN
{IF event # NIL AND event.subEvents = NIL AND current = length AND exec # NIL THEN private.continuation _ TRUE;
LOOP; --  white space on line in compound event.
};
IF event # NIL AND (event.subEvents # NIL OR current # length OR input # event.input) THEN { -- second case says this is a compound event. third says came from command file, where input field is @file and input (obtained from private.input) is the expansion  
subEvent _ UserExecPrivate.CreateSubEvent[event: event, input: substr];
privateSubEvent _ subEvent.privateStuff;
UserExec.GetStreams[exec].out.PutF["*n"];  -- if previous event caused some output, want this to go on fresh line. See comments in userexecimpl regarding LogNewLine as to why just don't call NewLine directly.
};
line _ UserExecPrivate.StripComments[event, substr];
IF line # substr THEN -- some comments
{[] _ RIS[rope: line, oldStream: inRopeStream];
IO.SkipOver[inRopeStream, IO.WhiteSpace];
IF inRopeStream.EndOf[] THEN {privateSubEvent.state _ completed; LOOP}; -- nothing there but a comment. 
};
subEvent.commandLine _ line;
subEvent.commandLineStream _ inRopeStream;
mark _ ShowTime.GetMark[]; 
nWords _ SafeStorage.NWordsAllocated[];
TRUSTED {t0 _ Time.Current[]; nFaults _ RTProcess.GetTotalPageFaults[]};
IF privateSubEvent.showInput THEN UserExec.GetStreams[exec].out.PutF["*n>%g", rope[line]];
FOR lst: UserExecPrivate.MethodList _ UserExecPrivate.methodList, lst.rest UNTIL lst = NIL DO
subEvent.commandLine _ line;
[] _ RIS[rope: line, oldStream: subEvent.commandLineStream]; -- load commandLineStream. Have to do it each time because the method might read from the commandLine before it determines that it is not applicable.
IF lst.first.proc[event: subEvent, exec: exec, clientData: lst.first.clientData] THEN
EXIT;
REPEAT
FINISHED => ERROR UserExecExtras.NewErrorThisEvent[event: subEvent, msg: Rope.Concat[firstToken, " not a command.\n"], offender: firstToken];
ENDLOOP; -- methodlist loop
END; -- of process substr.

ShowStats[];
privateSubEvent.state _ completed;
ENDLOOP; -- substr loop
privateEvent.state _ completed;
Release[];
};
}; -- DoIt


EventFailed: PUBLIC PROC[event: HistoryEvent, msg: ROPE _ NIL, offender: ROPE _ NIL] = {
privateEvent: REF UserExecPrivate.HistoryEventPrivateRecord = event.privateStuff;
IF NOT Rope.IsEmpty[msg] THEN ERROR UserExecExtras.NewErrorThisEvent[event, msg, offender]
ELSE privateEvent.offender _ offender;
};

RopeFromCMFile: PUBLIC PROC [file: ROPE, event: HistoryEvent, exec: ExecHandle] RETURNS[contents: ROPE, name: ROPE] =
{ENABLE FileIO.OpenFailed => {
SELECT why FROM
fileNotFound =>
{
name _ UserExec.GetTheFile[file: file, defaultExt: "cm", event: event, exec: exec];
IF name # NIL THEN {contents _ RopeFromFile[name]; CONTINUE};
name _ UserExec.GetTheFile[file: file, defaultExt: "commands", event: event, exec: exec];
IF name # NIL THEN {contents _ RopeFromFile[name]; CONTINUE};
};
illegalFileName => NULL;
ENDCASE => REJECT;
ERROR UserExecExtras.NewErrorThisEvent[event: event, msg: Rope.Concat[fileName, " not found"], offender: fileName];
}; 

length: INT;
IF Rope.Fetch[file, 0] = '@ THEN file _ Rope.Substr[file, 1]; -- strip off @
length _ Rope.Length[file];
IF length = 0 THEN RETURN;
IF Rope.Fetch[file, length - 1] = '@ THEN file _ Rope.Substr[base: file, len: length - 1]; -- strip off trailing @
name _ file;
contents _ NIL;
contents _ RopeFromFile[fileName: file ! FileIO.OpenFailed =>
IF why = fileNotFound AND Rope.Find[file, "."] = -1 THEN
{name _ Rope.Concat[file, ".cm"]; CONTINUE}
];
IF contents # NIL THEN RETURN;
contents _ RopeFromFile[fileName: name ! FileIO.OpenFailed =>
IF why= fileNotFound  THEN
{name _ Rope.Concat[file, ".commands"]; CONTINUE}
];
IF contents # NIL THEN RETURN;
contents _ RopeFromFile[fileName: name];
};


RopeFromFile: PROC [fileName: ROPE] RETURNS [value: ROPE] = TRUSTED {  -- LOOPHOLE
handle: IO.STREAM _ FileIO.Open[fileName: fileName, accessOptions: read, createOptions: oldOnly]; 
length: LONG INTEGER _ handle.GetLength[];
text: Rope.Text _ RopeInline.NewText[length];
[] _ handle.GetBlock[LOOPHOLE[text, REF TEXT]];
IO.Close[handle];
RETURN[text];
}; 

StripComments: PUBLIC PROC [event: UserExec.HistoryEvent, rope: ROPE] RETURNS [ROPE] = {
pos1, pos2: INT _ 0;
IF Rope.Find[s1: rope, s2: "//"] # -1 THEN UserExec.ErrorThisEvent[event, "// convention for comments no longer implemented. Use -- instead."];
pos1 _ 0;
WHILE (pos1 _ Rope.Find[s1: rope, s2: "--", pos1: pos1]) # -1 DO
pos3: INT _ Rope.Find[s1: rope, s2: "--", pos1: pos1 + 2];
pos2 _ Rope.Find[s1: rope, s2: "\n", pos1: pos1];
IF pos2 = -1 THEN pos2 _ Rope.Length[rope];
IF pos3 = -1 THEN pos3 _ Rope.Length[rope] ELSE pos3 _ pos3 + 2;
rope _ Rope.Replace[base: rope, start: pos1,
len: MIN[pos2, pos3] - pos1];
ENDLOOP;
RETURN[rope];
};

CorrectionDisabled: PUBLIC PROC[event: HistoryEvent] RETURNS[disabled: BOOL] = {
RETURN[IF event = NIL THEN FALSE ELSE event.dontCorrect];
};
PrintDeclFromSource: PUBLIC PROC [target: ROPE, file: ROPE, exec: UserExec.ExecHandle] RETURNS [value: BOOLEAN] = {
out: IO.STREAM = UserExec.GetStreams[].out;
fileAtom: ATOM = Atom.MakeAtom[file];
doc: TiogaOps.Ref;
viewer: ViewerClasses.Viewer;
pattern: TiogaOps.Pattern;
start, end: TiogaOps.Location;
found, inline: BOOL;
r: ROPE;
stream: IO.STREAM;
inner: PROC [root: TiogaOps.Ref] = {
TRUSTED {doc _ LOOPHOLE[Atom.GetProp[atom: fileAtom, prop: $Root]]};
IF doc # NIL THEN NULL
ELSE IF (viewer _ ViewerOps.FindViewer[file]) # NIL THEN doc _ TiogaOps.ViewerDoc[viewer]
ELSE Atom.PutProp[atom: fileAtom, prop: $Root, val: doc _ TiogaExtraOps.GetFile[file ! CIFS.Error => CONTINUE]];
IF doc = NIL THEN {value _ FALSE; RETURN};
pattern _ TiogaOps.CreateSimplePattern[target];  -- does CreateSimplePattern ignore comments?
start _ [doc, 0];
DO
PrintChildren: PROC [node: TiogaOps.Ref, onlyComments: BOOL _ FALSE] = {
child: TiogaOps.Ref _ TiogaOps.FirstChild[node];
UserExec.CheckForAbort[exec];
DO
IF child = NIL THEN RETURN
ELSE IF (onlyComments OR NOT inline) AND NOT TiogaOps.IsComment[child] THEN RETURN
ELSE { 
IF Rope.IsEmpty[TiogaOps.GetRope[child]] THEN onlyComments _ TRUE 
ELSE Show[child];
PrintChildren[child, onlyComments];
};
child _ TiogaOps.Next[child];
ENDLOOP;
};
Show: PROC [node: TiogaOps.Ref, start: INT _ 0, end: INT _ -1] = {
r: ROPE = TiogaOps.GetRope[node];
len: INT = Rope.Length[r];
UserExec.CheckForAbort[exec];
IF end = -1 THEN end _ len;
TiogaOps.InsertChar['\n];
TiogaOps.GoToPreviousCharacter[]; -- If we are at the end of the typescript, Paste will act like a stuff, which is not what we want
TiogaOps.SaveSpanForPaste[startLoc: [node, start], endLoc: [node, end]];
TiogaOps.Paste[];
IF TiogaOps.IsComment[node] THEN TiogaOps.AddLooks["c"];
TiogaOps.SelectPoint[viewer: exec.viewer, caret: TiogaOps.LastLocWithin[TiogaOps.ViewerDoc[exec.viewer]]];  -- go to end. assumes that only one node in typescript.
};
i: INT;
UserExec.CheckForAbort[exec];
[found, start, end] _ TiogaOps.NodeSearch[pattern: pattern, startLoc: start, endLoc: start];
IF NOT found THEN {value _ FALSE; RETURN};
r _ TiogaOps.GetRope[start.node];
IF TiogaOps.IsComment[start.node] THEN {  -- work around until CreateSimplePattern can take comment argument, or CreateGeneralPattern can take rope argument
start.where _ Rope.Length[r];  -- skip to end. StepForward no good as this would cause match not to succeed if the target was the first thing in the next node, e.g. IO.Put?
LOOP;
};
stream _ IO.RIS[r, stream];
IO.SetIndex[stream, end.where + 1];
i _ start.where;
WHILE i > 0 DO
i _ i - 1;
SELECT Rope.Fetch[r, i] FROM
'\n, '; => EXIT;
'  => LOOP;
ENDCASE => GOTO NotDecl;
REPEAT
NotDecl => {start _ end; LOOP};
ENDLOOP;
DO
token: ROPE = IO.GetCedarToken[stream ! IO.EndOfStream => GOTO NotDecl];
IF Rope.Equal[token, ":"] THEN {start.where _ IO.GetIndex[stream]; EXIT};  -- Yes
IF Rope.Equal[token, ","] THEN {[] _ IO.GetCedarToken[stream ! IO.EndOfStream => GOTO NotDecl]; LOOP};  -- e.g. Foo, Fie: type = ...
GOTO NotDecl;
REPEAT
NotDecl => {start _ end; LOOP};
ENDLOOP;
out.Flush[];
IF start.node # TiogaOps.FirstChild[doc] THEN {  -- node structure being used
inline _ TiogaOps.NodeSearch[pattern: TiogaOps.CreateSimplePattern["INLINE"], startLoc: start, endLoc: TiogaOps.LastLocWithin[start.node]].found;
Show[start.node, start.where];
PrintChildren[start.node];
}
ELSE {
end: INT = FindEnd[r, start.where];
inline _ TiogaOps.NodeSearch[pattern: TiogaOps.CreateSimplePattern["INLINE"], startLoc: start, endLoc: [start.node, end]].found;
Show[start.node, start.where, end];
};
TiogaOps.SelectPoint[viewer: exec.viewer, caret: TiogaOps.LastLocWithin[root]];  -- go to end. assumes that only one node in typescript.
value _ TRUE;
RETURN;
ENDLOOP;
};
inner[TiogaOps.ViewerDoc[exec.viewer]];
}; -- of PrintDeclFromSource 


FindEnd: PROC [nodeRope: ROPE, start: INT] RETURNS[end: INT] = {
i: INT;
inComment: BOOL _ FALSE;
blankLine: BOOL _ FALSE;
thisChar, lastChar: CHARACTER;
i _ Rope.Find[nodeRope, ";", start] + 1;
IF i = -1 THEN RETURN[Rope.Length[nodeRope]];
DO
lastChar _ thisChar;
thisChar _ Rope.Fetch[nodeRope, i];
i _ i + 1;
SELECT thisChar FROM
'- => { 
blankLine _ FALSE;
IF lastChar = '- THEN inComment _ NOT inComment;
end _ i -1;
};
'\n => {
IF blankLine THEN RETURN; -- blank line, usually indicates end of commented area. Subsequent comments between here and end probably refer to what follows.
blankLine _ TRUE;
inComment _ FALSE;
};
' , '\t => NULL;
ENDCASE => { 
blankLine _ FALSE;
IF ~inComment THEN RETURN;
end _ i -1;
}; -- anything seen outside of a comment means terminate.

ENDLOOP;
};  

FileNotFound: PUBLIC SIGNAL [name: ROPE, defaultExt: ROPE _ NIL] RETURNS [shouldBe: ROPE] = CODE;

RunBCDFile: PUBLIC PROCEDURE[fileName: ROPE, fileCapability: File.Capability _ File.nullCapability, callDebuggerFirst: BOOL _ FALSE, out: STREAM] RETURNS[name: ROPE, error: ROPE] = {
ENABLE
FileNotFound => RESUME[SIGNAL FileNotFound[name: fileName, defaultExt: "bcd"]];
warnings: ROPE;
IF fileCapability # File.nullCapability THEN name _ fileName
ELSE IF Rope.Find[s1: fileName, s2: "."] = -1 
THEN name _ Rope.Concat[fileName, ".bcd"]
ELSE name _ fileName;
[name, error, warnings] _ LoadAndGo[name, fileCapability, callDebuggerFirst];
IF error # NIL THEN
error _ Rope.Cat[error, ": ", fileName]
ELSE {
IF warnings # NIL THEN out.PutF["*n*m%g*s\n", rope[warnings]];
out.PutF["*nLoaded and started: %g\n", rope[name]];
};
};

LoadAndGo: PROC [fileName: ROPE, fileCapability: File.Capability, callDebuggerFirst: BOOL _ FALSE] RETURNS [name, error, warnings: ROPE] =  TRUSTED {  -- ConvertUnsafe
ls: LONG STRING = [100]; 
cm: PrincOps.ControlModule;
unboundImports: BOOLEAN;
IF fileCapability = File.nullCapability THEN {
IF Rope.Find[fileName, ">"] # -1 OR Rope.Find[fileName, "/"] # -1 THEN {  -- use cifs
err: ROPE;
fileCapability _ CIFS.GetFC[CIFS.Open[name: fileName, mode: CIFS.read ! CIFS.Error => TRUSTED {
err _ error;
CONTINUE;
};
]];
error _ err;
}
ELSE {
ConvertUnsafe.AppendRope[to: ls, from: fileName];
fileCapability _ Directory.Lookup[ls ! Directory.Error => {
SELECT type FROM
invalidFileName	=> error _ "Illegal file name";
fileNotFound	=> { 
fileName _ NARROW[SIGNAL FileNotFound[NIL, NIL]];  -- going to be caught in RunBCDFile and the appropriate arguments to the signal filled in .
IF fileName # NIL THEN {
ls.length _ 0;
ConvertUnsafe.AppendRope[to: ls, from: fileName];
RETRY;
};
error _ "Couldn't find a runnable file named";
};
ENDCASE	=> error _ "Lookup failed on";
CONTINUE;
}
];
};
};
IF error = NIL THEN [cm, unboundImports] _ Loader.Instantiate[file: fileCapability, offset: 1, codeLinks: TRUE ! Loader.Error => {
error _ SELECT type FROM
invalidBcd => "Invalid Bcd",
fileNotFound => "File Not Found",
versionMismatch => "Version MisMatch",
loadStateFull => "Load State Full, Can't Load",
insufficientVM => "Insufficient VM",
ENDCASE => ERROR;
IF message # NIL THEN error _ Rope.Cat[error, ": ",  ConvertUnsafe.ToRope[LOOPHOLE[message, LONG STRING]]];
CONTINUE;
}
];
IF error = NIL THEN {
IF ls.length # 0 THEN [] _ Directory.GetProps[fileCapability, ls ! Directory.Error => CONTINUE];
name _ IF ls.length # 0 THEN ConvertUnsafe.ToRope[ls]  -- GetProps writes the full name into the long string.
ELSE fileName;
};
IF error = NIL THEN { 
IF callDebuggerFirst THEN AMEvents.CallDebugger[Rope.Concat["Loaded ", name]];
Loader.Start[cm ! ABORTED => {error _ "Execution Aborted"; CONTINUE}];
};  
UserExecPrivate.UpdateFrameCache[];
IF unboundImports THEN warnings _ "(there are unbound imports)";
};

showStats: PUBLIC BOOLEAN _ FALSE;

SetShowStats: UserProfile.ProfileChangedProc = TRUSTED {  -- RTProcess
showStats _ UserProfile.Boolean["ShowStatistics", FALSE];
IF showStats THEN RTProcess.StartWatchingFaults[];
};

UserProfile.CallWhenProfileChanges[SetShowStats];

END. -- of UserExecMiscImpl

August 20, 1982 1:37 pm fixed LoadAndGo to use Loader.Instantiate and Loader.Start instead of Runtime.RunConfig.	


öLast Edited by: teitelman, May 23, 1983 6:31 pm 
Types
connecting concrete and opaque types
to access currentEvent, dontPrompt, continuation in DoIt, currentEvent in CorrectionEnabled
processing individual events
break input up into segments delimited by cr or ;
-- current is one beyond the character just read. We want to know if that character, e.g. CR could be the terminator. Therefore, we want to test and see if the scan stopped just before that character.
'' => current _ current + 1; -- from the standpoint of terminating the input, ignore next character. Whether ' or ^ is interpreted as special for command line will have to wait until we decide if this is a command or an expression.
'^ =>
SELECT Rope.Fetch[input, current - 2] FROM
SP, '\n, '\t => current _ current + 1; -- compromise. ^{cr} could end a line consisting of a mesa expression. Therefore, only give ^ its special interpretation (a la Alto exec) when preceded by white space. 
ENDCASE;
otherwise, keep going, e.g. CR is in middle of rope. current = length check says if this is the end of the rope, no point in calling ProperlyTerminated
otherwise, keep going, e.g. ; is in middle of rope.
process substr
first try just filename
no extension specified, try .cm
no extension specified, try .commands
Think about using RopeIO
WHILE (pos1 _ Rope.Find[s1: rope, s2: "//", pos1: pos1]) # -1 DO
pos2 _ Rope.Find[s1: rope, s2: "\n", pos1: pos1];
IF pos2 = -1 THEN pos2 _ Rope.Length[rope];
rope _ Rope.Replace[base: rope, start: pos1, len: pos2 - pos1 + 1];
ENDLOOP;
looking up declarations in file
 idea is to avoid printing out a procedure which happens to be a child of this node but do want to print out inline definitions (non-comment children) and do want to print out comments that are separated by empty nodes. Thus as soon as you see an empty node, only consider comments subsequently.
ELSE {
out.PutRope[IF start = 0 AND end = len THEN r ELSE Rope.Substr[base: r, start: start, len: end - start]];
out.PutChar['\n];
};
TiogaOps.CallWithLocks[proc: inner, root: TiogaOps.ViewerDoc[exec.viewer]];  -- check when bill is here as to why this locks up
running bcds 
printing statistics
Edited on December 14, 1982 11:40 pm, by Teitelman
changed catch phrase, eliminating ANY, moving corresponding stuff to UNWIND. problem with informational signals when planting breakpoints under DoIt
changes to: DoIt
Edited on ile userexecmiscimpl
compile userexecmisDecember 22, 1982 12:00 pm, by Teitelman
changes to: DIRECTORY, IMPORTS, DoIt
Edited on January 21, 1983 4:10 pm, by Teitelman
changes to: DoIt, Release (local of DoIt)
Edited on January 23, 1983 5:08 pm, by Teitelman
changes to: DoIt
Edited on March 6, 1983 2:42 pm, by Teitelman
changes to: DIRECTORY, DoIt, RopeFromCMFile
Edited on March 10, 1983 3:07 am, by Teitelman
changes to: DIRECTORY, EXPORTS, IMPORTS, DoIt, RopeFromCMFile

Edited on March 13, 1983 2:27 pm, by Teitelman
changes to: DoIt
Edited on March 31, 1983 3:32 pm, by Teitelman
changes to: DoIt
Edited on April 7, 1983 2:42 pm, by Teitelman
changes to: DIRECTORY, RunBCDFile, LoadAndGo, UserProfile, IMPORTS

Edited on April 15, 1983 3:27 pm, by Teitelman
changes to: DoIt
Edited on April 20, 1983 10:00 am, by Teitelman
changes to: DoIt, EventFailed, RopeFromCMFile, DIRECTORY, LoadAndGo, DIRECTORY, ShowStats (local of DoIt), DIRECTORY, IMPORTS, ShowStats (local of DoIt), DIRECTORY, ShowStats (local of DoIt)









Edited on May 13, 1983 1:03 pm, by Teitelman
changes to: LoadAndGo
Edited on May 23, 1983 6:31 pm, by Teitelman
changes to: ShowStats (local of DoIt)

�Ê1–

"Cedar" style˜J™0š
Ïk	˜	Jšœ	�œ˜Jšœ�œ˜(Jš�œ
�œ˜&Jšœ�œ˜)Jšœ
�œ˜*Jšœ�œ˜(Jšœ�œ˜ Jš�œ
�œ�œ|�œ�œ�œ�œ�œ/˜á
Jšœ	�œ'˜5Jšœ�œ˜)Jšœ	�œ˜Jšœ�œ˜Jšœ�œK˜UJšœ�œ˜Jšœ
�œ+˜:Jšœ�œ˜$Jšœ	�œ˜-Jšœ�œ˜!Jšœ�œ˜Jšœ	�œÎ
˜Ü
Jšœ�œ˜Jšœ	�œ�
˜�
Jšœ�œ"˜6Jšœ�œÄ
˜Ù
Jšœ�œ7˜HJšœ�œ
˜Jšœ
�œ
˜J˜
J˜—J˜JšÐblœ�œ
�œ
˜ J˜Jš�œ9�œ±
˜ó
J˜Jš�œ,˜3J˜Jšœ
�œ
�œ
�œ
˜
head™JšÏn
œ�œ˜'JšŸœ�œ˜,š
œ$™$šŸœ�œ
�œ%˜CJ™[—JšŸœ�œ
�œ-˜S——š
œ™š
Ÿœ�œ
�œ	�œM�œ˜sJšœ	�œ#˜/Jšœ�œ
�œ
˜Jš
œ˜Jšœ�œ+˜MJšœ�œ
˜Jšœ�œ˜Jšœ�œ
˜J˜!J˜Jšœ�œ
�œ˜Jšœ	�œ˜šŸœ�œ�œÏc
˜%š�œ�œ
�œ�œÐboœ�˜\Jš�œ(�œ
�œ
˜5Jš
œ#˜#Jš�œ�œ0˜UJ˜—J˜—šœ
�œ
�œ˜J˜—šŸ	œ�œ˜š�œ�œ�œ
�œ
�œ�˜;š
œ˜Jšœ�œ!˜,Jšœ�œ*˜1J˜Jšœ	�
œ
˜Jšœ�œ
˜JšŸœ�œ�œ�œ
�œ�œ˜CJš
œ˜Jš�œ˜Jš
œ˜š�œ�œ˜Jšœ@�œ˜IJ˜
—š�œ˜J˜.Jš
œ˜Jš
œ˜—Jš�œ�œ�œ"˜BJš�œ1˜8Jš�œ�œ�œ)˜IJš
œ˜J˜—J˜——J˜š�œ�œ
�˜Jš
œ0˜0Jš
œ˜š	�œ¡œ�œ
�œ ˜@Jš�œ(�œ
� c˜˜
š�œ"�œ�œ
˜JJš�œ
�œ
�œ$˜8š
œ˜Jš	�œ
�œ
�œ�œ 5˜xJš
œ˜—J˜
—Jš�œ
�œ#�œ˜KJš�œ
�œ
˜Jš
œ-˜-J˜—J˜—Jš	œ�œ
�œ
�œ�œ)˜QJ˜J˜"J˜(J˜Jš
 1™1š
�˜Jšœ�œ
˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜Jš
œ˜Jš�œ�œ
�œ
˜J˜š�œ�˜Jšœ�	œ˜-šŸœ�œ
�œ
�œ˜+Jšœ�œ	˜šŸ
œ˜)Jš
œ˜š�œ�œ3˜SJš�œ ‚
˜›
—J˜—Jšœ	�œ˜Jš�œ˜Jš�œ
�œ�œ�œ�œ�œ
�œ
�œ˜_Jš�œ˜š
�˜š
œ5˜5Jš�œ�œ˜Jš
œ˜—Jš
œÈ
™È
Jš�œ�œ
�œ )˜NJš�œ
�œ�œ
�œ˜&Jš�œ
˜—š
�˜Jšœ�œ
�œ˜Jšœ�œ
�œ˜—J˜—J˜š�œ�˜Jš�œ�œ�œ ,˜VJšœ Ê
™ç
™š�œ �™*Jš�œ% ¨
™Ï
Jš�œ
™——Jšœ G˜eš�œ˜Jš�œ�œ�œ
˜*Jš	�œ
�œ�œ�œ ˜JJš�œ
�œ�œ�œF˜|Jš�œ
�œ
˜
Jšœ�œ
˜š�œ
˜J™—
—Jš
œ˜—˜š�œ�œ�˜4Jšœ^ ^˜¼
Jšœ�œ
˜Jš�œ
˜Jš
œ˜J™3—Jš
œ˜—Jš�œ�œ
˜—Jš
�˜Jš�œ1 ˜OJš�œ +˜4——J˜Jš
 ™š
�˜š
�˜˜J˜Jš
œ ˜ Jš
œ˜Jšœ ˜—˜Jš�œ
�œ�œ;˜XJš
œ$˜$Jš
œ&˜&Jš�œ�œ(˜BJš
œ˜Jš	�œ
�œ�œ
�œ  ˜HJšœ "˜&—˜%Jš�œ
�œ�œ;˜XJš
œ$˜$Jš
œ&˜&J˜>Jš�œ�œ(˜BJš
œ˜Jš	�œ
�œ�œ
�œ  ˜HJšœ "˜&—š�œ˜Jš
œ#˜#Jš
œ&˜&Jš�œ�œ�œ(˜bJš
œ˜—J˜—Jšœ�œ�œ˜)Jšœ�œ
˜Jšœ�œ
˜J˜'š�œ�˜ Jšœ
�œ	�œ
�œ�œ
�œ�œ�œ
�œ�œ
˜oJš�œ *˜0J˜—š�œ	�œ
�œ�œ
�œ�œ�œ
 ¦
˜ƒJ˜GJš
œ(˜(Jšœ+ ¥
˜Ð
J˜—Jš
œ4˜4š�œ�œ
 ˜&Jšœ�œ&˜/J˜)Jš�œ�œ%�œ  ˜hJ˜—Jš
œ˜Jš
œ*˜*J˜Jš
œ'˜'Jš�œA˜HJš�œ�œ9˜Zš�œH�œ�œ
�˜]Jš
œ˜Jšœ�œ5 •
˜Ò
š�œO�˜UJš�œ
˜—Jš
�˜Jš�œ�œ|˜�
Jš�œ ˜—Jš�œ ˜—J˜Jš
œ˜Jš
œ"˜"Jš�œ ˜Jš
œ˜Jš
œ
˜
Jš
�˜Jš�
œ ˜
J˜—J˜šŸœ�œ
�œ�
œ�œ�œ˜XJšœ�œ@˜QJš�œ
�œ�œ
�œ7˜ZJš�œ"˜&J˜—J˜šŸœ�œ
�œ�œ)�œ�œ�œ˜ušœ
�œ˜š�œ�˜˜˜
J˜SJš�œ�œ
�œ!�œ˜=J˜YJš�œ�œ
�œ!�œ˜=J˜——Jšœ�œ
˜Jš�œ�œ
˜—Jš�œn˜s˜J˜——Jšœ�œ
˜Jš�œ�œ ˜LJ˜Jš�œ�œ
�œ
˜Jš�œ#�œ2 ˜rJš
 ™J˜Jšœ�œ
˜˜=š�œ�œ�˜8Jšœ"�œ
˜+—J˜—Jš�œ�œ
�œ
�œ
˜Jš
 ™˜=š�œ�˜Jšœ(�œ
˜1—J˜—Jš�œ�œ
�œ
�œ
˜Jš
 %™%Jš
œ(˜(J˜J˜—Jš
Ÿ™J˜š
Ÿœ�œ�œ�œ	�œ�œ ˜RJšœ�œ
�œQ˜bJšœ�œ
�œ˜*J˜-Jšœ�œ�œ
�œ˜/J˜Jš�œ˜
Jš�
œ˜J˜—šŸ
œ�œ
�œ&�œ�œ�œ˜XJšœ�œ˜š�œ9�™@J™1Jš�œ�œ™+J™CJš�œ
™—Jš�œ$�œe˜�
J˜	š�œ9�˜@Jšœ�œ1˜:J˜1Jš�œ�œ˜+Jš�œ�œ�œ˜@˜,Jšœ�œ˜—Jš�œ
˜—Jš�œ˜
J˜J˜—šŸœ�œ�œ�œ˜PJš�œ
�œ	�œ
�œ
�œ
�œ˜9J˜——™šŸœ�œ
�œ�œ�œ	�œ˜sJšœ�œ
�œ˜+Jšœ
�œ˜%Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
�œ
˜šŸœ�œ˜$Jš�œ�œ-˜DJš�œ�œ
�œ
�˜Jš�œ
�œ)�œ
�œ!˜YJ•StartOfExpansion/[atom: 
ATOM, prop: 
REF ANY, val: 
REF ANY]š�œS�œ
�œ˜pJš
�œ�œ
�œ
�œ�œ˜*J˜]Jš
œ˜š
�˜šŸ
œ�œ$�œ�œ˜HJ˜0J˜š
�˜Jš�œ	�œ
�œ
�˜Jš�œ
�œ�œ
�œ	�œ
�œ�œ
�˜Rš�œ˜Jš�œ'�œ�œ
˜BJšœ
 Ú
œL™§Jš�œ
˜Jš
œ#˜#J˜—Jš
œ˜Jš�œ
˜—J˜—šŸœ�œ�œ�œ
˜BJšœ�œ˜!Jšœ�œ˜J˜Jš�œ
�œ˜Jš
œ˜Jšœ" a˜ƒ
Jš
œH˜HJš
œ˜Jš�œ�œ˜8Jšœl 7˜£
š�œ™Jš	œ�œ�œ�œ�œ7™iJ™J™—J˜—Jšœ�œ
˜J˜Jš
œ\˜\Jš
�œ
�œ�œ
�œ�œ˜*Jš
œ!˜!š�œ �œ r˜œ
Jšœ �
˜¬
Jš�œ
˜Jš
œ˜—Jšœ	�œ
�œ˜Jš�œ!˜#Jš
œ˜š�œ�˜Jš
œ
˜
š�œ�˜Jšœ�œ
˜Jš
�˜Jš�œ�œ	˜—Jš
�˜Jšœ�œ˜Jš�œ
˜—š
�˜Jš	œ�œ�œ�œ�œ
˜HJš	�œ�œ�œ�œ ˜QJš
�œ�œ�œ�œ�œ�œ ˜„
Jš�œ	˜
Jš
�˜Jšœ�œ˜Jš�œ
˜—J˜š�œ'�œ ˜MJš
œ‘
˜‘
Jš
œ˜Jš
œ˜J˜
—š�œ˜Jšœ�œ˜#Jš
œ€
˜€
Jš
œ#˜#J˜—JšœQ 7˜ˆ
Jšœ�œ
˜
Jš�œ
˜Jš�œ
˜—Jš
œ˜—J™J˜'Jšœ ˜J˜—J˜šŸœ�œ�œ	�œ�œ�œ˜@Jšœ�œ
˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜Jšœ�	œ
˜Jš
œ(˜(Jš�œ�œ
�œ˜-š
�˜J˜Jš
œ#˜#Jš
œ
˜
š�œ
�˜Jš
œ˜Jšœ�œ
˜Jš�œ�œ
�œ˜0Jš
œ˜Jš
œ˜š
œ˜Jš�œ�œ
�œ €
˜š
Jšœ�œ
˜Jšœ�œ
˜Jš
œ˜—Jšœ�œ
˜š�œ˜
Jšœ�œ
˜Jš�œ�œ
�˜Jš
œ˜Jšœ 6˜9—J˜—Jš�œ
˜—Jšœ 
˜J˜——š
œ
™
JšŸœ�œ
�œ�œ�œ�œ�œ�œ�œ
˜aJ˜šŸ
œ�œ
�	œ�œL�œ�œ�œ�œ�œ	�œ˜¶
š
�˜Jšœ�œ
�œ2˜O—Jšœ
�œ
˜Jš�œ&�œ˜<š�œ'˜.Jš�œ%˜)—Jš�œ˜Jš
œM˜Mš�œ	�œ
�˜J˜'—š
�˜Jš�œ�œ
�œ(˜>Jš
œ3˜3J˜—Jš�
œ
˜J˜—šŸ	œ�œ�œ6�œ�œ�œ�œ�œ ˜§
Jšœ�œ
�	œ�
 
˜J˜Jšœ�œ
˜š�œ&�œ˜.š�œ�œ�œ ˜UJšœ�œ
˜
šœ�œ�œ�œ�œ
�œ˜_Jš
œ˜Jš�œ
˜	Jš
œ˜Jš
œ˜—J˜J˜
—š�œ˜Jš
œ1˜1š
œ;˜;š�œ�˜J˜/˜Jš
œ�œ
�œ�œ�œ [˜Ž
š�œ�œ
�˜Jš
œ˜Jš
œ1˜1Jš
�˜Jš
œ˜—J˜.J˜—Jš�œ˜&—Jš
�	˜	Jš
œ
˜
J˜—J˜—J˜—š�œ	�œ
�œW�œ˜‚
šœ�œ�˜J˜J˜!J˜&J˜/J˜$Jš�œ�œ
˜—Jš�œ�œ
�œ5�œ
�œ
�œ˜kJš
�	˜	Jš
œ
˜
Jš
œ˜—š�œ	�œ
�˜Jš�œ�œA�œ˜`Jšœ�œ�œ 6˜mJš�œ
˜J˜—š�œ	�œ
�œ
˜Jš�œ�œ5˜NJšœ�œ"�œ˜FJš
œ˜—Jš
œ#˜#Jš�œ�œ*˜@Jš�
œ
˜—J˜—™JšŸ	œ�œ
�œ�œ
˜"J˜šŸœ#�œ ˜FJšœ2�œ˜9Jš�œ�œ!˜2J˜—J˜J˜1—J˜Jš�œ ˜J˜J˜qJ˜š
�2™2J™”
JšœÏr™—š
�Z™ZJšœ¢™$—š
�0™0Jšœ¢
œ™)—™0Jšœ¢™—™-Jšœ¢™+—™.Jšœ¢1™=—J™™.Jšœ¢™—™.Jšœ¢™—™-Jšœ¢6™B—J™™.Jšœ¢™—™/Jšœ¢Mœ¢œ¢œ™¾
—J™J™J™J™J™J™J™J™J™™,Jšœ¢	™—™,Jšœ¢	œ™%—J™—…—R¢xÉ