RETURN RunInternal[bcdName, runEvenIfAlreadyRun, runEvenIfUnbound]};

given: ROPE ~ PFS.RopeFromPath[PFS.AbsoluteName[PFS.PathFromRope[name]]];

baseStart: INT ~ given.FindBackward["/"]+1;

afterBase: INT ~ given.SkipTo[baseStart, ".!"];

moduleName: ROPE ~ given.Substr[start: baseStart, len: afterBase-baseStart];

hasExt: BOOL ~ given.Find[".", baseStart] >= 0;

startFind: CARD ~ BasicTime.GetClockPulses[];

searchResult: SearchResult ~ FindWithHacks[given, quote, preferOptimized, baseStart, afterBase, Append];

findPulses: CARD ~ BasicTime.GetClockPulses[] - startFind;

torun: PATH ~ searchResult.torun;

unixName: ROPE ~ PFS.PFSNameToUnixName[torun];

install: IL.SymEntry ¬ NIL;

start: IL.SymEntry ¬ NIL;

thisFile: IL.FileEntry ¬ NIL;

thisTime: BasicTime.GMT ¬ BasicTime.nullGMT;

thisSize: CARD ¬ 0;

hasInstall, hasStart: BOOL;

ilPulses, libPulses, commitPulses, installPulses, runPulses: CARD ¬ 0;

dont: BOOL ¬ FALSE;

wasAborted: BOOL ¬ FALSE;

Append: PROC [err: BOOL, fmt: ROPE, v: LIST OF IO.Value] ~ CHECKED {

Bitch: PROC [format: ROPE] ~ CHECKED {

BitchAsErr: PROC [format: ROPE] ~ CHECKED {

TestErr: UNSAFE PROC [ile: IL.Error, from: ROPE] RETURNS [BOOL] ~ {

Seconds: PROC[p: BasicTime.Pulses] RETURNS[REAL] ~ CHECKED INLINE {

Inner: PROC = TRUSTED {

Start of body

LibSearch.Crock1[];

IF torun=NIL THEN {

Process.CheckForAbort[];

IF TestErr[IL.LockIncrementalLoadState[TRUE], "Lock"] THEN RETURN[error: TRUE];

Inner[ ! UNWIND => [] ¬ TestErr[IL.UnlockIncrementalLoadState[], "UNWIND Unlock"]];

[] ¬ TestErr[IL.UnlockIncrementalLoadState[], "Unlock"];

IF error OR dont THEN RETURN;

hasInstall ¬ install#NIL AND thisFile.seqNum = install.fe.seqNum;

hasStart ¬ start#NIL AND thisFile.seqNum = start.fe.seqNum;

IF hasInstall THEN {

IF hasStart THEN {

[] ¬ SymTab.Store[runInfoTab, unixName, NEW[RunInfo ¬ [unixName: unixName, torun: torun, moduleName: moduleName, hasInstall: hasInstall, hasStart: hasStart]]];

SELECT TRUE FROM

IF printTimings THEN Append[FALSE, "\t(find=%5.2f il=%5.2f lib=%5.2f c=%5.2f inst=%5.2f run=%5.2f)", LIST[ [real[Seconds[findPulses]]], [real[Seconds[ilPulses]]], [real[Seconds[libPulses]]], [real[Seconds[commitPulses]]], [real[Seconds[installPulses]]], [real[Seconds[runPulses]]] ]];

IF wasAborted THEN ERROR ABORTED; -- propagate abort

RETURN;

};

globalUndefineds ¬ CONS[ UXStrings.ToRope[se.name], globalUndefineds ];

RETURN[TRUE]

};

FOR se ¬ IL.LookupSymEntry[UXStrings.Create[Rope.Concat[prefix, name]], FALSE], IL.GetPrevSymEntry[se, FALSE] UNTIL se=NIL DO

se ¬ se;

};

all: RopeList ~ IF quote THEN LIST["Foo"] ELSE WITH ProcessProps.GetProp[$RunPatterns] SELECT FROM

ctrLen: INT ~ Rope.Length[centerPat];

FOR hackRules: RopeList ¬ all, hackRules.rest WHILE hackRules#NIL DO

RETURN [[NIL, all]];

};

buf: IO.STREAM ~ IO.ROS[];

buf.PutRope["["];

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

buf.PutRope[" ]"];

RETURN [buf.RopeFromROS[]];

};

ENABLE QuotedStringError => {msg ¬ "Mismatched quotes"; GO TO Failure};

dontStartIfUnbound, runAgain, loadOnly, excepting, quote, printTimings: BOOL ¬ FALSE;

preferOptimized: BOOL ¬ TRUE;

unboundOK: SymTab.Ref ~ SymTab.Create[case: TRUE]; -- never used!

something: BOOL ¬ FALSE;

patchByteSize: CARD ¬ 0;

cmds: IO.STREAM ¬ NIL;

defaultSwitches: ROPE ¬ GlobalRunDefaults.GetGlobalRunDefaults[];

WITH ProcessProps.GetProp[$RunDefaultSwitches] SELECT FROM

cmds ¬ IO.RIS[Rope.Concat[defaultSwitches, cmd.commandLine]];

FOR arg: ROPE ¬ GetCmdToken[cmds], GetCmdToken[cmds] UNTIL arg = NIL DO

IF excepting THEN { msg ¬ "Looks like you forgot your -x"; GOTO Failure };

IF NOT something THEN { msg ¬ runUsage; GOTO Failure };

EXITS Failure => result ¬ $Failure;

};

cmds: IO.STREAM ~ IO.RIS[cmd.commandLine];

switches: ROPE ~ GetCmdToken[cmds];

IF switches # NIL AND (Rope.Size[switches] = 0 OR Rope.Fetch[switches, 0] = '-) THEN {

msg ¬ "no local default switches are set for Run";

WITH ProcessProps.GetProp[$RunDefaultSwitches] SELECT FROM

};

ENABLE PFS.Error => {msg ¬ error.explanation; GOTO Failure};

cmds: IO.STREAM ~ IO.RIS[cmd.commandLine];

path: PATH ~ PFS.FileInfo[PFS.PathFromRope[GetCmdToken[cmds]]].fullFName;

IO.PutRope[cmd.out, PFS.PFSNameToUnixName[path]];

IO.PutChar[cmd.out, '\n];

EXITS Failure => result ¬ $Failure;

};

ENABLE QuotedStringError => {msg ¬ "Mismatched quotes"; GO TO Failure};

cmds: IO.STREAM ~ IO.RIS[cmd.commandLine];

FOR target: ROPE ¬ GetCmdToken[cmds], GetCmdToken[cmds] UNTIL target = NIL DO

RETURN;

EXITS

};

EachName: PROC [name: PATH] RETURNS [continue: BOOL ¬ FALSE] = { path ¬ name };

IF Rope.Match["*.~*~", name]

WITH SymTab.Fetch[runInfoTab, name].val SELECT FROM

path ¬ PFS.PathFromRope[name];

PFS.EnumerateForNames[pattern: path, proc: EachName];

};

path: PATH ~ PathFromUnixName[name];

short: PFSNames.Component ~ PFSNames.ShortName[path];

dot: INT ~ Rope.Index[short.name.base, short.name.start, "."];

RETURN [Rope.Substr[short.name.base, short.name.start, MIN[short.name.len, dot-short.name.start]]]

};

WITH SymTab.Fetch[runInfoTab, unixName].val SELECT FROM

};

ENABLE {

cmds: IO.STREAM ~ IO.RIS[cmd.commandLine];

GetFilePattern: PROC RETURNS [ROPE] ~ {

exceptions: LIST OF ROPE ¬ NIL;

Exception: PROC [rope: ROPE] RETURNS [BOOL] ~ {

format: { pcr, command, names, ccode, libs } ¬ command;

first: ROPE ¬ NIL;

after: ROPE ¬ NIL;

before: ROPE ¬ NIL;

last: ROPE ¬ NIL;

list: LIST OF ROPE ¬ NIL;

something: BOOL ¬ FALSE;

libTab: SymTab.Ref ¬ NIL;

FOR target: ROPE ¬ GetCmdToken[cmds], GetCmdToken[cmds] UNTIL target = NIL DO

IF NOT something THEN {msg ¬ loadedFilesUsage; GO TO Failure};

IF first = NIL AND after = NIL THEN first ¬ "*";

IF before = NIL AND last = NIL THEN last ¬ " ";

TRUSTED {

UNTIL list = NIL OR (first # NIL AND Rope.Match[first, list.first, FALSE]) DO

IF NOT (before = NIL AND last = NIL) THEN {

FOR tail: LIST OF ROPE ¬ list, tail.rest UNTIL tail = NIL DO

EXITS

};

rep: REF ProcRep ~ NEW [ProcRep ¬ [[pcStart], staticLink]];

RETURN [LOOPHOLE[rep]]};

IF char = '" THEN RETURN [break];

IF char = ' OR char = '\t OR char = ', OR char = '\l OR char = '\r THEN RETURN [sepr];

RETURN [other];

};

token ¬ IO.GetTokenRope[stream, CmdTokenBreak ! IO.EndOfStream => CONTINUE].token;

IF Rope.Equal[token, "\""] THEN {

};

"Run (-d | -a | -l | -p number | -q | -s | -t | -u InterfaceName* -x | ModuleOrFileName)*
-d don't start if unbound
-a run again even if already run
-l  load only
-o prefer optimized code
-p number allocate that number of bytes for patch space
-q  quote (don't use file searching hacks)
-t print load timing info
-u start unbound exception list
-x end unbound exception list";

Commander.Register["Run", RunCmd, runUsage];

Commander.Register["RunDefaultSwitches", RunDefaultsCmd, "Set local default switches for the Run command"];

Commander.Register["LoadedVersionOf", LoadedVersionCmd, "LoadedVersionOf FileNamePattern*"];

Commander.Register["LoadedFiles", LoadedFilesCmd, Rope.Concat["Format load state for restart\n", loadedFilesUsage]];

Commander.Register["UXName", UXNameCommand, "For debug of PFSNameToUnixName"];

};

proc: SAFE PROC ~ CProcToCedar[cproc];

path: PATH ~ PFS.PathFromRope[UXStrings.ToRope[wd]];

PFS.DoInWDir[path, proc];

};

"^ExternalNames\n";

"CallWithPFSWorkingDirectory XR�llWithPFSWorkingDirectory\n";

};