DIRECTORY
Atom USING [GetPropFromList, PropList],
IO USING [int, PutF, rope],
Rope USING [Cat, Concat, Equal, Fetch, FromRefText, Length, ROPE],
spGlobals USING[Aborted, argNames, branch, branchLink, branchLinkPtr, branchPtr, Canned, CapacitorBody, conLinkPtr, elements, error, error2, ErrorSignal, ErrorStrings, eval, expressionPtr, FunctionBody, Handle, HashKey, hashModulus, InductorBody, instTreeNode, instTreePtr, ISourceBody, modBrPtr, ModelArgHash, ModelBody, modelBranch, modFuncBlk, modFuncPtr, namePtr, next, node, nodePtr, nodePtrSeq, RealBranch, RealModel, RealNode, RealParm, realThingPtr, realThing, realThings, RefBranchRec, RefCircuitRec, RefCktInstRec, RefFunctionRec, RefModBody, RefModelRec, RefNodeRec, RefParmRec, refR, RefRealBranch, RefRealModel, RefRealNode, RefRealParm, RefUnReal, refUnReal, ValueSeq, VSourceBody],
spGlobalsExtras USING [CombineInstancesProc, IsUsefulProc];

spBomb: CEDAR PROGRAM
IMPORTS Atom, IO, Rope, spGlobals
EXPORTS spGlobals=

BEGIN OPEN spGlobals;

pushCopies: PROC[nameList: namePtr]= {

FOR nl: namePtr_ nameList, nl.srchLink UNTIL nl = NIL DO
nl.realCopy_ WITH nl.details SELECT FROM
x: RefCircuitRec => NIL,
x: RefCktInstRec => NIL,
x: RefFunctionRec => NIL,
p: RefParmRec => NEW[realThing_ [
nextThing: nl.realCopy,
thing: IF p.default THEN NEW[RealParm_ [rp: p.dfltValue]]
ELSE refUnReal] ],
ENDCASE => NEW[realThing_ [
nextThing: nl.realCopy,
thing: refUnReal] ];
ENDLOOP;
}; -- pushCopies

advanceLevel: PROC[nameList: namePtr]= {
FOR nl: namePtr_ nameList, nl.srchLink UNTIL nl = NIL DO
IF nl.realCopy # NIL THEN nl.realCopy.newLevel_ FALSE;
ENDLOOP;
}; -- advanceLevel

popCopies: PROC[handle: Handle, nameList: namePtr]= {
FOR nl: namePtr_ nameList, nl.srchLink UNTIL nl = NIL DO
WITH nl.details SELECT FROM
x: RefCircuitRec => NULL;
x: RefCktInstRec => NULL;
x: RefFunctionRec => NULL;
n: RefNodeRec =>
WITH nl.realCopy.thing SELECT FROM
r: RefRealNode => {
IF r.rn.branches # NIL THEN {
handle.vars.nodeCount_ handle.vars.nodeCount + 1;
r.rn.nextNode_ handle.vars.nodeList;
handle.vars.nodeList_ r.rn;
}
ELSE {
r.rn.nextNode_ handle.vars.unusedNodes;
handle.vars.unusedNodes_ r.rn;
};
nl.realCopy_ nl.realCopy.nextThing;
};
ENDCASE => nl.realCopy_ nl.realCopy.nextThing;
ENDCASE => nl.realCopy_ nl.realCopy.nextThing;
ENDLOOP;
}; -- popCopies

getParmValue: PUBLIC PROC[handle: Handle, nPtr: namePtr] RETURNS[REAL]= {
ENABLE ErrorSignal => ErrorSignal[331, s];
getRealThing[handle, nPtr];
RETURN[IF handle.vars.n # NIL THEN LOOPHOLE[handle.vars.n] ELSE handle.vars.p]
-- *
}; -- getParmValue

getRealThing: PROC[handle: Handle, nPtr: namePtr]= {

rCopy: realThingPtr;

handle.vars.n_ NIL; handle.vars.b_ NIL; handle.vars.m_ NIL; handle.vars.p_ 0.0;
IF nPtr=NIL THEN RETURN;
rCopy_ nPtr.realCopy;
IF rCopy # NIL THEN IF rCopy.newLevel THEN rCopy_ rCopy.nextThing;
IF rCopy # NIL THEN
WITH rCopy.thing SELECT FROM
rt: RefRealNode => handle.vars.n_ rt.rn;
rt: RefRealBranch => handle.vars.b_ rt.rb;
rt: RefRealParm => handle.vars.p_ rt.rp;
rt: RefRealModel => handle.vars.m_ rt.rm;
rt: RefUnReal => ErrorSignal[330, nPtr.name];
ENDCASE
ELSE
WITH nPtr.details SELECT FROM
pn: RefParmRec =>
IF pn.default THEN handle.vars.p_ pn.dfltValue ELSE ErrorSignal[331, nPtr.name];
ENDCASE => error2[handle, 390, nPtr];
}; -- getRealThing

putRealThing: PROC[handle: Handle, nPtr: namePtr, t: realThings]= {

rCopy: realThingPtr_ nPtr.realCopy;
IF rCopy # NIL THEN
SELECT t FROM
realNode => rCopy.thing_ NEW[RealNode_ [rn: handle.vars.n]];
realBranch => rCopy.thing_ NEW[RealBranch_ [rb: handle.vars.b]];
realParm => rCopy.thing_ NEW[RealParm_ [rp: handle.vars.p]];
realModel => rCopy.thing_ NEW[RealModel_ [rm: handle.vars.m]];
ENDCASE;
}; -- putRealThing

putParmValue: PUBLIC PROC[handle: Handle, nPtr: namePtr, val: REAL]= {
handle.vars.p_ val;
putRealThing[handle, nPtr, realParm];
}; -- putParmValue

makeConnections: PROC[handle: Handle, connections: conLinkPtr, fakes: namePtr]= {
UNTIL fakes=NIL DO
getRealThing[handle, connections.namedNode];
putRealThing[handle, fakes, realNode];
fakes_ fakes.nextName;
connections_ connections.nextLink;
ENDLOOP;
}; -- makeConnections

apply: PROC[handle: Handle, apList: expressionPtr]= {
FOR ex: expressionPtr _ apList, ex.next UNTIL ex=NIL DO
[]_ eval[handle, ex];
ENDLOOP;
}; -- apply

explodeInstance: PROC[handle: Handle, instNamePtr: namePtr] RETURNS[t: instTreePtr]= {
inst: RefCktInstRec_ NARROW[instNamePtr.details];
ckt: namePtr_ NARROW[inst.of];
cktDetails: RefCircuitRec_ NARROW[ckt.details];

pushCopies[cktDetails.names];
makeConnections[handle, inst.connections, cktDetails.fakeNodes];
apply[handle, inst.actualParms];
advanceLevel[cktDetails.names];
t_ NEW[instTreeNode_ [instance: instNamePtr] ];
FOR exp: expressionPtr _ cktDetails.assertions, exp.next UNTIL exp=NIL DO
IF eval[handle, exp]=0.0 THEN error2[handle, 341, instNamePtr];
ENDLOOP;
explode[handle, ckt, t];
popCopies[handle, cktDetails.names];
}; -- explodeInstance


explodeModelFunc: PROC[handle: Handle, mfNamePtr: namePtr, newFunc: modFuncPtr]= {
index: NAT;
arguments: argNames;
parms: expressionPtr;
data: REF ANY;

WITH mfNamePtr.details SELECT FROM
m: RefModelRec => {
newFunc.argVector_ m.modelArgVec;
arguments_ m.modelArgs;
parms_ m.modelParms;
data _ m.data;
};
f: RefFunctionRec => {
newFunc.argVector_ f.funcArgVec;
arguments_ f.funcArgs;
parms_ f.funcParms;
data _ f.data;
};
ENDCASE => error2[handle, 399, mfNamePtr];

IF arguments # NIL THEN {
newFunc.arguments_ NEW[nodePtrSeq[arguments.size]];
newFunc.arguments.visited _ FALSE;
FOR index IN [0..arguments.size) DO
IF arguments[index] # NIL THEN getRealThing[handle, arguments[index]];
newFunc.arguments[index]_ handle.vars.n;
ENDLOOP;
};

index_ 0;
FOR p: expressionPtr_ parms, p.next UNTIL p=NIL DO index_ index + 1; ENDLOOP;
newFunc.parmVector_ NEW[ValueSeq[index]];
newFunc.parmVector.visited _ FALSE;
newFunc.parmVector.handle _ handle;
newFunc.parmVector.modFunc _ newFunc;
UNTIL index=0 DO
index_ index - 1;
newFunc.parmVector[index]_ eval[handle, parms];
parms_ parms.next;
ENDLOOP;
}; -- explodeModelFunc

explodeController: PROC[handle: Handle, branchNamePtr: namePtr, newB: branchPtr]= {
brDetails: RefBranchRec_ NARROW[branchNamePtr.details];
oldmf: namePtr_ brDetails.controller;
newFunc: modFuncPtr;
newModB: modBrPtr;

WITH oldmf.details SELECT FROM
fcn: RefFunctionRec => {
handle.vars.funcCount_ handle.vars.funcCount + 1;
newFunc_ NEW[modFuncBlk_ [
nextMFPtr: handle.vars.functionList,
body: NEW[FunctionBody_ [functionProc: fcn.functionProc, branch: newB]]
]];
handle.vars.functionList_ newFunc; -- *
explodeModelFunc[handle, oldmf, newFunc];
newB.controller_ newFunc;
};
mod: RefModelRec => {
mBody: RefModBody;
getRealThing[handle, oldmf];
mBody_ NARROW[handle.vars.m.body];
newModB_ NEW[modelBranch_ [nextBranch: mBody.modelBranches, b: newB]];
mBody.modelBranches_ newModB;
newB.controller_ handle.vars.m;
newB.modelIndex_ brDetails.modelIndex;
};
ENDCASE => error2[handle, 399, branchNamePtr];
}; -- explodeController

connectBranch: PROC[n: nodePtr, b: branchPtr, pos: BOOL]= {
IF n # NIL THEN {
n.branches_ NEW[branchLink_ [nextLink: n.branches, branch: b, pos: pos]];
IF pos THEN b.posNode_ n ELSE b.negNode_ n;
}
ELSE ErrorSignal[242, b.branchName.name];
}; -- connectBranch

explodeBranch: PROC[handle: Handle, branchNamePtr: namePtr]
RETURNS[newB: branchPtr_ NIL]= {
pNode, nNode: nodePtr;
newC, newL, newV, newI: branchPtr;
brDetails: RefBranchRec_ NARROW[branchNamePtr.details];
brValue: REAL;

ParallelsExistingBranch: PROC [branchType: elements] RETURNS [BOOL] = {
IF NOT (Rope.Fetch[branchNamePtr.name, 0] = '? -- anonymous
AND brDetails.controller = NIL -- constant value
) THEN RETURN[FALSE]; -- can't add this one to any other
IF brValue = 0 THEN RETURN[TRUE]; -- throw this one away
FOR list: REF branchLink _ pNode.branches, list.nextLink WHILE list # NIL DO
details: REF ANY;
branchName: namePtr;
otherBranch: branchPtr = list.branch;
IF otherBranch.negNode = nNode -- same connections
AND ISTYPE[(details _ (branchName _ otherBranch.branchName).details), RefBranchRec]
AND NARROW[details, RefBranchRec].branchType = branchType -- same branch type
AND Rope.Fetch[branchName.name, 0] = '? -- also anonymous
AND otherBranch.controller = NIL -- constant value
THEN {
otherBranch.comVal _ otherBranch.comVal+eval[handle, brDetails.valExpr];
RETURN[TRUE];
};
ENDLOOP;
RETURN[FALSE];
};

handle.vars.branchCount_ handle.vars.branchCount + 1;
getRealThing[handle, brDetails.posNode];
pNode_ handle.vars.n;
getRealThing[handle, brDetails.negNode];
nNode_ handle.vars.n;
SELECT TRUE FROM
brDetails.controller = NIL => brValue _  eval[handle, brDetails.valExpr];
ENDCASE =>
WITH brDetails.controller.details SELECT FROM
mod: RefModelRec => {
getRealThing[handle, brDetails.controller];
IF handle.vars.m.body = $useless THEN RETURN;
};
ENDCASE => NULL;

IF pNode # nNode THEN {
SELECT brDetails.branchType FROM
resistor => newB_ NEW[branch_ [body: refR]];
capacitor=> {
IF ParallelsExistingBranch[capacitor] THEN RETURN;
newB_ newC_ NEW[branch_
[body: NEW[CapacitorBody_ [nextCapacitor: handle.vars.capacitorList]] ] ];
handle.vars.capacitorList_ newC;
};
inductor => {
newB_ newL_ NEW[branch_
[body: NEW[InductorBody_ [nextInductor: handle.vars.inductorList ]] ] ];
handle.vars.inductorList_ newL;
};
vSource  => {
newB_ newV_ NEW[branch_
[body: NEW[VSourceBody_ [nextvSource: handle.vars.vSourceList  ]] ] ];
handle.vars.vSourceList_ newV;
};
iSource  => {
IF ParallelsExistingBranch[iSource] THEN RETURN;
newB_ newI_ NEW[branch_
[body: NEW[ISourceBody_ [nextiSource: handle.vars.iSourceList  ]] ] ];
handle.vars.iSourceList_ newI;
};
ENDCASE => error2[handle, 391, branchNamePtr];
handle.vars.b_ newB;
putRealThing[handle, branchNamePtr, realBranch];
newB.branchName_ branchNamePtr;
newB.comVal_ brValue;
newB.posNode _ pNode;
newB.negNode _ nNode;
IF brDetails.controller # NIL THEN
explodeController[handle, branchNamePtr, newB];
connectBranch[pNode, newB, TRUE];
connectBranch[nNode, newB, FALSE];
};
}; -- explodeBranch

explode: PROC[handle: Handle, ckt: namePtr, tree: instTreePtr]= {
curName: namePtr;
newModel: modFuncPtr;
newB: branchPtr;
newTree: instTreePtr;
cktDetails: RefCircuitRec_ NARROW[ckt.details];

IF Canned[handle] THEN SIGNAL Aborted;
FOR curName_ cktDetails.names, curName.srchLink UNTIL curName=NIL DO
WITH curName.details SELECT FROM
x: RefNodeRec => {
handle.vars.n_ tree.nodes_ NEW[node_ [
nodeName: curName,
treeLevel: tree,
brotherNodes: tree.nodes] ];
putRealThing[handle, curName, realNode];
};
ENDCASE;
ENDLOOP;

FOR curName_ cktDetails.names, curName.srchLink UNTIL curName=NIL DO
ENABLE ErrorSignal => {
ErrorStrings[handle, error, treeError[handle, tree, curName], s];
LOOP;
};
WITH curName.details SELECT FROM
rm: RefModelRec => {
handle.vars.modelCount_ handle.vars.modelCount + 1;
newModel_ NEW[modFuncBlk_ [
nextMFPtr: handle.vars.functionList,
body: NEW[ModelBody_
[modelProc: rm.modelProc,
modelResults: rm.modelResults,
modelName: curName,
oldArgVector: rm.modelOldArgVec]]
]];
handle.vars.functionList_ newModel;
explodeModelFunc[handle, curName, newModel];
IF ModelInstanceUseful[handle, rm, newModel] THEN {
IF GetPropFromRef[rm.data, $CombineInstancesProc] # NIL THEN { -- register this instance for comparing with future ones
key: HashKey = HashArgs[newModel];
IF  handle.vars.modelArgs = NIL THEN
handle.vars.modelArgs _ NEW[ModelArgHash _ ALL[NIL]];
handle.vars.modelArgs[key] _ CONS[newModel, handle.vars.modelArgs[key]];
};
}
ELSE newModel.body _ $useless;
handle.vars.m_ newModel;
putRealThing[handle, curName, realModel];
};
ENDCASE;
ENDLOOP;

FOR curName_ cktDetails.names, curName.srchLink UNTIL curName=NIL DO
ENABLE ErrorSignal => {
ErrorStrings[handle, error, treeError[handle, tree, curName], s];
LOOP;
};
WITH curName.details SELECT FROM
x: RefBranchRec => {
newB_ explodeBranch[handle, curName];
IF newB # NIL THEN {
newB.brotherBranches_ tree.branches;
newB.treeLevel_ tree;
tree.branches_ newB;
};
};
x: RefCktInstRec => {
newTree_ explodeInstance[handle, curName];
newTree.father_ tree;
newTree.brothers_ tree.sons;
tree.sons_ newTree;
};
ENDCASE;
ENDLOOP;
}; -- explode

ModelInstanceUseful: PROC [ handle: Handle, proto: RefModelRec, inst: modFuncPtr ]
RETURNS [ useful: BOOL _ TRUE ] = {
r: REF ANY;
IF (r _ GetPropFromRef[proto.data, $IsUsefulProc]) # NIL THEN {
isUsefulProc: spGlobalsExtras.IsUsefulProc =
NARROW[r, REF spGlobalsExtras.IsUsefulProc]^;
IF ~ isUsefulProc[inst.parmVector] THEN RETURN[FALSE];
};
IF (r _ GetPropFromRef[proto.data, $CombineInstancesProc]) # NIL THEN {
combineInstancesProc: spGlobalsExtras.CombineInstancesProc =
NARROW[r, REF spGlobalsExtras.CombineInstancesProc]^;
match: modFuncPtr = FindMatchingModelInstance[handle, inst];
IF match # NIL
AND combineInstancesProc[parmsA: match.parmVector, parmsB: inst.parmVector]
THEN RETURN[FALSE];
};
};

GetPropFromRef: PROC [ propList, prop: REF ANY ] RETURNS [ val: REF ANY ] = {
WITH propList SELECT FROM
pl: Atom.PropList => val _ Atom.GetPropFromList[pl, prop];
ENDCASE => val _ NIL;
};

HashArgs: PROC [ model: modFuncPtr ] RETURNS [ key: HashKey ] = {
sum: INT _ 0;
FOR i: NAT IN [0..model.arguments.size) DO
TRUSTED {sum _ sum+LOOPHOLE[model.arguments[i], INT]};
ENDLOOP;
IF sum < 0 THEN sum _ -sum;
key _ sum MOD hashModulus;
};

FindMatchingModelInstance: PROC [ handle: Handle, inst: modFuncPtr ] RETURNS [ match: modFuncPtr _ NIL ] = {
key: HashKey = HashArgs[inst];
prevList: LIST OF REF ANY _ NIL;
IF handle.vars.modelArgs = NIL THEN handle.vars.modelArgs _
NEW[ModelArgHash _ ALL[NIL]];
FOR list: LIST OF REF ANY _ handle.vars.modelArgs[key], list.rest WHILE list#NIL
DO
{
WITH list.first SELECT FROM
mf: modFuncPtr => { -- matches if arguments are the same and model name is the same.
IF inst.arguments.size # mf.arguments.size THEN GOTO Mismatch;
FOR  i: NAT IN [0..inst.arguments.size) DO
IF inst.arguments[i] # mf.arguments[i] THEN GOTO Mismatch;
ENDLOOP;
WITH mf.body SELECT FROM
mb: RefModBody =>
WITH inst.body SELECT FROM
nfb: RefModBody =>
IF mb.modelName # nfb.modelName THEN GOTO Mismatch;
ENDCASE => GOTO Mismatch;
ENDCASE => GOTO Mismatch;

IF prevList # NIL THEN { -- there's a match, move it to the front
prevList.rest _ list.rest;
list.rest _ handle.vars.modelArgs[key];
handle.vars.modelArgs[key] _ list;
};
RETURN[match: mf];
};
ENDCASE => NULL;
EXITS Mismatch => NULL
};
prevList _ list;
ENDLOOP;
}; -- end of FindMatchingModelInstance

treeError: PROC[handle: Handle, t: instTreePtr, n: namePtr] RETURNS[Rope.ROPE]= {
RETURN[Rope.Concat[printTree[handle, t, TRUE], n.name]];
}; -- treeError

AlphaNumeric: PROC[name: Rope.ROPE] RETURNS[an: BOOL_ FALSE]= {
tChar: CHAR_ Rope.Fetch[name, 0];
an_ tChar IN ['a..'z] OR tChar IN ['A..'Z]; -- first char should not be numeric
IF an THEN
FOR i: INT IN [1..Rope.Length[name]) DO
tChar_ Rope.Fetch[name, i];
an_ tChar IN ['a..'z] OR tChar IN ['A..'Z] OR tChar IN ['0..'9];
IF ~an THEN RETURN;
ENDLOOP;
}; -- AlphaNumeric

printTree: PROC[handle: Handle, t: instTreePtr, toRope: BOOL _ FALSE]
RETURNS[r: Rope.ROPE _ NIL]= {
IF t # NIL AND t # handle.vars.treeRoot THEN {
tName: Rope.ROPE _ t.instance.name;
r _ printTree[handle, t.father, toRope].Concat[ 
IF AlphaNumeric[tName] THEN tName.Concat["/"] ELSE Rope.Cat["$", tName, "$/"] ];
};
IF toRope THEN RETURN ELSE {
handle.msgStream.PutF["%g", IO.rope[r]];
r _ NIL;
};
}; -- printTree

printNode: PROC[handle: Handle, n: nodePtr, ok, toRope: BOOL _ FALSE]
RETURNS[r: Rope.ROPE _ NIL]= {
nName: Rope.ROPE _ n.nodeName.name;
r_ printTree[handle, n.treeLevel, toRope].Concat[
IF ok OR AlphaNumeric[nName] THEN nName ELSE Rope.Cat["$", nName, "$"]
];
IF NOT toRope THEN {
handle.msgStream.PutF["%g", IO.rope[r]];
r _ NIL;
};
}; -- printNode

printBranch: PROC[handle: Handle, b: branchPtr, ok, toRope: BOOL_ FALSE]
RETURNS[r: Rope.ROPE_ NIL]= {
bName: Rope.ROPE _ b.branchName.name;
r_ printTree[handle, b.treeLevel, toRope].Concat[
IF ok OR AlphaNumeric[bName] THEN bName ELSE Rope.Cat["$", bName, "$"]
];
IF NOT toRope THEN {
handle.msgStream.PutF["%g", IO.rope[r]];
r _ NIL;
};
}; -- printBranch

makeStringNB: PUBLIC PROC[handle: Handle, n: nodePtr, b: branchPtr, ok: BOOL_ TRUE]
RETURNS[Rope.ROPE]= { -- NB: Node/Branch; ok: non-alphanumeric chars allowed.
RETURN[IF n # NIL
THEN printNode[handle, n, ok, TRUE]
ELSE printBranch[handle, b, ok, TRUE]
];
}; -- makeStringNB

printTreeWithCktNames: PROC[handle: Handle, t: instTreePtr] = {
IF t = NIL OR t = handle.vars.treeRoot THEN handle.msgStream.PutF["\t"]
ELSE {
tInstDetails: RefCktInstRec _ IF ISTYPE[t.instance.details, RefCktInstRec] THEN NARROW[t.instance.details] ELSE NIL;
cktName: Rope.ROPE _ IF tInstDetails # NIL THEN tInstDetails.of.name ELSE NIL;
printTreeWithCktNames[handle, t.father];
handle.msgStream.PutF["%g(%g)/", IO.rope[t.instance.name], IO.rope[cktName]];
};
}; -- printTreeWithCktNames

printUnusedNodes: PROC[handle: Handle, n: nodePtr] = {
FOR n: nodePtr _ handle.vars.unusedNodes, n.nextNode UNTIL n=NIL DO
nName: Rope.ROPE _ n.nodeName.name;
printTreeWithCktNames[handle, n.treeLevel];
handle.msgStream.PutF["%g", IO.rope[n.nodeName.name]];
handle.msgStream.PutF[IF n.nextNode = NIL THEN ".\n\n" ELSE ",\n"];
ENDLOOP;
}; -- printUnusedNodes

printHole: PUBLIC PROC[handle: Handle]= {
handle.msgStream.PutF["\nNodes --\n"];
FOR n: nodePtr_ handle.vars.nodeList, n.nextNode UNTIL n=NIL DO
[]_ printNode[handle, n, TRUE];
handle.msgStream.PutF["_ {"];
FOR bLink: branchLinkPtr_ n.branches, bLink.nextLink UNTIL bLink=NIL DO
[]_ printBranch[handle, bLink.branch, TRUE];
IF bLink.branch.posNode=n THEN handle.msgStream.PutF["+"]
ELSE handle.msgStream.PutF["-"];
IF bLink.nextLink # NIL THEN handle.msgStream.PutF[", "];
ENDLOOP;
handle.msgStream.PutF["}.\n"];
ENDLOOP;
}; -- printHole

findNB: PROC[handle: Handle, tree: instTreePtr] RETURNS[n: nodePtr_ NIL, b: branchPtr_ NIL]= {
IF handle.vars.item=name THEN {
i: instTreePtr;
FOR i_ tree.sons, i.brothers UNTIL i=NIL DO
IF Rope.Equal[i.instance.name, Rope.FromRefText[handle.vars.newString]] THEN EXIT;
ENDLOOP;
IF i # NIL THEN {
next[handle];
IF handle.vars.item=slash THEN next[handle]
ELSE error[handle, 300, FALSE];
[n, b]_ findNB[handle, i];
}
ELSE {
FOR n_ tree.nodes, n.brotherNodes UNTIL n=NIL DO
IF Rope.Equal[n.nodeName.name, Rope.FromRefText[handle.vars.newString]] THEN EXIT;
ENDLOOP;
IF n=NIL THEN FOR b_ tree.branches, b.brotherBranches UNTIL b=NIL DO
IF Rope.Equal[b.branchName.name, Rope.FromRefText[handle.vars.newString]] THEN EXIT;
ENDLOOP;
next[handle];
};
}
ELSE error[handle, 301, FALSE];
}; -- findNB

findNodeOrBranch: PUBLIC PROC[handle: Handle] RETURNS[n: nodePtr, b: branchPtr]= {
[n, b]_ findNB[handle, handle.vars.treeRoot];
}; -- findNodeOrBranch

fillInBranchLinks: PROC[handle: Handle]= {
FOR nodes: nodePtr_ handle.vars.nodeList, nodes.nextNode UNTIL nodes=NIL DO
FOR links: branchLinkPtr_ nodes.branches, links.nextLink UNTIL links=NIL DO
links.otherNode_ IF links.pos THEN links.branch.negNode ELSE links.branch.posNode;
ENDLOOP;
ENDLOOP;
}; -- fillInBranchLinks

bomb: PUBLIC PROC[handle: Handle]= {
cktRootDetails: RefCircuitRec_ NARROW[handle.vars.cktRoot.details];
handle.vars.treeRoot_ NEW[instTreeNode_ []];
pushCopies[cktRootDetails.names];
advanceLevel[cktRootDetails.names];
explode[handle, handle.vars.cktRoot, handle.vars.treeRoot];
getRealThing[handle, handle.vars.gndNodeName];
handle.vars.gndNode_ handle.vars.n;
popCopies[handle, cktRootDetails.names];
fillInBranchLinks[handle];

handle.msgStream.PutF[
"\n\nTotal %g nodes, %g models, %g functions, and %g branches.\n\n",
IO.int[handle.vars.nodeCount],
IO.int[handle.vars.modelCount],
IO.int[handle.vars.funcCount],
IO.int[handle.vars.branchCount]];

IF handle.vars.unusedNodes # NIL THEN {
handle.msgStream.PutF["Unused nodes:\n"];
printUnusedNodes[handle, handle.vars.unusedNodes];
};
}; -- bomb

END.
 
CHANGE LOG

Wilhelm, March 16, 1982  9:41 AM
Barth, 7-May-82 10:48:59 PDT
Chen, February 12, 1984  7:50 PM, modified to support oldArgVector.
Chen, June 10, 1984 9:47:59 pm PDT, cedarized.
McCreight, April 2, 1985 3:41:00 pm PST.
Chen, July 22, 1985 7:56:50 pm PDT, => Cedar6.0.

ήFile: spBomb.mesa
Copyright (C) 1985 by Xerox Corporation.  All rights reserved.
Last Edited by:
Sweetsun Chen, July 22, 1985 8:04:35 pm PDT

For each namePtr linked with the nameList, initialize its realCopy as follows:
if the namePtr points to a circuit, a circuit instance, a model or a function, its realCopy is assigned nil;
otherwise, allocate and initialize its realCopy as following:
the "nextThing" of the new realCopy is the original realCopy,
its "newLevel" is the default (TRUE),
its "thing" is unReal, unless the namePtr is a parameter name pointer with default, in which case "thing" points to the default value.
For each namePtr linked with the nameList do the following:
If its details points to a circuit, a circuit instance, or a function, then do nothing;
otherwise, pop up its realCopy.nextThing as its realCopy;
If the original realCopy points to a nodePtr, then
if it has nonNIL branches then pop the nodePtr on the handle.vars.nodeList, with original handle.vars.nodeList as its nextNode, and increment handle.vars.nodeCount;
otherwise if its branches is nil then pop the nodePtr on top of handle.vars.unusedNodes with the original handle.vars.unusedNodes as its nextNode.
Reset n,b,m,and p; If nPtr and its realCopy is not NIL then depending on the type of its realCopy (or the non-nil nextThing of its realCopy, if its realCopy.newLevel is TRUE), set n,b,m, or p accordingly; but if its realCopy (or the nextThing, see above) is NIL and nPtr.details.default then set p with the default.
Depending on the type of t, initialize nPtr.realCopy.thing to point to (the content of) n, b, p, or m.
For each connection linked with connections, set n to its namedNode.realCopy.thing.rn; let fakes.realCopy.thing point to n, then proceed similarly (for connection.nextLink with fakes.nextName, and so on). 
.. so the model or function can know its environment in case of error
initialize each parameter of newFunc
See whether this model instance non-trivial and cannot be combined with another
Κζ–

"cedar" style˜Jš
Οc™Jš
œ>™>š
œ™Icode™+—J™š
Οk	˜	Jšœžœ˜'Jšžœ
žœ˜Jšœžœ2žœ˜BJšœ
žœ©˜ΈJšœžœ&˜;—J˜šœžœ
ž˜Jšžœžœ˜!Jšžœ˜—J˜Jšžœ
žœ˜J˜šœžœ˜&š
ΠctN™NJš
Ÿl™lš
Ÿ=™=JšŸ<œ
™=JšŸΠktŸ™%Jš
٠
™†
——J˜šžœ$žœžœ
ž˜8šœ
žœžœ
ž˜(Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜šœžœ
˜!Jš
œ˜šœžœžœ
žœ˜9Jšžœ˜——šžœžœ
˜Jš
œ˜Jš
œ˜——Jšžœ
˜—JšœŸ
˜—J˜šœžœ˜(šžœ$žœžœ
ž˜8Jšžœžœ
žœžœ
˜6Jšžœ
˜—JšœŸ˜—J˜šœžœ&˜5š
Ÿ;™;JšŸWœŸ.™‘
š
Ÿ2™2Jšœ	Ÿ›
™€
Jšœ
Ÿˆ
™’
——šžœ$žœžœ
ž˜8šžœžœ
ž˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜š
œ˜šžœžœ
ž˜"š
œ˜šžœžœ
žœ˜Jš
œ1˜1Jš
œ$˜$Jš
œ˜Jš
œ
˜
—šžœ˜Jš
œ'˜'Jš
œ˜Jš
œ˜—Jš
œ#˜#Jš
œ˜—Jšžœ'˜.——Jšžœ'˜.—Jšžœ
˜—JšœŸ˜—J˜š	œžœ
žœ žœ
žœ˜IJšžœ$˜*Jš
œ˜Jšžœ
žœžœ
žœ
žœžœ˜NJš
Ÿ˜JšœŸ˜—J˜šœžœ"˜4Jš
Ÿ»™»J˜Jš
œ˜J˜Jšœžœžœžœ˜OJšžœžœ
žœ
žœ
˜Jš
œ˜Jš
žœ	žœ
žœ
žœžœ˜Bšžœ	žœ
ž˜šžœ
žœ
ž˜Jš
œ(˜(Jš
œ*˜*Jš
œ(˜(Jš
œ)˜)Jš
œ-˜-Jš
ž˜——š
ž˜šžœžœ
ž˜š
œ˜Jšžœžœžœ˜P—Jšžœ˜%——JšœŸ˜—J˜šœžœ1˜CJš
Ÿf™fJ˜Jš
œ#˜#šžœ	žœ
ž˜šžœž˜
Jšœžœ ˜<Jšœžœ"˜@Jšœžœ ˜<Jšœžœ!˜>Jšžœ
˜——JšœŸ˜—J˜šœžœ
žœ%žœ˜FJš
œ˜Jš
œ%˜%JšœŸ˜—J˜šœžœ<˜QJš
ŸΝ
™Ν
šžœžœ
ž˜Jš
œ,˜,Jš
œ&˜&Jš
œ˜Jš
œ"˜"Jšžœ
˜—JšœŸ˜—J˜šœžœ*˜5šžœ%žœžœ
ž˜7Jš
œ˜Jšžœ
˜—JšœŸ	˜—J˜šœžœ'žœ˜VJšœžœ˜1Jšœžœ
˜Jšœžœ˜/J˜Jš
œ˜Jš
œ@˜@Jš
œ ˜ Jš
œ˜Jšœžœ)˜/šžœ6žœžœ
ž˜IJšžœžœ"˜?Jšžœ
˜—Jš
œ˜Jš
œ$˜$JšœŸ˜J˜—J˜šœžœ<˜RJšœžœ
˜Jš
œ˜Jš
œ˜Jšœžœ
žœ
˜J˜šžœžœ
ž˜"š
œ˜Jš
œ!˜!Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—š
œ˜Jš
œ ˜ Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jšžœ#˜*—J˜šžœ
žœ
žœ˜Jšœžœ˜3Jšœžœ
˜"šžœžœž˜#Jšžœžœ
žœ(˜FJš
œ(˜(Jšžœ
˜—Jš
œ˜—J˜Jš
œ	˜	Jš
žœ!žœžœ
žœžœ
˜MJšœžœ˜)Jšœžœ
˜#Jš
œ#˜#š
œ%˜%Jš
œE™E—Jš
œ$™$šžœ	ž˜Jš
œ˜Jš
œ/˜/Jš
œ˜Jšžœ
˜—JšœŸ˜—J˜šœžœ<˜SJšœžœ˜7Jš
œ%˜%Jš
œ˜Jš
œ˜J˜šžœžœ
ž˜š
œ˜Jš
œ1˜1šœ	žœ˜Jš
œ$˜$Jšœžœ>˜GJš
œ˜—Jšœ#˜'Jš
œ)˜)Jš
œ˜Jš
œ˜—š
œ˜Jš
œ˜Jš
œ˜Jšœžœ˜"Jšœ	žœ:˜FJš
œ˜Jš
œ˜Jš
œ&˜&Jš
œ˜—Jšžœ'˜.—JšœŸ˜—J˜šœžœ žœ˜;šžœžœ
žœ˜Jšœžœ:˜IJšžœžœžœ˜+Jš
œ
˜
—Jšžœ%˜)JšœŸ˜—J˜šœžœ(˜;Jšžœžœ˜ Jš
œ˜Jš
œ"˜"Jšœžœ˜7Jšœ	žœ
˜J˜šΟnœžœžœžœ˜Gšžœ
žœ)˜;Jšžœž˜0Jšœžœ
žœ
žœ"˜8—Jš	žœ
žœ
žœ
žœ˜8š	žœžœ,žœžœ
ž˜LJšœ	žœ
žœ
˜Jš
œ˜Jš
œ%˜%šžœ˜2Jšžœ
žœI˜SJšžœ
žœ0˜MJšžœ%˜9Jšžœž˜2šžœ˜Jš
œH˜HJšžœ
žœ˜
Jš
œ˜——Jšžœ
˜—Jšžœ
žœ˜Jš
œ˜J˜—Jš
œ5˜5Jš
œ(˜(Jš
œ˜Jš
œ(˜(Jš
œ˜šžœ
žœ
ž˜Jšœžœ/˜Išžœ˜
šžœžœ
ž˜-š
œ˜Jš
œ+˜+Jšžœžœ
žœ
˜-Jš
œ˜—Jšžœžœ
˜———J˜šžœžœ˜šžœž˜ Jšœžœ˜,š
œ
˜
Jšžœ$žœ
žœ
˜2šœžœ˜Jšœžœ@˜J—Jš
œ ˜ Jš
œ˜—š
œ
˜
šœžœ˜Jšœžœ>˜H—Jš
œ˜Jš
œ˜—š
œ
˜
šœžœ˜Jšœžœ<˜F—Jš
œ˜Jš
œ˜—š
œ
˜
Jšžœ"žœ
žœ
˜0šœžœ˜Jšœžœ<˜F—Jš
œ˜Jš
œ˜—Jšžœ'˜.—Jš
œ˜Jš
œ0˜0Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜šžœžœ
ž˜"Jš
œ/˜/—Jšœžœ˜!Jšœžœ˜"Jš
œ˜—JšœŸ˜—J˜šœ	žœ4˜AJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ˜/J˜Jšžœžœ
žœ	˜&šžœ-žœ	žœ
ž˜Dšžœžœ
ž˜ š
œ˜šœžœ˜&Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ(˜(Jš
œ˜—Jšžœ
˜—Jšžœ
˜—J˜šžœ-žœ	žœ
ž˜Dšžœ˜Jš
œA˜AJšžœ
˜Jš
œ˜—šžœžœ
ž˜ š
œ˜Jš
œ3˜3šœ
žœ˜Jš
œ$˜$šœžœ˜Jš
œn˜n—Jš
œ˜—Jš
œ#˜#Jš
œ,˜,šžœ+žœ˜3šžœ2žœ
žœ8˜wJš
œ"˜"šžœžœ
ž˜$Jšœžœžœ
žœ˜5—Jšœžœ'˜HJ˜—J˜
—Jšžœ˜Jš
œ˜Jš
œ)˜)Jš
œ˜—Jšžœ
˜—Jšžœ
˜J˜—šžœ-žœ	žœ
ž˜Dšžœ˜Jš
œA˜AJšžœ
˜Jš
œ˜—šžœžœ
ž˜ š
œ˜Jš
œ%˜%šžœžœ
žœ˜Jš
œ$˜$Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜—š
œ˜Jš
œ*˜*Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jšžœ
˜—Jšžœ
˜—JšœŸ
˜
—J˜š‘œžœ9˜RJšžœžœžœ˜#Jš
œO™OJšœžœ
žœ
˜šžœ3žœ
žœ˜?š
œ,˜,Jšžœžœ ˜-—Jšžœ!žœ
žœ
žœ˜6Jš
œ˜—šžœ;žœ
žœ˜Gš
œ<˜<Jšžœžœ(˜5—Jš
œ<˜<šžœ	ž˜JšžœH˜KJšžœ
žœ
žœ˜—J˜—J˜J˜—š‘œžœžœ
žœžœžœ
žœ˜Mšžœ
žœ
ž˜Jš
œ:˜:Jšžœ
žœ
˜Jš
œ˜—J˜—š‘œžœžœ˜AJšœžœ˜
šžœžœ
žœž˜*Jšžœžœžœ˜6Jšžœ
˜—Jšžœ	žœ˜Jšœ
žœ
˜Jš
œ˜J˜—š‘œžœ&žœžœ˜lJš
œ˜Jšœ
žœ
žœ
žœ
žœžœ
˜ šžœžœ
žœ˜;Jšžœžœ
žœ˜—š
žœžœ
žœ
žœ
žœ)žœž˜Pš
ž˜Jš
œ
˜
šžœžœ
ž˜šœ@˜TJšžœ)žœ
žœ
˜>šžœžœ
žœž˜*Jšžœ%žœ
žœ
˜:Jšžœ
˜—šžœ	žœ
ž˜š
œ˜šžœžœ
ž˜š
œ˜Jšžœžœ
žœ
˜3—Jšžœžœ
˜——Jšžœžœ
˜J˜—šžœžœ
žœ(˜AJ˜Jš
œ'˜'Jš
œ"˜"J˜—Jšžœ˜J˜—Jšžœžœ
˜—Jšžœ
ž˜Jš
œ˜—Jš
œ˜Jšžœ
˜—Jšœ#˜&J˜—šœžœ-žœžœ˜QJšžœ"žœ˜8JšœŸ˜—J˜š‘œžœžœžœžœžœ˜?Jšœžœ˜!Jšœ
žœ
žœžœ#˜Ošžœž˜
šžœžœ
žœž˜'Jš
œ˜Jšœ
žœ
žœžœ
žœžœ
˜@Jšžœžœ
žœ
˜Jšžœ
˜——JšœŸ˜—J˜šœžœ)žœžœ
˜EJšžœ	žœžœ˜šžœžœ
žœžœ˜.Jšœžœ˜#Jš
œ0˜0Jšžœžœžœ˜PJš
œ˜—šžœžœ
žœ
žœ˜Jšœžœ
˜(Jšœžœ
˜J˜—JšœŸ˜—J˜šœžœ)žœžœ
˜EJšžœ	žœžœ˜Jšœžœ˜#š
œ1˜1Jšžœžœžœžœ˜FJš
œ˜—šžœ
žœžœ˜Jšœžœ
˜(Jšœžœ
˜J˜—JšœŸ
˜—J˜šœ
žœ+žœžœ
˜HJšžœ	žœžœ˜Jšœžœ˜%š
œ1˜1Jšžœžœžœžœ˜FJš
œ˜—šžœ
žœžœ˜Jšœžœ
˜(Jšœžœ
˜J˜—JšœŸ˜—J˜š	œžœ
žœ/žœžœ
˜SJšžœžœ8˜Mšžœ
žœž˜Jšžœžœ
˜#Jšžœžœ
˜%Jš
œ˜—JšœŸ˜—J˜šœžœ$˜?Jšžœžœ
žœžœ˜Gšžœ˜Jš
œžœ
žœ$žœ
žœžœ
žœ
˜tJš
œžœžœžœ
žœžœ
žœ
˜NJš
œ(˜(Jšœ!žœžœ˜MJš
œ˜—JšœŸ˜J˜—šœžœ ˜6šžœ2žœžœ
ž˜CJšœžœ˜#Jš
œ+˜+Jšœžœ˜6Jš	œžœžœ
žœ	žœ˜CJšžœ
˜—JšœŸ˜—J˜šœžœ
žœ˜)Jš
œ&˜&šžœ.žœžœ
ž˜?Jšœžœ˜Jš
œ˜šžœ2žœžœ
ž˜GJšœ&žœ˜,Jšžœžœ˜9Jšžœ˜ Jšžœžœ
žœ˜9Jšžœ
˜—Jš
œ˜Jšžœ
˜—JšœŸ˜—J˜š	œžœ$žœ
žœžœ˜^šžœžœ˜Jš
œ˜šžœžœžœ
ž˜+JšžœFžœ
žœ
˜RJšžœ
˜—šžœžœ
žœ˜Jš
œ
˜
Jšžœžœ
˜+Jšžœžœ˜Jš
œ˜Jš
œ
˜
—šžœ˜šžœžœžœ
ž˜0JšžœFžœ
žœ
˜RJšžœ
˜—š
žœžœ
žœ
žœ%žœžœ
ž˜DJšžœHžœ
žœ
˜TJšžœ
˜—Jš
œ
˜
Jš
œ˜—Jš
œ
˜
—Jšžœžœ˜JšœŸ	˜—J˜šœžœ
žœžœ˜RJš
œ-˜-Jšœ˜—J˜šœžœ˜*šžœ6žœžœ
ž˜Kšžœ6žœžœ
ž˜KJšœžœžœžœ˜RJšžœ
˜—Jšžœ
˜—JšœŸ˜—J˜šœžœ
žœ˜$Jšœžœ˜CJšœžœ˜,Jš
œ!˜!Jš
œ#˜#Jš
œ;˜;Jš
œ.˜.Jš
œ#˜#Jš
œ(˜(Jš
œ˜J˜š
œ˜Jš
œD˜DJšžœ˜Jšžœ˜Jšžœ˜Jšžœ˜!—J˜šžœžœ
žœ˜'Jš
œ)˜)Jš
œ2˜2J˜—JšœŸ˜
—J˜Jšžœ˜šžœ
žœ
˜Jšœž˜ Jšœž˜Jšœžœ#˜CJšœžœ˜.Jšœ$žœ
˜(Jšœžœ˜0J˜——…—Nbp&