DIRECTORY Graph USING [GraphHandle], GraphOps USING [Lock, SaveGraph, Unlock], GraphPrivate USING [IsGraphViewer, IsLocked], GraphUtil USING [HandleNotNil], IO USING [Close, PutF, STREAM], Labels USING [Set], MessageWindow USING [Append, Blink], Rope USING [ROPE], ThymeGlobals, ViewerClasses USING [Viewer]; ThymeCleanUp: CEDAR PROGRAM IMPORTS GraphOps, GraphPrivate, GraphUtil, IO, Labels, MessageWindow, ThymeGlobals EXPORTS ThymeGlobals = { OPEN ThymeGlobals; CleanUp: PUBLIC PROC[handle: Handle] = { msg: IO.STREAM _ handle.msgStream; IF handle.vars.canned THEN msg.PutF["Simulation is aborted.\n"]; msg.PutF["\nClosing all input and output files ...... "]; CloseIO[handle.vars]; msg.PutF["done.\nReleasing memory space ...... "]; handle.vars _ FreeVars[handle.vars]; handle.stage_ idle; Labels.Set[handle.time, ""]; Labels.Set[handle.step, ""]; msg.PutF["done.\n\nThyme is idle now.\n"]; handle.simulation_ NIL; handle.outer.inhibitDestroy _ FALSE; }; -- CleanUp CloseIO: PROC[vars: REF Variables] = { ReleaseGraph: PROC [gh: Graph.GraphHandle, plottedOnly: BOOL _ TRUE] RETURNS [Graph.GraphHandle] = { IF GraphUtil.HandleNotNil[gh] THEN { OPEN gh; v: ViewerClasses.Viewer _ chart.viewer; IF NOT GraphPrivate.IsLocked[gh] THEN GraphOps.Lock[gh]; IF v # NIL AND GraphPrivate.IsGraphViewer[v] THEN { msg: Rope.ROPE _ GraphOps.SaveGraph[gh, plottedOnly]; IF msg # NIL THEN { MessageWindow.Append[message: msg, clearFirst: TRUE]; MessageWindow.Blink[]; }; v.inhibitDestroy _ FALSE; }; userEditAllowed _ TRUE; GraphOps.Unlock[gh]; }; RETURN[NIL]; }; -- ReleaseGraph IF vars = NIL THEN RETURN; vars.thymeDotErrors _ CloseNil[vars.thymeDotErrors]; FOR i: NAT IN [0..vars.fileStackTop) DO vars.fileStack[vars.fileStackTop] _ CloseNil[vars.fileStack[vars.fileStackTop]]; ENDLOOP; vars.fileStack _ NIL; vars.inStream _ CloseNil[vars.inStream]; IF vars.prints # NIL THEN FOR i: NAT IN [0..vars.numPrints) DO vars.prints[i].printStream _ FlushCloseNil[vars.prints[i].printStream]; vars.prints[i].printList _ NilPrintBlkPtr[vars.prints[i].printList]; ENDLOOP; vars.prints _ NIL; IF vars.graphHandle # NIL THEN vars.graphHandle _ ReleaseGraph[vars.graphHandle, FALSE]; IF vars.plots # NIL THEN FOR i: NAT IN [0..vars.numPlots) DO gHandle: Graph.GraphHandle _ vars.plots[i].plotHandle; IF gHandle # NIL THEN vars.plots[i].plotHandle _ ReleaseGraph[gHandle]; vars.plots[i].plotList _ NilPlotBlkPtr[vars.plots[i].plotList]; vars.plots[i].title _ NIL; ENDLOOP; vars.plots _ NIL; }; -- CloseIO CloseNil: PROC[stream: IO.STREAM] RETURNS [IO.STREAM _ NIL] = { IF stream # NIL THEN stream.Close[ ]; }; -- CloseNil FreeVars: PROC[vars: REF Variables] RETURNS [REF Variables] = { IF vars # NIL THEN {OPEN vars; line _ NIL; newString _ NIL; treeRoot _ NilInstTreePtr[treeRoot]; unusedNodes _ NilNodePtr[unusedNodes]; IF modelArgs # NIL THEN FOR i: INT IN [0..hashModulus) DO modelArgs[i] _ NilModelArgsElement[modelArgs[i]]; ENDLOOP; modelArgs _ NIL; n _ NilNodePtr[n]; b _ NilBranchPtr[b]; m _ NilModFuncPtr[m]; gndNode _ NilNodePtr[gndNode]; nodeList _ NilNodePtr[nodeList]; capacitorList _ NilBranchPtr[capacitorList]; inductorList _ NilBranchPtr[inductorList]; vSourceList _ NilBranchPtr[vSourceList]; iSourceList _ NilBranchPtr[iSourceList]; functionList _ NilModFuncPtr[functionList]; intNodeList _ NilNodePtr[intNodeList]; intNodeModFunc _ NilModFuncPtr[intNodeModFunc]; otherModFunc _ NilModFuncPtr[otherModFunc]; worstNode _ NilNodePtr[worstNode]; IF worstNodeLog # NIL THEN FOR i: NAT IN [0..maxLog) DO worstNodeLog[i].node _ NilNodePtr[worstNodeLog[i].node]; ENDLOOP; worstNodeLog _ NIL; title _ NIL; lastRetreatCause _ NIL; }; RETURN[NIL]; }; -- FreeVars NilModelArgsElement: PROC[list: LIST OF REF ANY] RETURNS [LIST OF REF ANY _ NIL] = { IF list # NIL THEN { IF list.first # NIL THEN WITH list.first SELECT FROM x: modFuncPtr => list.first _ NilModFuncPtr[x]; ENDCASE; -- an error. list.rest _ NilModelArgsElement[list.rest]; }; }; -- NilModelArgsElement NilNamePtr: PROC[ref: namePtr] RETURNS [namePtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextName _ NilNamePtr[nextName]; srchLink _ NilNamePtr[srchLink]; name _ NIL; expExpr _ NilExpressionPtr[expExpr]; realCopy _ NilRealThingPtr[realCopy]; IF details # NIL THEN details _ WITH details SELECT FROM x: RefBranchRec => NilRefBranchRec[x], x: RefCircuitRec => NilRefCircuitRec[x], x: RefParmRec => NilRefParmRec[x], x: RefCktInstRec => NilRefCktInstRec[x], x: RefModelRec => NilRefModelRec[x], x: RefFunctionRec => NilRefFunctionRec[x], ENDCASE => NIL; -- RefNodeRec, RefConRec, or error. }; }; -- NilNamePtr NilRefBranchRec: PROC[ref: RefBranchRec] RETURNS [RefBranchRec _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; posNode _ NilNamePtr[posNode]; negNode _ NilNamePtr[negNode]; controller _ NilNamePtr[controller]; valExpr _ NilExpressionPtr[valExpr]; }; }; -- NilRefBranchRec NilRefCircuitRec: PROC[ref: RefCircuitRec] RETURNS [RefCircuitRec _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; names _ NilNamePtr[names]; fakeNodes _ NilNamePtr[fakeNodes]; parms _ NilNamePtr[parms]; father _ NilNamePtr[father]; assertions _ NilExpressionPtr[assertions]; }; }; -- NilRefCircuitRec NilRefParmRec: PROC[ref: RefParmRec] RETURNS [RefParmRec _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextParm _ NilNamePtr[nextParm]; }; }; -- NilRefParmRec NilRefCktInstRec: PROC[ref: RefCktInstRec] RETURNS [RefCktInstRec _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; of _ NilNamePtr[of]; connections _ NilConLinkPtr[connections]; actualParms _ NilExpressionPtr[actualParms]; }; }; -- NilRefCktInstRec NilConLinkPtr: PROC[ref: conLinkPtr] RETURNS [conLinkPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextLink _ NilConLinkPtr[nextLink]; namedNode _ NilNamePtr[namedNode]; }; }; -- NilConLinkPtr NilRefModelRec: PROC[ref: RefModelRec] RETURNS [RefModelRec _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; modelProc _ NIL; modelResults _ NilArgList[modelResults]; modelArgs _ NilArgNames[modelArgs]; modelArgVec _ NilArgList[modelArgVec]; modelOldArgVec _ NilArgList[modelOldArgVec]; modelParms _ NilExpressionPtr[modelParms]; data _ NIL; }; }; -- NilRefModelRec NilRefFunctionRec: PROC[ref: RefFunctionRec] RETURNS [RefFunctionRec _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; functionProc _ NIL; funcArgs _ NilArgNames[funcArgs]; funcArgVec _ NilArgList[funcArgVec]; funcParms _ NilExpressionPtr[funcParms]; branch _ NilNamePtr[branch]; data _ NIL; }; }; -- NilRefFunctionRec NilArgNames: PROC[ref: argNames] RETURNS [argNames _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; FOR i: NAT IN [0..size) DO names[i] _ NilNamePtr[names[i]]; ENDLOOP; }; }; --NilArgNames NilNodePtr: PROC[ref: nodePtr] RETURNS [nodePtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextNode _ NilNodePtr[nextNode]; nodeName _ NilNamePtr[nodeName]; treeLevel _ NilInstTreePtr[treeLevel]; brotherNodes _ NilNodePtr[brotherNodes]; branches _ NilBranchLinkPtr[branches]; curPtr _ NilBranchPtr[curPtr]; nextIntNode _ NilNodePtr[nextIntNode]; entity _ NIL; }; }; -- NilNodePtr NilBranchLinkPtr: PROC[ref: branchLinkPtr] RETURNS [branchLinkPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextLink _ NilBranchLinkPtr[nextLink]; branch _ NilBranchPtr[branch]; otherNode _ NilNodePtr[otherNode]; }; }; -- NilBranchLinkPtr NilBranchPtr: PROC[ref: branchPtr] RETURNS [branchPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; branchName _ NilNamePtr[branchName]; treeLevel _ NilInstTreePtr[treeLevel]; brotherBranches _ NilBranchPtr[brotherBranches]; posNode _ NilNodePtr[posNode]; negNode _ NilNodePtr[negNode]; controller _ NilModFuncPtr[controller]; entity _ NIL; IF body # NIL THEN body _ WITH body SELECT FROM x: RefC => NilRefC[x], x: RefL => NilRefL[x], x: RefV => NilRefV[x], x: RefI => NIlRefI[x], ENDCASE => NIL; -- RefR or error. }; }; -- NilBranchPtr NilRefC: PROC[ref: RefC] RETURNS [RefC _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextCapacitor _ NilBranchPtr[nextCapacitor]; }; }; -- NilRefC NilRefL: PROC[ref: RefL] RETURNS [RefL _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextInductor _ NilBranchPtr[nextInductor]; }; }; -- NilRefL NilRefV: PROC[ref: RefV] RETURNS [RefV _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextvSource _ NilBranchPtr[nextvSource]; }; }; -- NilRefV NIlRefI: PROC[ref: RefI] RETURNS [RefI _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextiSource _ NilBranchPtr[nextiSource]; }; }; -- NIlRefI NilExpressionPtr: PROC[ref: expressionPtr] RETURNS [expressionPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; next _ NilExpressionPtr[next]; WITH ref SELECT FROM e: REF max expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF min expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF add expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF sub expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF mul expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF div expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF eq expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF neq expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF grt expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF les expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF geq expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF leq expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF and expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF or expressionNode => [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF power expressionNode=> [e.leftOp, e.rightOp] _ NilBinary[e.leftOp, e.rightOp]; e: REF int expressionNode => e.unaryOp _ NilExpressionPtr[e.unaryOp]; e: REF abs expressionNode => e.unaryOp _ NilExpressionPtr[e.unaryOp]; e: REF exp expressionNode => e.unaryOp _ NilExpressionPtr[e.unaryOp]; e: REF log expressionNode => e.unaryOp _ NilExpressionPtr[e.unaryOp]; e: REF sqrt expressionNode => e.unaryOp _ NilExpressionPtr[e.unaryOp]; e: REF neg expressionNode => e.unaryOp _ NilExpressionPtr[e.unaryOp]; e: REF not expressionNode => e.unaryOp _ NilExpressionPtr[e.unaryOp]; e: REF load expressionNode => [e.var, e.expr] _ NilNameAndExpr[e.var, e.expr]; e: REF store expressionNode=> [e.var, e.expr] _ NilNameAndExpr[e.var, e.expr]; ENDCASE; -- num, or an error. }; }; -- NilExpressionPtr NilBinary: PROC[left, right: expressionPtr] RETURNS [nLeft, nRight: expressionPtr] = { nLeft _ NilExpressionPtr[left]; nRight _ NilExpressionPtr[right]; }; -- NilBinary NilNameAndExpr: PROC[name: namePtr, expr: expressionPtr] RETURNS [nName: namePtr, nExpr: expressionPtr] = { nName _ NilNamePtr[nName]; nExpr _ NilExpressionPtr[expr]; }; -- NilNameAndExpr NilRealThingPtr: PROC[ref: realThingPtr] RETURNS [realThingPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextThing _ NilRealThingPtr[nextThing]; WITH thing SELECT FROM x: RefRealNode => thing _ NilRefRealNode[x]; x: RefRealBranch => thing _ NilRefRealBranch[x]; x: RefRealModel => thing _ NilRefRealModel[x]; ENDCASE => thing _ NIL; -- for RefRealParm, RefUnReal, or an error. }; }; -- NilRealThingPtr NilRefRealNode: PROC[ref: RefRealNode] RETURNS [RefRealNode _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; rn _ NilNodePtr[rn]; }; }; -- NilRefRealNode NilRefRealBranch: PROC[ref: RefRealBranch] RETURNS [RefRealBranch _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; rb _ NilBranchPtr[rb]; }; }; -- NilRefRealBranch NilRefRealModel: PROC[ref: RefRealModel] RETURNS [RefRealModel _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; rm _ NilModFuncPtr[rm]; }; }; -- NilRefRealModel NilInstTreePtr: PROC[ref: instTreePtr] RETURNS [instTreePtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; father _ NilInstTreePtr[father]; brothers _ NilInstTreePtr[brothers]; sons _ NilInstTreePtr[sons]; instance _ NilNamePtr[instance]; nodes _ NilNodePtr[nodes]; branches _ NilBranchPtr[branches]; }; }; -- NilInstTreePtr NilModFuncPtr: PROC[ref: modFuncPtr] RETURNS [modFuncPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextMFPtr _ NilModFuncPtr[nextMFPtr]; arguments _ NilArgNodes[arguments]; argVector _ NilArgList[argVector]; parmVector _ NilArgList[parmVector]; actualParms _ NilExpressionPtr[actualParms]; data _ NIL; WITH body SELECT FROM x: RefFuncBody => body _ NilRefFuncBody[x]; x: RefModBody => body _ NilRefModBody[x]; ENDCASE => body _ NIL; -- an error. }; }; -- NilModFuncPtr NilArgNodes: PROC[ref: argNodes] RETURNS [argNodes _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; FOR i: NAT IN [0..size) DO nodes[i] _ NilNodePtr[nodes[i]]; ENDLOOP; }; }; -- NilArgNodes NilRefFuncBody: PROC[ref: RefFuncBody] RETURNS [RefFuncBody _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; functionProc _ NIL; branch _ NilBranchPtr[branch]; }; }; -- NilRefFuncBody NilRefModBody: PROC[ref: RefModBody] RETURNS [RefModBody _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; modelProc _ NIL; modelResults _ NilArgList[modelResults]; modelName _ NilNamePtr[modelName]; oldArgVector _ NilArgList[oldArgVector]; modelBranches _ NilModBrPtr[modelBranches]; }; }; -- NilRefModBody NilModBrPtr: PROC[ref: modBrPtr] RETURNS [modBrPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextBranch _ NilModBrPtr[nextBranch]; b _ NilBranchPtr[b]; }; }; -- NilModBrPtr NilArgList: PROC[ref: argList] RETURNS [argList _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; handle _ NIL; modFunc _ NilModFuncPtr[modFunc]; }; }; --NilArgList NilPlotBlkPtr: PROC[ref: plotBlkPtr] RETURNS [plotBlkPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextBlk _ NilPlotBlkPtr[nextBlk]; arg _ NilArgumentPtr[arg]; }; }; -- NilPlotBlkPtr NilPrintBlkPtr: PROC[ref: printBlkPtr] RETURNS [printBlkPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; nextBlk _ NilPrintBlkPtr[nextBlk]; arg _ NilArgumentPtr[arg]; }; }; -- NilPrintBlkPtr NilArgumentPtr: PROC[ref: argumentPtr] RETURNS [argumentPtr _ NIL] = { IF ref = NIL THEN RETURN; IF ref.visited THEN RETURN ELSE {OPEN ref; visited _ TRUE; node _ NilNodePtr[node]; branch _ NilBranchPtr[branch]; }; }; -- NilArgumentPtr }. CHANGE LOG Chen, May 17, 1985 1:09:43 pm PDT, created. Chen, July 22, 1985 7:51:28 pm PDT => Cedar6.0. Chen, November 24, 1985 2:54:48 pm PST, modified for Graph package. Chen, November 24, 1985 2:54:48 pm PST, Messages blink only afterwards. TThymeCleanUp.mesa Copyright c 1985 by Xerox Corporation. All rights reserved. Last Edited by: Last Edited by: Jacobi June 10, 1986 6:57:54 pm PDT Christian LeCocq February 3, 1987 5:27:44 pm PST Sweetsun Chen, November 24, 1985 3:25:48 pm PST Christian Jacobi, June 10, 1986 6:57:37 pm PDT checkProcess close IO nil other refs on vars reset progress/status epilog thyme.errors input file and included files text outputs graph viewers gndNodeName _ NilNamePtr[gndNodeName]; undefNode _ NilNamePtr[undefNode]; cktRoot _ NilNamePtr[cktRoot]; currentCkt _ NilNamePtr[currentCkt]; worst nodes ��3��Icode��K�� m�1�<��K��0�k�3K�0K��,��/K��+��.�K�� K��K�� )K�� -K�� K��K��K��$K��K�� K�� K��n��K�� K�� K�� K��K��K��K��K��K��K�K��K��(K��K��"K��&�@K��K��9�9K�K�K��2�2K��$�$K��K��K��K��K��K��*�*K��K��$K��ct � K��&� ��&��d��-K��'�'K��8��3K�� '�5��K��/��5K��K��K��K��K��K�K��K��K��c��K��K��K��4�4K��'K��P�PK��K��K��(�(K�� >K��G�GK��D�DK��K��K�� K��3��X� ��8t@