IO USING [PutF, rope],

Rope USING [Cat, Concat, Equal, Fetch, Length, ROPE],

spGlobals USING[Aborted, argNames, attPtr, Canned, conLinkPtr, error2, ErrorSignal, ErrorStrings, eval, expressionPtr, Handle, namePtr, RealNode, RealParm, realThingPtr, realThing, realThings, RefBranchRec, RefCircuitRec, RefCktInstRec, RefFunctionRec, RefNodeRec, RefParmRec, RefRealNode, RefRealParm, RefUnReal, refUnReal, ValueSeq],

ThymeParser;

IMPORTS IO, Rope, spGlobals

EXPORTS spGlobals=

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.

The reason behind pushCopies and popCopies is that a particular circuit may be instantiated recursively. The "real copy" of each element refers to the instances that are being used at the current level. The real copy is actually a stack of copies, so that when we're finsihed expanding this instance of the circuit we can pop the stack to make the previous "real copy" current again. This pushing and popping only needs to be done for things like nodes and branches and parameters that may be different in different instances.

FOR nl: namePtr← nameList, nl.srchLink UNTIL nl = NIL DO

}; -- pushCopies

FOR nl: namePtr← nameList, nl.srchLink UNTIL nl = NIL DO

}; -- advanceLevel

Back off the latest version of "realCopies" for the elements of the given list. This restores the previous "realCopy" (if any) that was defined in the parent cell.

FOR nl: namePtr← nameList, nl.srchLink UNTIL nl = NIL DO

}; -- popCopies

ENABLE ErrorSignal => ErrorSignal[331, s];

getRealThing[handle, nPtr];

IF handle.vars.n # NIL THEN RETURN[LOOPHOLE[handle.vars.n]] ELSE

RETURN[handle.vars.p]; -- *

}; -- getParmValue

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.

rCopy: realThingPtr;

handle.vars.n← 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

ELSE

}; -- getRealThing

Depending on the type of t, initialize nPtr.realCopy.thing to point to (the content of) n, b, p, or m.

rCopy: realThingPtr← nPtr.realCopy;

IF rCopy # NIL THEN

}; -- putRealThing

handle.vars.p← val;

putRealThing[handle, nPtr, realParm];

}; -- putParmValue

This procedure is called to bind formal parameters to actual parameters. The formal parameters for a circuit are stored in its fakeNodes list, whereas the actual parameters are contained in the connections list.

UNTIL fakes=NIL DO

}; -- makeConnections

FOR ex: expressionPtr ← apList, ex.next UNTIL ex=NIL DO

}; -- apply

inst: RefCktInstRec← NARROW[instNamePtr.details];

ckt: namePtr← NARROW[inst.of];

cktDetails: RefCircuitRec← NARROW[ckt.details];

oldPath: Rope.ROPE;

type: ThymeParser.TypeList;

In order to use this code for Crystal, keep around a path name of cell instances traversed. This procedure updates the path name for use in exploding this instance, then restores the old value when it's done.

oldPath ← handle.vars.pathName;

handle.vars.pathName ← Rope.Cat[oldPath, instNamePtr.name, "/"];

pushCopies[cktDetails.names];

makeConnections[handle, inst.connections, cktDetails.fakeNodes];

apply[handle, inst.actualParms];

advanceLevel[cktDetails.names];

FOR exp: expressionPtr ← cktDetails.assertions, exp.next UNTIL exp=NIL DO

Before exploding the circuit, see if it's a transistor. If it is, then don't bother to explode it in the normal way. Process transistors specially.

FOR type ← handle.vars.fetTable, type.next UNTIL type = NIL DO

IF type = NIL THEN explode[handle, ckt];

popCopies[handle, cktDetails.names];

handle.vars.pathName ← oldPath;

}; -- explodeInstance

pNode, nNode: Rope.ROPE;

value: REAL;

brDetails: RefBranchRec← NARROW[branchNamePtr.details];

getRealThing[handle, brDetails.posNode];

pNode← handle.vars.n;

getRealThing[handle, brDetails.negNode];

nNode← handle.vars.n;

value ← eval[handle, brDetails.valExpr];

IF brDetails.controller # NIL THEN {

SELECT brDetails.branchType FROM

}; -- explodeBranch

RETURNS [namePtr] = {

RETURNS [REAL] = {

This procedure is used to look up the value of the parameter named "name" in circuit "ckt". It's used to find things like transistor lengths. 0.0 is returned if the name didn't match anything.

WHILE list # NIL DO

RETURN [0.0];

}; -- findParm

This procedure examines a transistor that corresponds to a transistor, reads out the terminals and parameters from the circuit structure, and generates a Crystal transistor for it.

source, drain, gate: Rope.ROPE;

l, w, x, y: REAL;

fetHandle: REF ANY ← NIL;

l ← findParm[handle, ckt.parms, "l"];

w ← findParm[handle, ckt.parms, "w"];

x ← findParm[handle, ckt.parms, "x"];

y ← findParm[handle, ckt.parms, "y"];

getRealThing[handle, findName[ckt.fakeNodes, "source"]];

source ← handle.vars.n;

getRealThing[handle, findName[ckt.fakeNodes, "drain"]];

drain ← handle.vars.n;

getRealThing[handle, findName[ckt.fakeNodes, "gate"]];

gate ← handle.vars.n;

IF handle.vars.fetProc # NIL THEN

handle.vars.fetCount ← handle.vars.fetCount + 1;

IF handle.vars.attProc # NIL THEN {

RETURN;

curName: namePtr;

cktDetails: RefCircuitRec← NARROW[ckt.details];

prevCkt: namePtr ← handle.vars.curCkt;

IF Canned[handle] THEN SIGNAL Aborted;

Read through the circuit and build up node data structures.

handle.vars.curCkt ← ckt;

FOR curName← cktDetails.names, curName.srchLink UNTIL curName=NIL DO

FOR curName← cktDetails.names, curName.srchLink UNTIL curName=NIL DO

handle.vars.curCkt ← prevCkt;

}; -- explode

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

}; -- AlphaNumeric

This is the top-level procedure for expanding a hierarchical description into a flattened version.

cktRootDetails: RefCircuitRec← NARROW[handle.vars.cktRoot.details];

pushCopies[cktRootDetails.names];

advanceLevel[cktRootDetails.names];

explode[handle, handle.vars.cktRoot];

popCopies[handle, cktRootDetails.names];

}; -- bomb