DIRECTORY
BasicTime USING [Now],
CommandTool USING [Run],
FS USING [Error],
IO USING [PutF, rope],
Labels USING [Set],
MessageWindow USING [Append, Blink],
Plot USING [IsPlotViewer, SavePlot],
PlotOps USING [Handle],
PrincOps USING [NoTimeout], 
Process USING [Abort, Detach, GetPriority, Priority, priorityBackground, SetPriority, SetTimeout],
Real USING [FixC],
RefText USING [New],
Rope USING [Equal, Find, IsEmpty, ROPE, Substr],
RopeFrom USING [String],
spGlobals USING [Aborted, bomb, CircuitRec, CloseNil, defineCircuit, dumpAll, error, ErrWarnSummary, fileStackSeq, FlushCloseNil, function, functionTable, FuncTableBlk, FuncTablePtr, Handle, keys, makePlotList, makePrintList, maxInclude, maxLog, maxPlots, maxPrints, model, modelTable, ModelTableBlk, ModelTablePtr, nameBlk, namePtr, next, openInputFile, output, PlotSeq, printHole, PrintSeq, PutMsgLine, runIt, searchKey, SetCursor, setICs, topoAnalysis, Variables, WorstNodeLog],
ViewerClasses USING [Viewer];

spMain: CEDAR MONITOR
IMPORTS BasicTime, CommandTool, FS, IO, Labels, MessageWindow, Plot, Process, Real, RefText, Rope, RopeFrom, spGlobals 
EXPORTS spGlobals=

{ OPEN spGlobals;

EnterModels: PUBLIC ENTRY PROC[name: Rope.ROPE, proc: model,
numArgs, numParms, numResults: NAT]= {
ENABLE UNWIND => NULL;
m: ModelTablePtr;
FOR m_ modelTable, m.next UNTIL m=NIL DO
IF Rope.Equal[m.name, name] THEN {
m^_ [
next: m.next,
name: name,
proc: proc,
numArgs: numArgs,
numParms: numParms,
numResults: numResults];
RETURN;
};
ENDLOOP;
m_ NEW[ModelTableBlk_
[next: modelTable,
name: name,
proc: proc,
numArgs: numArgs,
numParms: numParms,
numResults: numResults]];
modelTable_ m;
}; -- EnterModels

EnterFunctions: PUBLIC ENTRY PROC[name: Rope.ROPE, proc: function,
numArgs, numParms: NAT]= {
ENABLE UNWIND => NULL;
f: FuncTablePtr;
FOR f_ functionTable, f.next UNTIL f=NIL DO
IF Rope.Equal[f.name, name] THEN {
f^_ [f.next, name, proc, numArgs, numParms];
RETURN;
};
ENDLOOP;
f_ NEW[FuncTableBlk_ [functionTable, name, proc, numArgs, numParms]];
functionTable_ f;
}; -- EnterFunctions


findModel: PUBLIC ENTRY PROC[name: Rope.ROPE] RETURNS[model, NAT, NAT, NAT]= {
ENABLE UNWIND => NULL;
m: ModelTablePtr;
FOR m_ modelTable, m.next UNTIL m=NIL DO
IF Rope.Equal[m.name, name] THEN 
RETURN[m.proc, m.numArgs, m.numParms, m.numResults];
ENDLOOP;
RETURN[NIL, 0, 0, 0];
}; -- findModel

findFunction: PUBLIC ENTRY PROC[name: Rope.ROPE]
RETURNS[function, NAT, NAT]= {
ENABLE UNWIND => NULL;
f: FuncTablePtr;
FOR f_ functionTable, f.next UNTIL f=NIL DO
IF Rope.Equal[f.name, name] THEN
RETURN[f.proc, f.numArgs, f.numParms];
ENDLOOP;
RETURN[NIL, 0, 0];
}; -- findFunction

ResetCheckPoint: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
handle.vars.checkPoint_ FALSE };

Canned: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.vars.canned]};

ForcedDump: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.vars.forcedDump]};

CheckPoint: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.vars.checkPoint]};

ShowDetails: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.showTimeStep]};

StopIt: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
IF handle # NIL THEN {
IF handle.vars # NIL THEN {
handle.vars.forcedDump_ FALSE; 
handle.vars.canned_ TRUE;
};
AbortCheckPoint[handle];
};
}; -- StopIt

DumpIt: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
IF handle # NIL THEN {
IF handle.vars # NIL THEN {
handle.vars.forcedDump_ TRUE;
handle.vars.canned_ TRUE;
};
AbortCheckPoint[handle];
};
}; -- DumpIt

ToggleShowDetails: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
handle.showTimeStep_ ~handle.showTimeStep;
}; -- ToggleShowDetails

SimulateIt: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
IF handle = NIL THEN RETURN;
IF handle.stage=idle AND handle.simulation=NIL THEN {
curPriority: Process.Priority = Process.GetPriority[];
handle.stage_ input;
SetCursor[handle];
Process.SetPriority[Process.priorityBackground];
handle.simulation_ FORK Simulate[handle];
Process.SetPriority[curPriority];
TRUSTED {Process.Detach[handle.simulation]};
}
ELSE MessageWindow.Append[message: "It's still running.", clearFirst: TRUE];
}; -- SimulateIt

NextStage: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
SELECT handle.stage FROM
input, bomb, topo => {
handle.stage_ SUCC[handle.stage];
SetCursor[handle];
};
run => {
handle.vars.runState _ (handle.vars.runState + 1) MOD 4;
SetCursor[handle];
};
ENDCASE => MessageWindow.Append[ -- should not get here
message: "* Weird situation detected in 'NextStage', please inform SChen.pa",
clearFirst: TRUE];
}; -- NextStage

PeriodicSetCheckPoint: ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
WHILE handle # NIL DO
ENABLE ABORTED => EXIT;
WAIT handle.checkPointCV;
IF handle # NIL THEN
IF handle.vars # NIL THEN handle.vars.checkPoint_ TRUE
ELSE EXIT;
ENDLOOP;
IF handle # NIL THEN
TRUSTED {Process.SetTimeout[@handle.checkPointCV, PrincOps.NoTimeout]};
}; -- PeriodicSetCheckPoint

CleanUp: ENTRY PROC[handle: Handle]= {OPEN handle;
ENABLE UNWIND => NULL;
IF checkProcess # NIL THEN {
TRUSTED {Process.Abort[LOOPHOLE[checkProcess, UNSPECIFIED]]};
checkProcess_ NIL;
};
IF vars.canned THEN msgStream.PutF["\n...... Aborted.\n"];
vars.thymeDotErrors _ CloseNil[vars.thymeDotErrors];
FOR i: NAT IN [0..vars.fileStackTop) DO
vars.fileStack[vars.fileStackTop] _ CloseNil[vars.fileStack[vars.fileStackTop]];
ENDLOOP;
vars.inStream _ CloseNil[vars.inStream];
FOR i: NAT IN [0..vars.numPrints) DO
vars.prints[i].printStream _ FlushCloseNil[vars.prints[i].printStream];
ENDLOOP;
FOR i: NAT IN [0..vars.numPlots) DO
v: ViewerClasses.Viewer _ vars.plots[i].plotViewer;
IF Plot.IsPlotViewer[v] THEN {
h: PlotOps.Handle _ NARROW[v.data];
IF h # NIL THEN {
msg: Rope.ROPE _ Plot.SavePlot[v, h.plotSpec.file];
IF msg # NIL THEN {
MessageWindow.Blink[];
MessageWindow.Append[message: msg, clearFirst: TRUE];
};
};
v.inhibitDestroy _ FALSE;
};
vars.plots[i].plotViewer _ NIL;
ENDLOOP;
FOR i: NAT IN [0..maxLog) DO
vars.worstNodeLog[i] _ [];
ENDLOOP;
handle.stage_ idle;
SetCursor[handle];
Labels.Set[handle.time, ""];
Labels.Set[handle.step, ""];
simulation_ NIL;
vars_ NIL;
}; -- CleanUp

AbortCheckPoint: INTERNAL PROC[handle: Handle]= {
IF handle = NIL THEN RETURN;
IF handle.stage=run AND handle.checkProcess # NIL THEN {
TRUSTED {Process.Abort[LOOPHOLE[handle.checkProcess, UNSPECIFIED]]};
handle.checkProcess_ NIL;
};
}; -- AbortCheckPoint

AddLibrary: PROC[handle: Handle]= {
next[handle];
IF handle.vars.item=leftB THEN next[handle] ELSE error[handle, 801, TRUE];
IF handle.vars.item=name THEN {
originalName, nameRoot, errMsg: Rope.ROPE;
dotPosition: INT;
originalName_ RopeFrom.String[handle.vars.newString];
dotPosition_ Rope.Find[originalName, "."];
nameRoot_ IF dotPosition=-1 THEN originalName
ELSE Rope.Substr[originalName, 0, dotPosition-1];
IF NOT (Rope.Equal[nameRoot, "MosModels",    FALSE] OR
Rope.Equal[nameRoot, "StdFunctions", FALSE] OR
Rope.Equal[nameRoot, "Level2Model",  FALSE]) THEN {
[errMsg, ]_ CommandTool.Run[originalName];
IF NOT errMsg.IsEmpty[] THEN PutMsgLine[handle, errMsg];
};
next[handle];
}
ELSE error[handle, 804, TRUE];
IF handle.vars.item=rightB THEN next[handle] ELSE error[handle, 802, FALSE];
IF handle.vars.item=semi THEN next[handle] ELSE error[handle, 800, FALSE];
}; -- AddLibrary


Simulate: PUBLIC PROC[handle: Handle]= {
ENABLE {
Aborted => GOTO stop;
ABORTED => {handle.vars.canned _ TRUE; GOTO stop};
FS.Error => {
handle.msgStream.PutF["%g\nProgram stopped.\n", IO.rope[error.explanation]];
GOTO stop;
};
};
InitVars[handle];
openInputFile[handle];
next[handle];

WHILE handle.vars.item=name DO
IF Canned[handle] THEN GOTO stop;
IF searchKey[handle]=libraryKey THEN AddLibrary[handle] ELSE EXIT;
ENDLOOP;  

IF handle.vars.item=name AND searchKey[handle]=circuitKey THEN {
theRoot: namePtr_ NEW[nameBlk_
[name: "Main Circuit", details: NEW[CircuitRec_ []]] ];
defineCircuit[handle: handle, ckt: theRoot, root: TRUE]; -- may signal Aborted
}
ELSE error[handle, 820, TRUE];
IF handle.vars.item=slash AND handle.vars.errCount <= 0 THEN {
next[handle];
output[handle, handle.vars.cktRoot, 0];
};

IF handle.vars.item#semi THEN error[handle, 800,, FALSE]
ELSE IF handle.vars.errCount <= 0 THEN {
NextStage[handle];
bomb[handle]; -- may signal Aborted
next[handle];
IF handle.vars.item=plus THEN {next[handle]; printHole[handle]};
};
IF handle.vars.errCount <= 0 THEN {
NextStage[handle];
topoAnalysis[handle];
IF Canned[handle] THEN GOTO stop;
};
IF handle.vars.errCount <= 0 THEN {
NextStage[handle];
WHILE handle.vars.item=name DO
OPEN handle.vars;
key: keys_ searchKey[handle];
next[handle];
SELECT key FROM
runKey=> {
TRUSTED {
Process.SetTimeout[@handle.checkPointCV,
Real.FixC[60.0*checkPointInterval]];
Process.Detach[handle.checkProcess_ FORK PeriodicSetCheckPoint[handle]]};
lastTime_ runIt[handle];
IF NOT Canned[handle] THEN PutMsgLine[handle, "Done."];
};
printKey=> makePrintList[handle];
plotKey => makePlotList[handle];
icKey   => setICs[handle];
dumpKey => IF ~ForcedDump[handle] THEN dumpAll[handle, lastTime];
checkPointKey=> {
IF item=leftB THEN next[handle] ELSE error[handle, 801];
IF item=number THEN {
checkPointInterval_ value;
next[handle]
}
ELSE error[handle, 809, FALSE];
IF item=rightB THEN next[handle] ELSE error[handle, 802];
}
ENDCASE=> GOTO err1;
IF item=eof THEN EXIT;
IF item=semi THEN next[handle] ELSE error[handle, 800,, FALSE];
REPEAT
err1=> error[handle, 821, TRUE];
ENDLOOP;
}; -- run

IF ForcedDump[handle] THEN dumpAll[handle, handle.vars.lastTime];
ErrWarnSummary[handle]; 
GOTO stop;
EXITS
stop=> {CleanUp[handle]; handle.msgStream.PutF["Thyme is idle now .....\n"];};
}; -- Simulate
InitVars: PROC[handle: Handle]= {
handle.vars_ NEW[Variables_ [ ]];
{OPEN handle.vars;
simTime _ BasicTime.Now[];
line_ RefText.New[256];
newString_ RefText.New[256];
line.length_ 0;
newString.length_ 0;
fileStack_ NEW[fileStackSeq[maxInclude]];
prints_ NEW[PrintSeq[maxPrints]];
plots_ NEW[PlotSeq[maxPlots]];
worstNodeLog_ NEW[WorstNodeLog[maxLog]];
};
}; -- InitVars
}.

ÚFile: [Thyme]<Thyme>Cedar5.2>System>spMain.mesa
Last Edited by: SChen, September 18, 1984 1:06:20 pm PDT

entry procs
find the model named newString from ModelTable
main proc
libraries
circuit definition
explode

analyze

run
killPlot[]



CHANGE LOG
Wilhelm, April 27, 1982  4:07 PM
Barth,  7-May-82 14:41:52 PDT
Chen, April 19, 1983  6:45 PM, changed the version name for openSysWindow.
Barth, July 11, 1983  12:46 PM
Chen, June 12, 1984 11:37:19 am PDT, cedarized.
�Êp˜Jš
Ðct/™/Jš
œ8™8J™š
Ïk	˜	Jšœ
žœ˜Jšœžœ˜Jšžœ
žœ	˜Jšžœ
žœ˜Jšœžœ˜Jšœžœ˜$Jšœžœ˜$Jšœžœ
˜Jšœ	žœ˜JšœžœU˜bJšœžœ˜Jšœžœ˜Jšœžœžœ
˜0Jšœ	žœ
˜Jšœ
žœÒ˜áJšœžœ
˜—J˜šœžœ
ž˜JšžœžœžœQ˜wJšžœ˜—J˜Jšœžœ˜J˜š
Ïnœžœ
žœ
žœžœ˜<Jšœžœ˜&Jšžœ
žœžœ
˜Jš
œ˜šžœžœžœ
ž˜(šžœžœ˜"š
œ˜Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jšžœ
˜Jš
œ˜—Jšžœ
˜—šœžœ˜Jš
œj˜j—Jš
œ˜Jšœ�œ
˜—š
Ÿœžœ
žœ
žœžœ˜BJšœžœ˜Jšžœ
žœžœ
˜Jš
œ˜šžœžœžœ
ž˜+šžœžœ˜"Jš
œ,˜,Jšžœ
˜Jš
œ˜—Jšžœ
˜—Jšœžœ?˜EJš
œ˜Jšœ�˜—J˜Jš
Ït™J˜šœžœ
žœ
žœžœžœžœžœžœ˜NJšžœ
žœžœ
˜Jš
œ˜Jš
 .™.šžœžœžœ
ž˜(šžœžœ
˜!Jšžœ.˜4—Jšžœ
˜—Jšžœ
žœ˜Jšœ�˜—J˜š	œžœ
žœ
žœžœ
˜0Jšžœžœžœ˜Jšžœ
žœžœ
˜Jš
œ˜šžœžœžœ
ž˜+šžœž˜ Jšžœ ˜&—Jšžœ
˜—Jšžœ
žœ˜Jšœ�˜—J˜šŸœžœ
žœ
žœ˜5Jšžœ
žœžœ
˜Jšœžœ˜ —J˜šŸœžœ
žœ
žœžœ
žœ˜:Jšžœ
žœžœ
˜Jšžœ˜—J˜šŸ
œžœ
žœ
žœžœ
žœ˜>Jšžœ
žœžœ
˜Jšžœ˜ —J˜šŸ
œžœ
žœ
žœžœ
žœ˜>Jšžœ
žœžœ
˜Jšžœ˜ —J˜šŸœžœ
žœ
žœžœ
žœ˜?Jšžœ
žœžœ
˜Jšžœ˜—J˜šŸœžœ
žœ
žœ˜,Jšžœ
žœžœ
˜šžœ
žœ
žœ˜šžœžœ
žœ˜Jšœžœ˜Jšœžœ
˜J˜—Jš
œ˜J˜—Jšœ�	˜—J˜šŸœžœ
žœ
žœ˜,Jšžœ
žœžœ
˜šžœ
žœ
žœ˜šžœžœ
žœ˜Jšœžœ
˜Jšœžœ
˜J˜—Jš
œ˜J˜—Jšœ�	˜—J˜šŸœžœ
žœ
žœ˜7Jšžœ
žœžœ
˜Jš
œ*˜*Jšœ�˜—J˜šŸ
œžœ
žœ
žœ˜0Jšžœ
žœžœ
˜Jšžœ
žœ
žœ
žœ
˜šžœžœžœ
žœ˜5J˜6Jš
œ˜Jš
œ˜Jš
œ0˜0Jšœžœž
˜)Jš
œ!˜!Jšžœ%˜,Jš
œ
˜
—JšžœBžœ˜LJšœ�
˜—J˜šŸ	œžœ
žœ
žœ˜/Jšžœ
žœžœ
˜šžœž˜š
œ˜Jšœžœ˜!Jš
œ˜Jš
œ˜—š
œ˜Jšœ2žœ˜8Jš
œ˜Jš
œ˜—šžœ�˜7Jš
œM˜MJšœžœ˜——Jšœ�˜—J˜šŸœžœ
žœ˜4Jšžœ
žœžœ
˜šžœ
žœ
ž˜Jšžœ
žœžœ
˜Jšžœ˜šžœ
žœ
ž˜Jšžœžœ
žœž˜6Jšžœ
žœ
˜
—Jšžœ
˜—šžœ
žœ
ž˜Jšžœ@˜G—Jšœ�˜—J˜šŸœžœ
žœžœ˜2Jšžœ
žœžœ
˜šžœžœ
žœ˜Jšžœžœžœ˜=Jšœžœ
˜Jš
œ˜—Jšžœ
žœ'˜:Jš
œ4˜4šžœžœ
žœž˜'Jš
œP˜PJšžœ
˜—Jš
œ(˜(šžœžœ
žœž˜$Jš
œG˜GJšžœ
˜—šžœžœ
žœž˜#Jš
œ3˜3šžœžœ˜Jšœžœ	˜#šžœžœ
žœ˜Jšœ
žœ%˜3šžœžœ
žœ˜Jš
œ˜Jšœ/žœ˜5J˜—J˜—Jšœžœ
˜J˜—Jšœžœ
˜Jšžœ
˜—šžœžœ
žœ
ž˜Jš
œ˜Jšžœ
˜—Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ
˜Jšœžœ
˜
Jšœ�
˜
—J˜šŸœžœ
žœ˜1Jšžœ
žœ
žœ
žœ
˜šžœžœžœ
žœ˜8Jšžœžœžœ˜DJšœžœ
˜Jš
œ˜—Jšœ�˜—J˜šŸ
œžœ˜#Jš
œ
˜
Jšžœžœžœžœ˜Jšžœžœ˜Jšœ%žœ
˜*Jšœ
žœ
˜Jš
œ5˜5Jš
œ*˜*šœ
žœžœ
˜-Jšžœ-˜1—šžœ
žœ'žœž˜6Jšœ%žœž˜.šœ%žœžœ˜3Jš
œ*˜*Jšžœ
žœžœ˜8Jš
œ˜——Jš
œ
˜
Jš
œ
˜
—Jšžœžœ˜Jšžœžœžœžœ˜LJšžœžœžœžœ˜JJšœ�
˜—J˜Jš
 	™	J˜šŸœžœ
žœ˜(šžœ˜Jšœžœ˜Jšžœžœžœ˜2šžœ˜
Jšœ0žœ˜LJšžœ˜
J˜—J˜—Jš
œ˜Jš
œ˜Jš
œ
˜
J˜Jš
�	™	šžœž˜Jšžœžœ
žœ˜!Jšžœžœžœ
žœ
˜BJšžœ˜
—J˜Jš
�™šžœžœžœ˜@Jšœžœ	˜Jšœ žœ˜7Jšœ2žœÏc˜NJš
œ
˜
—Jšžœžœ˜šžœžœžœ˜>Jš
œ
˜
Jš
œ'˜'Jš
œ˜—Jš
œ™Jšžœžœžœ
˜8šžœ
žœžœ˜(Jš
œ˜Jšœ¡˜#Jš
œ
˜
Jšžœžœ#˜@Jš
œ˜—J™Jš
œ™šžœžœ˜#Jš
œ˜Jš
œ˜Jšžœžœ
žœ˜!Jš
œ˜——™Jš
œ™šžœžœ˜#Jš
œ˜šžœž˜Jšžœ
˜Jš
œ˜Jš
œ
˜
šžœž˜š
œ
˜
šžœ˜	Jš
œ(˜(Jš
œ$˜$Jšœ#žœ!˜I—Jš
œ˜Jšžœ
žœžœ˜7Jš
œ˜—Jš
œ!˜!Jš
œ ˜ Jš
œ˜Jšœžœžœ˜Aš
œ˜Jšžœžœžœ˜8šžœ
žœ˜Jš
œ˜Jš
œ˜Jš
œ
˜
—Jšžœžœ˜Jšžœ
žœžœ˜9Jš
œ
˜
—Jšžœžœ˜—Jšžœ
žœ
žœ
˜Jšžœžœžœžœ˜?š
ž˜Jšœžœ˜ —Jšžœ
˜—Jšœ�˜	—J˜Jšžœžœ'˜AJš
œ˜Jš
œ
™
Jšžœ˜
š
ž˜Jš
œN˜N—Jšœ�˜J™—šŸœžœ˜!Jšœ
žœ˜!šœ
žœ
˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ˜)Jšœžœ˜!Jšœžœ˜Jšœžœ˜(Jš
œ˜—Jšœ�˜—J™Jš
œ˜J™J™
J™ Jš
œ™J™JJ™J™/—…—'º9