DIRECTORY
Core,
CoreClasses,
CoreFlat,
CoreOps,
CoreProperties,
ElectricalCoreClasses,
HashTable,
IO,
Mint,
PWCore,
Rope,
Schedule,
WriteCapa;

MintInputImpl: CEDAR PROGRAM
IMPORTS
CoreClasses,
CoreFlat,
CoreOps,
CoreProperties,
ElectricalCoreClasses,
HashTable,
IO,
Mint,
PWCore,
Schedule,
WriteCapa

EXPORTS
Mint
~ BEGIN OPEN Mint;

FlatCellProc: TYPE = PROC [cell: Core.CellType, target: CoreFlat.FlatCellTypeRec _ CoreFlat.allFlatCells, flatCell: CoreFlat.FlatCellTypeRec _ [], instance: CoreClasses.CellInstance _ NIL, parent: Core.CellType _ NIL, flatParent: CoreFlat.FlatCellTypeRec _ [], circuit: Circuit, wireName: HashTable.Table, ignoreFlag, capaEvalFlag: BOOLEAN];

defaultIndex: NAT _ LAST[NAT];
kilo: REAL = 1000.0;
TypeTable: PUBLIC ARRAY CoreClasses.TransistorType OF TType _
[NEW[TTypeRec _ ["nETran", 0.0012, 0.00025, 20000.0]],
 NEW[TTypeRec _ ["pETran", 0.0012, 0.00025, 50000.0]],
 NEW[TTypeRec _ ["nDTran", 0.0012, 0.00025, 20000.0]]];
debug: BOOL _ FALSE;
verbose: BOOL _ FALSE;
debugCellType: Core.CellType _ NIL;
debugCircuit: Circuit _ NIL;
debugNode: Node _ NIL;
debugNodeList: NodeList _ NIL;
ignoreMe: PUBLIC ATOM _ CoreProperties.RegisterProperty[
prop: $MintIgnoreMe,
properties: CoreProperties.Props[[CoreProperties.propPrint, CoreProperties.PropDontPrint]]
];

CreateCircuit: PUBLIC PROC [rootCell: Core.CellType] RETURNS [circuit: Circuit] ~ {
WireToNode: PROC[wire: Core.Wire] = {
flatWire: CoreFlat.FlatWire _ NEW[CoreFlat.FlatWireRec _ [
flatCell: CoreFlat.rootCellType,
wireRoot: public,
wire: wire
]];
node: Node _ BuildNode[flatWire, circuit];
};	-- GuessInput 

circuit _ NEW[CircuitRec];
circuit.rootCell _ rootCell;
circuit.info _ NEW[InfoRec];
circuit.nodeTable _ HashTable.Create[equal: CoreFlat.FlatWireEqual, hash: CoreFlat.FlatWireHash];
CreatePrivate[circuit];
CoreOps.VisitRootAtomics[root: rootCell.public, eachWire: WireToNode];
};

BuildNode: PUBLIC PROC[flatWire: CoreFlat.FlatWire, circuit: Circuit] RETURNS [Node] = {
new: Node;
val: HashTable.Value;
found: BOOLEAN;
[found: found, value: val] _ HashTable.Fetch[circuit.nodeTable, flatWire];
IF found THEN RETURN[NARROW[val]];
new _ NEW[NodeRec];
new.flatWire _ flatWire;
IF debug THEN new.watched _ TRUE; -- keeps everything for ever if you debug the cell ... or the program.
[] _ HashTable.Store[table: circuit.nodeTable, key: flatWire, value: new];
circuit.info.totalNodes _ circuit.info.totalNodes + 1;
new.cap _ WriteCapa.GetRootCap[flatWire.wire];
new.ignoreMe _ CheckIgnoreProp[flatWire.wire];
new.fetSeq _ NEW[FetSeqRec[2]];
RETURN [new];
};

CheckIgnoreProp: PROC [wire: Core.Wire] RETURNS [ignored: BOOLEAN] ~ {
ignored _ NARROW[CoreProperties.GetWireProp[from: wire, prop: ignoreMe], ATOM]=$TRUE;
};

AddFetToNode: PROC [fet: Fet, node: Node, circuit: Circuit] ~ {
fetSeq: FetSeq;
nTotal: NAT _ node.fetSeq.size;
nUsed: NAT _ node.fetSeq.nUsed;
IF nUsed<nTotal THEN {
node.fetSeq.elements[nUsed] _ fet;
node.fetSeq.nUsed _ nUsed+1;
RETURN
};
fetSeq _ NEW[FetSeqRec[2*nTotal]];
FOR i: NAT IN [0..nUsed) DO
fetSeq.elements[i] _ node.fetSeq.elements[i];
ENDLOOP;
fetSeq.elements[nUsed] _ fet;
node.fetSeq _ fetSeq;
node.fetSeq.nUsed _ nUsed+1;
};

GetFetType: PROC [l, w: NAT, type: CoreClasses.TransistorType, circuit: Circuit] RETURNS [fType: FetType] ~ {
FOR fTList: LIST OF FetType _ circuit.fetTypeList, fTList.rest UNTIL fTList=NIL DO
IF fTList.first.l#l THEN LOOP;
IF fTList.first.w#w THEN LOOP;
IF fTList.first.type#type THEN LOOP;
RETURN[fTList.first];
ENDLOOP;
fType _ NEW[FetTypeRec _ [l, w, type, w/(l * TypeTable[type].rOn)]];
circuit.fetTypeList _ CONS[fType, circuit.fetTypeList];
};

BuildFet: PROC[gate, ch1, ch2: CoreFlat.FlatWire, type: CoreClasses.TransistorType, l, w: NAT, circuit: Circuit] = {
fet: Fet;
fet _ NEW[FetRec];
fet.gate _ BuildNode[gate, circuit];
fet.gate.cap _ fet.gate.cap+TypeTable[type].cPerArea*l*w;
fet.ch1 _ BuildNode[ch1, circuit];
fet.ch1.cap _ fet.ch1.cap+TypeTable[type].cPerWidth*w;
fet.ch2 _ BuildNode[ch2, circuit];
fet.ch2.cap _ fet.ch2.cap+TypeTable[type].cPerWidth*w;
fet.switch _ FALSE;
AddFetToNode[fet, fet.gate, circuit];
fet.type _ GetFetType[l, w, type, circuit];
IF ~fet.ch1.fixedV THEN
IF fet.ch1 # fet.gate THEN AddFetToNode[fet, fet.ch1, circuit];
IF ~fet.ch2.fixedV THEN
IF (fet.ch2 # fet.gate) AND (fet.ch2 # fet.ch1) THEN AddFetToNode[fet, fet.ch2, circuit];
circuit.info.totalFets[fet.type.type] _ circuit.info.totalFets[fet.type.type] + 1;
};

NextCellType: PROC [cell: Core.CellType, target: CoreFlat.FlatCellTypeRec, flatCell: CoreFlat.FlatCellTypeRec, instance: CoreClasses.CellInstance, parent: Core.CellType, flatParent: CoreFlat.FlatCellTypeRec, circuit: Circuit, wireName: HashTable.Table, ignoreFlag, capaEvalFlag: BOOLEAN, proc: FlatCellProc] = {

BindCellType: CoreFlat.UnboundFlatCellProc = {
BindPublicToActual: CoreOps.EachWirePairProc = {
IF publicWire.size=0 THEN {
flatWire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[table: wireName, key: actualWire].value];
[] _ HashTable.Store[table: wireName, key: publicWire, value: flatWire];
IF CheckIgnoreProp[publicWire] THEN {
node: Node _ NARROW[HashTable.Fetch[circuit.nodeTable, flatWire].value];
node.ignoreMe _ TRUE;
};
};
};
IF CoreOps.VisitBinding[actual: IF instance=NIL OR instance.type#cell THEN previous.public ELSE instance.actual, public: cell.public, eachWirePair: BindPublicToActual] THEN ERROR;
proc[cell, target, flatCell, instance, parent, flatParent, circuit, wireName, ignoreFlag, capaEvalFlag];
};

previous: Core.CellType _ cell;
CoreFlat.NextUnboundCellType[cell, target, flatCell, instance, defaultIndex, parent, flatParent, circuit, BindCellType];
};


Flatten: FlatCellProc = {
cellIgnoreMe: ATOM _ NARROW[CoreProperties.GetCellTypeProp[cell, ignoreMe]];
instanceIgnoreMe: ATOM _ IF instance#NIL THEN NARROW[CoreProperties.GetCellInstanceProp[instance, ignoreMe]] ELSE NIL;
layoutAtom: ATOM _ PWCore.GetLayoutAtom[cell];
IF cellIgnoreMe#NIL THEN ignoreFlag _ cellIgnoreMe=$TRUE;
IF instanceIgnoreMe#NIL THEN ignoreFlag _ instanceIgnoreMe=$TRUE;
IF layoutAtom=$Get OR layoutAtom=$GetAndFlatten THEN capaEvalFlag _ FALSE;
SELECT cell.class FROM
ElectricalCoreClasses.capacitorCellClass => {
gndNode: Node _ Mint.NodeFromRope["public.Gnd", circuit];
n0Wire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[wireName, cell.public[0]].value];
n0Node: Node _ NARROW[HashTable.Fetch[circuit.nodeTable, n0Wire].value];
n1Wire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[wireName, cell.public[1]].value];
n1Node: Node _ NARROW[HashTable.Fetch[circuit.nodeTable, n1Wire].value];
capa: ElectricalCoreClasses.Capacitor _ NARROW[cell.data];
SELECT TRUE FROM
n0Node=gndNode => n1Node.cap _ n1Node.cap+capa.value;
n1Node=gndNode => n0Node.cap _ n0Node.cap+capa.value;
ENDCASE => IO.PutF[StdOut, "Capacitor between %g and %g discarded\n", IO.rope[Mint.RopeFromNode[n0Node, circuit]], IO.rope[Mint.RopeFromNode[n0Node, circuit]]];
};
ElectricalCoreClasses.signalGeneratorCellClass => {
nWire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[wireName, cell.public[0]].value];
nNode: Node _ NARROW[HashTable.Fetch[circuit.nodeTable, nWire].value];
sig: ElectricalCoreClasses.SignalGenerator _ NARROW[cell.data];
nNode.input _ TRUE;
SELECT sig.type FROM
DC => nNode.history _ Schedule.CreateHistory[0.0, sig.onLevel*kilo];
RectWave => {
delay: ps _ sig.tDelay*kilo;
offLevel: mVolt _ sig.offLevel*kilo;
onLevel: mVolt _ sig.onLevel*kilo;
tRise: ps _ sig.tRise*kilo;
tFall: ps _ sig.tFall*kilo;
width: ps _ sig.width*kilo;
period: ps _ sig.period*kilo;
nNode.history _ Schedule.CreateHistory[0.0, offLevel];
THROUGH [0..3] DO
nNode.history _ Schedule.AddToHistory[nNode.history, delay, offLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay+tRise, onLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay+width-tFall, onLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay+width, offLevel];
delay _ delay+period;
ENDLOOP;
};
OneShot => {
delay: ps _ sig.tDelay*kilo;
offLevel: mVolt _ sig.offLevel*kilo;
onLevel: mVolt _ sig.onLevel*kilo;
tRise: ps _ sig.tRise*kilo;
tFall: ps _ sig.tFall*kilo;
width: ps _ sig.width*kilo;
nNode.history _ Schedule.CreateHistory[0.0, offLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay, offLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay+tRise, onLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay+width-tFall, onLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay+width, offLevel];
};
Step => {
delay: ps _ sig.tDelay*kilo;
offLevel: mVolt _ sig.offLevel*kilo;
onLevel: mVolt _ sig.onLevel*kilo;
tRise: ps _ sig.tRise*kilo;
nNode.history _ Schedule.CreateHistory[0.0, offLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay, offLevel];
nNode.history _ Schedule.AddToHistory[nNode.history, delay+tRise, onLevel];
};
ENDCASE => ERROR;
};
ElectricalCoreClasses.probeCellClass => {
IF NARROW[cell.data, ElectricalCoreClasses.Probe].type=Voltage THEN {
nWire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[wireName, cell.public[0]].value];
nNode: Node _ NARROW[HashTable.Fetch[circuit.nodeTable, nWire].value];
nNode.watched _ TRUE;
}
ELSE IO.PutF[StdOut, "No current probes allowed\n"];
};
ElectricalCoreClasses.panelCellClass => {
panel: ElectricalCoreClasses.Panel _ NARROW[cell.data];
circuit.info.tStart _ panel.tMin;
circuit.info.tStop _ panel.tMax;
};
CoreClasses.transistorCellClass => {
gateWire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[table: wireName, key: cell.public[ORD[CoreClasses.TransistorPort.gate]]].value];
ch1Wire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[table: wireName, key: cell.public[ORD[CoreClasses.TransistorPort.ch1]]].value];
ch2Wire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[table: wireName, key: cell.public[ORD[CoreClasses.TransistorPort.ch2]]].value];
tran: CoreClasses.Transistor _ NARROW[cell.data];
BuildFet[gateWire, ch1Wire, ch2Wire, tran.type, tran.length, tran.width, circuit];
};
CoreClasses.recordCellClass =>  {
rct: CoreClasses.RecordCellType _ NARROW[cell.data];
InsertNonPublicWires[cell.public, rct.internal, flatCell, circuit, wireName, ignoreFlag, capaEvalFlag];
NextCellType[cell, target, flatCell, instance, parent, flatParent, circuit, wireName, ignoreFlag, capaEvalFlag, Flatten]
};
ENDCASE => {
IF cell.class.recast=NIL THEN IO.PutF[StdOut, "What is a %g ?\n", IO.rope[cell.class.name]]
ELSE NextCellType[cell, target, flatCell, instance, parent, flatParent, circuit, wireName, ignoreFlag, capaEvalFlag, Flatten]
};
};

InsertNonPublicWires: PROC [public, internal: Core.Wire, flatCell: CoreFlat.FlatCellTypeRec, circuit: Circuit, wireName: HashTable.Table, ignoreFlag, capaEvalFlag: BOOLEAN] ~ {

MarkAtomicPublic: PROC[wire: Core.Wire] = {
[] _ HashTable.Store[table: publicsTable, key: wire, value: $Public];
};

InsertInternal: PROC[wire: Core.Wire] = {
IF NOT HashTable.Fetch[table: publicsTable, key: wire].found THEN {
node: Node _ InsertWire[wire, flatCell, circuit, wireName];
node.ignoreMe _ ignoreFlag;
IF capaEvalFlag THEN node.cap _ node.cap+circuit.info.eachWireCapa;
};
};

publicsTable: HashTable.Table _ HashTable.Create[public.size+1];
CoreOps.VisitRootAtomics[root: public, eachWire: MarkAtomicPublic];
CoreOps.VisitRootAtomics[root: internal, eachWire: InsertInternal];
};

InsertWire: PROC [wire: Core.Wire, flatCell: CoreFlat.FlatCellTypeRec, circuit: Circuit, wireName: HashTable.Table, wireRoot: CoreFlat.WireRoot _ internal] RETURNS[node: Node]= {
flatWire: CoreFlat.FlatWire _ NEW[CoreFlat.FlatWireRec];
flatWire.flatCell _ flatCell;
flatWire.wireRoot _ wireRoot;
flatWire.wire _ wire;
node _ BuildNode[flatWire, circuit];
[] _ HashTable.Store[table: wireName, key: wire, value: flatWire];
};

NetFromCore: PUBLIC PROC[circuit: Circuit, layout: BOOLEAN _ TRUE] = {

InsertPublic: PROC[wire: Core.Wire] = {
[] _ InsertWire[wire, CoreFlat.rootCellType, circuit, wireName, public];
};

wireName: HashTable.Table _ HashTable.Create[];
IO.PutF[Mint.StdOut, "\nConverting cell %g . . .", IO.rope[CoreOps.GetCellTypeName[circuit.rootCell]]];
CoreOps.VisitRootAtomics[root: circuit.rootCell.public, eachWire: InsertPublic];
Flatten[cell: circuit.rootCell, circuit: circuit, wireName: wireName, ignoreFlag: FALSE, capaEvalFlag: ~layout];
IO.PutRope[Mint.StdOut, "Finished\n"];
};

Stats: PUBLIC PROC[circuit: Circuit] = {
total: INT _ 0;
IO.PutF[Mint.StdOut, "Total number of nodes: %d.\n", IO.int[circuit.info.totalNodes]];
FOR i: CoreClasses.TransistorType IN CoreClasses.TransistorType DO
IF circuit.info.totalFets[i] = 0 THEN LOOP;
IO.PutF[Mint.StdOut, "Number of %s transistors: %d.\n", IO.rope[TypeTable[i].name], IO.int[circuit.info.totalFets[i]]];
total _ total + circuit.info.totalFets[i];
ENDLOOP;
IO.PutF[Mint.StdOut, "Total number of transistors: %d.\n", IO.int[total]];
};

InputData: PUBLIC PROC [circuit: Circuit, fixedVList: NodeList, layout: BOOLEAN _ TRUE, eachWireCapa: pF _0.0] ~ {
GuessInput: PROC[wire: Core.Wire] = {
flatWire: CoreFlat.FlatWire _ NEW[CoreFlat.FlatWireRec _ [
flatCell: CoreFlat.rootCellType,
wireRoot: public,
wire: wire
]];
node: Node _ NARROW[HashTable.Fetch[circuit.nodeTable, flatWire].value];
IF ~node.fixedV THEN {
node.input _ TRUE;
FOR i: NAT IN [0..node.fetSeq.nUsed) DO
fet: Fet _ node.fetSeq[i];
IF fet.ch1=node OR fet.ch2=node THEN {
node.input _ FALSE;
EXIT;
};
ENDLOOP;
};
node.watched _ TRUE;
};	-- GuessInput 

circuit.info.eachWireCapa _ eachWireCapa;
FOR iNodeList: NodeList _ fixedVList, iNodeList.rest UNTIL iNodeList = NIL DO
iNodeList.first.fixedV _ TRUE;
ENDLOOP;
NetFromCore[circuit, layout];
CoreOps.VisitRootAtomics[root: circuit.rootCell.public, eachWire: GuessInput];
Stats[circuit];
PrepareSets[circuit, fixedVList];
};

NextNodeList: PROC [set: Set, fetList: FetList] RETURNS [nodeList: NodeList _ NIL] ~ {
FOR iFetList: FetList _ fetList, iFetList.rest UNTIL iFetList = NIL DO
IF NOT iFetList.first.ch1.done THEN {
nodeList _ CONS[iFetList.first.ch1, nodeList];
iFetList.first.ch1.done _ TRUE;
AddNodeToSet[set, iFetList.first.ch1];
};
IF NOT iFetList.first.ch2.done THEN {
nodeList _ CONS[iFetList.first.ch2, nodeList];
iFetList.first.ch2.done _ TRUE;
AddNodeToSet[set, iFetList.first.ch2];
};
ENDLOOP;
};	--NextNodeList

NextFetList: PROC [set: Set, nodeList: NodeList] RETURNS [fetList: FetList _ NIL] ~ {
FOR iNodeList: NodeList _ nodeList, iNodeList.rest UNTIL iNodeList = NIL DO
FOR i: NAT IN [0..iNodeList.first.fetSeq.nUsed) DO
fet: Fet = iNodeList.first.fetSeq[i];
IF NOT fet.done THEN 
IF fet.gate # iNodeList.first THEN {
fetList _ CONS[fet, fetList];
fet.done _ TRUE;
AddFetToSet[set, fet];
};
ENDLOOP;
ENDLOOP;
};	--NextFetList

AddNodeToSet: PROC [set: Set, node: Node] ~ {
set.lNodes _ CONS[node, set.lNodes];
set.type.nNodes _ set.type.nNodes+1;
node.done _ TRUE;
};

AddFetToSet: PROC [set: Set, fet: Fet] ~ {
set.lFets _ CONS[fet, set.lFets];
fet.done _ TRUE;
set.type.nFets[fet.type.type] _ set.type.nFets[fet.type.type]+1;
};


PrepareSets: PUBLIC PROC [circuit: Circuit, fixedVList: NodeList] ~ {

FindOneSet: HashTable.EachPairAction ~ {
nodeList: NodeList;
fetList: FetList;
set: Set;
node: Node _ NARROW[value];
IF node.done THEN RETURN;
set _ NEW[SetRec];
set.type _ NEW[SetTypeRec];
nodeList _ LIST[node];
AddNodeToSet[set, node];
UNTIL nodeList = NIL DO
fetList _ NextFetList[set, nodeList];
nodeList _ NextNodeList[set, fetList];
ENDLOOP;
FindInputs[set];
FindFixedV[set, fixedVList, GndNode, VddNode];
FOR il: Library _ circuit.library, il.rest UNTIL il=NIL DO
IF TypeEqual[set.type, il.first.type] THEN {
il.first.nElem _ il.first.nElem+1;
il.first.setList _ CONS[set, il.first.setList];
set.type _ il.first.type;
RETURN;
};
ENDLOOP;
circuit.library _ CONS[NEW[LibraryElemRec _ [set.type, 1, LIST[set]]], circuit.library];
};

GndNode: Node _ Mint.NodeFromRope["public.Gnd", circuit];
VddNode: Node _ Mint.NodeFromRope["public.Vdd", circuit];
FOR inode: NodeList _ fixedVList, inode.rest UNTIL inode=NIL DO
inode.first.done _ TRUE;
inode.first.input _ TRUE;
ENDLOOP;
[] _ HashTable.Pairs[circuit.nodeTable, FindOneSet]
};	-- PrepareSets

FindInputs: PROC [set: Set] ~ {
found: BOOLEAN;
FOR ifet: FetList _ set.lFets, ifet.rest UNTIL ifet=NIL DO
found _ FALSE;
FOR inode: NodeList _ set.lNodes, inode.rest UNTIL inode=NIL DO
IF inode.first=ifet.first.gate THEN {
found _ TRUE;
EXIT;
};
ENDLOOP;
IF ~found THEN {
found _ FALSE;
FOR inode: NodeList _ set.inList, inode.rest UNTIL inode=NIL DO
IF inode.first=ifet.first.gate THEN {
found _ TRUE;
EXIT;
};
ENDLOOP;
IF ~found THEN {
set.type.nInput _ set.type.nInput+1;
set.inList _ CONS[ifet.first.gate, set.inList];
ifet.first.gate.setList _ CONS[set, ifet.first.gate.setList]
};
};
ENDLOOP;
};

FindFixedV: PROC [set: Set, fixedVList: NodeList, GndNode, VddNode: Node] ~ {
found: BOOLEAN;
FOR ifet: FetList _ set.lFets, ifet.rest UNTIL ifet=NIL DO
FOR fix: NodeList _ fixedVList, fix.rest UNTIL fix=NIL DO
IF ifet.first.ch1=fix.first OR ifet.first.ch2=fix.first THEN {
IF fix.first=VddNode THEN set.type.nVddTran _ set.type.nVddTran+1;
IF fix.first=GndNode THEN set.type.nGndTran _ set.type.nGndTran+1;
found _ FALSE;
FOR inode: NodeList _ set.fixedV, inode.rest UNTIL inode=NIL DO
IF inode.first=fix.first THEN {
found _ TRUE;
EXIT;
};
ENDLOOP;
IF ~found THEN set.fixedV _ CONS[fix.first, set.fixedV];
};
ENDLOOP;
ENDLOOP;
};

TypeEqual: PROC [s1, s2: SetType] RETURNS [ok: BOOLEAN _ FALSE] ~ {
FOR tt: CoreClasses.TransistorType IN CoreClasses.TransistorType DO
IF s1.nFets[tt]#s2.nFets[tt] THEN RETURN;
ENDLOOP;
IF s1.nVddTran#s2.nVddTran THEN RETURN;
IF s1.nGndTran#s2.nGndTran THEN RETURN;
IF s1.nNodes#s2.nNodes THEN RETURN;
IF s1.nInput#s2.nInput THEN RETURN;
ok _ TRUE;
};

PrintSetType: PROC [out: IO.STREAM, setType: SetType]  ~ {
IO.PutF[out, " %4d, %4d,", IO.int[setType.nFets[nE]], IO.int[setType.nFets[pE]]];
IO.PutF[out, " %4d, %4d, %4d, %4d", IO.int[setType.nVddTran], IO.int[setType.nGndTran], IO.int[setType.nNodes], IO.int[setType.nInput]];
};

SolveInverter: PROC [set: Set, t: ps] RETURNS [tlast: ps] ~ {
out: Node ~ set.lNodes.first;
in: Node ~ set.inList.first;
};

ErrMsg: PROC [nodeList: NodeList, msg: Rope.ROPE, circuit: Circuit] ~ {
IO.PutF[Mint.StdOut, "\n%g:", IO.rope[msg]];
FOR iNodeList: NodeList _ nodeList, iNodeList.rest UNTIL iNodeList=NIL DO
IO.PutF[Mint.StdOut, "\n%g", IO.rope[Mint.RopeFromNode[iNodeList.first, circuit]]];
ENDLOOP;
IO.PutF[Mint.StdOut, "\n" ];
};

CheckLibrary: PUBLIC PROC [circuit: Circuit] ~ {
n: NAT _ 0;
FOR il: Library _ circuit.library, il.rest UNTIL il=NIL DO
SELECT TRUE FROM
il.first.type.nFets[nE]+il.first.type.nFets[pE]=0 => FOR iSetList: SetList _ il.first.setList, iSetList.rest UNTIL iSetList=NIL DO
IF iSetList.first.lNodes.first.flatWire.wireRoot#public THEN {
IF iSetList.first.lNodes.first.setList=NIL THEN ErrMsg[iSetList.first.lNodes, "This Node is isolated", circuit] ELSE ErrMsg[iSetList.first.lNodes, "This Node is not loaded by any fet", circuit]};
ENDLOOP;
il.first.type.nVddTran=0 => FOR iSetList: SetList _ il.first.setList, iSetList.rest UNTIL iSetList=NIL DO
ErrMsg[iSetList.first.lNodes, "These Nodes have no path to Vdd", circuit];
ENDLOOP;
il.first.type.nGndTran=0 => FOR iSetList: SetList _ il.first.setList, iSetList.rest UNTIL iSetList=NIL DO
ErrMsg[iSetList.first.lNodes, "These Nodes have no path to Gnd", circuit];
ENDLOOP;
ENDCASE;
ENDLOOP;
};

OutputResults: PUBLIC PROC [circuit: Circuit] ~ {
n: NAT _ 0;
IO.PutF[Mint.StdOut, "                              nE  pE ^Vdd ^Gnd nodes inputs\n"];
FOR il: Library _ circuit.library, il.rest UNTIL il=NIL DO
IO.PutF[Mint.StdOut, "%5d el: %5d    Type: ", IO.int[n], IO.int[il.first.nElem]];
PrintSetType[Mint.StdOut, il.first.type];
IO.PutF[Mint.StdOut, "\n" ];
n _ n+1;
ENDLOOP;
};

END.
”MintInputImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Christian LeCocq April 18, 1987 10:25:17 am PDT
Bertrand Serlet October 18, 1986 8:12:25 pm PDT


some usefull definitions
Basic data stuctures builders
This procedure sees if a given node exists, and makes a new one if necessary.  A pointer is returned to the new or existing node.
ooops! sounds like we've exceded our available space...
IF nFets>127 THEN fetSeq _ NEW[FetSeqRec[nFets+1]]
ELSE {
poolIndex: NAT _ 
IF circuit.private.fetSeqPool[nFets+1]=NIL THEN fetSeq _ NEW[FetSeqRec[nFets+1]]
ELSE {
fetSeq _ circuit.private.fetSeqPool[nFets+1].first;
circuit.private.fetSeqPool[nFets+1] _ circuit.private.fetSeqPool[nFets+1].rest;
};
IF nFets>0 THEN circuit.private.fetSeqPool[nFets] _ CONS[node.fetSeq, circuit.private.fetSeqPool[nFets]];
};
IF fetSeq.size#nFets+1 THEN ERROR; --temporary while debug (hopefully..)
This procedure builds a transistor data structure and links it into the network under construction.
cap: REAL;
Input From Core
PROC [actualWire, publicWire: Wire]
Circuit Preparation
PROC [key: Key, value: Value] RETURNS [quit: BOOLEAN _ FALSE];
... to be finished.
Κ/˜š
œ™Icodešœ
Οm
œ1™<K™/K™/J™J™—š
Οk	˜	Kš
œ˜Kš
œ˜K˜	Kš
œ˜Kš
œ˜Kš
œ˜Kšœ	ž
˜
Kšžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜K˜	Kš
œ
˜
K˜—šΟb
œžœ
ž˜š
ž˜Kš
œ˜K˜	Kš
œ˜Kš
œ˜Kš
œ˜Kšœ	ž
˜
Kšžœ
˜Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ	˜	K˜—š
ž˜Kš
œ˜—šž
œ˜K˜KšœžœžœŸ
žœžœtžœ˜ΥK˜K™Kšœžœžœ
žœ˜Kšœžœ
˜šœžœ
žœžœ˜=Kš
œ6˜6Kš
œ6˜6Kš
œ7˜7—Kšœžœžœ
˜Kšœ	žœžœ
˜Kšœžœ
˜#Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜šœ
žœ
žœ#˜8Kš
œ˜Kš
œZ˜ZKš
œ˜—K˜——
head™šΟn
œžœ
žœžœ˜Sš 
œžœ˜%šœžœ˜:Kš
œ ˜ Kš
œ˜Kš
œ
˜
Kš
œ˜—Kš
œ*˜*KšœΟc˜K˜—Kšœ
žœ
˜Kš
œ˜Kšœžœ
˜Kš
œa˜aKš
œ˜Kš
œF˜FK˜K˜—š 	œžœ
žœ0žœ˜XKš
œ
™
K˜
K˜Kšœžœ
˜Kš
œJ˜JKšžœžœ
žœ
žœ˜"Kšœžœ
˜Kš
œ˜Kšžœžœžœ‘F˜hKš
œJ˜JKš
œ6˜6Kš
œ.˜.K•StartOfExpansion![from: 
Core.Wire, prop: 
ATOM]š
œ.˜.Kšœ
žœ˜Kšžœ˜
K˜K˜—š œžœžœžœ˜FKšœ
žœ9žœ˜UK˜K˜—š œžœ-˜?Kš
œ˜Kšœžœ˜Kšœžœ˜šžœžœ˜Kš
œ"˜"Kš
œ˜Kš
ž˜Kš
œ˜—K™7Kšžœ
žœ
žœ™2šžœ™K™Kšžœ%žœ
žœ
žœ™Pšžœ™Kš
œ3™3Kš
œO™OK™—Kšžœ	žœ%žœ1™iK™—Kšžœžœ
žœ‘%™HKšœ	žœ˜"šžœžœ
žœž˜Kš
œ-˜-Kšžœ
˜—Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜—š 
œžœžœ6žœ˜mšžœ	žœ
žœ,žœžœ
ž˜RKšžœžœ
ž˜Kšžœžœ
ž˜Kšžœžœ
ž˜$Kšžœ˜Kšžœ
˜—Kšœžœ9˜DKšœžœ˜7K˜K˜—šΠbnœžœLžœ˜tK™cKšœžœ
™
K˜	Kšœžœ	˜Kš
œ$˜$Kš
œ9˜9Kš
œ"˜"Kš
œ6˜6Kš
œ"˜"Kš
œ6˜6Kšœ
žœ
˜Kš
œ%˜%Kš
œ+˜+šžœž˜Kšžœžœ%˜?—šžœž˜Kšžœžœžœ%˜Y—Kš
œR˜RK˜K˜——™š œžœ…žœ˜·K˜š œ"˜.š œ˜0Kšžœ™#šžœžœ˜Kšœžœ:˜^Kš
œH˜Hšžœžœ˜%Kšœ
žœ5˜HKšœžœ
˜K˜—K˜—Kš
œ˜—Kšžœžœ
žœ
žœžœžœIžœ
žœ
˜³
Kš
œh˜hK˜K˜—K˜Kš
œx˜xKš
œ˜K˜—K˜š œ˜Kšœžœžœ1˜LKšœžœžœ
žœ
žœ
žœ9žœ
žœ
˜vKšœžœ˜.Kšžœžœ
žœ!˜9Kšžœžœ
žœ%˜AKšžœ.žœžœ
˜Jšžœ
ž˜š
œ-˜-Kš
œ9˜9Kšœžœ2˜TKšœžœ3˜HKšœžœ2˜TKšœžœ3˜HKšœ(žœ˜:šžœ
žœ
ž˜Kš
œ5˜5Kš
œ5˜5Kšžœžœ9žœ+žœ+˜ 
—K˜—š
œ3˜3Kšœžœ2˜SKšœžœ2˜FKšœ-žœ˜?Kšœžœ
˜šžœ
ž˜KšžœB˜Dš
œ
˜
Kš
œ˜Kš
œ$˜$Kš
œ"˜"Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ6˜6šžœž˜Kš
œF˜FKš
œK˜KKš
œQ˜QKš
œL˜LKš
œ˜Kšžœ
˜Kš
œ˜——š
œ˜Kš
œ˜Kš
œ$˜$Kš
œ"˜"Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ6˜6Kš
œF˜FKš
œK˜KKš
œQ˜QKš
œL˜LKš
œ˜—š
œ	˜	Kš
œ˜Kš
œ$˜$Kš
œ"˜"Kš
œ˜Kš
œ6˜6Kš
œF˜FKš
œK˜KK˜—Kšžœžœ
˜—K˜—š
œ)˜)šžœ
žœ6žœ˜EKšœžœ2˜SKšœžœ2˜FKšœžœ
˜K˜
—Kšžœ
žœ-˜4K˜—š
œ)˜)Kšœ%žœ˜7K˜!K˜ K˜—š
œ$˜$Kšœžœ3žœ+˜…
Kšœžœ3žœ*˜ƒ
Kšœžœ3žœ*˜ƒ
Kšœžœ˜1Kš
œR˜RK˜—š
œ!˜!Kšœ"žœ˜4Kš
œg˜gKš
œx˜xK˜—šžœ˜Kš
žœžœ
žœ
žœ"žœ˜[Kšžœy˜}Kš
œ˜——Kš
œ˜K˜—š œžœŠ
žœ˜°
K˜š œžœ˜+Kš
œE˜EKš
œ˜K˜—š œžœ˜)šžœ
žœ7žœ˜CKš
œ;˜;Kš
œ˜Kšžœžœ/˜CK˜—Kš
œ˜K˜—Kš
œ@˜@Kš
œC˜CKš
œC˜CK˜K˜—š 
œžœŒ
žœ˜²
Kšœžœ˜8Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ$˜$Kš
œB˜BKš
œ˜K˜—š
 œžœ
žœžœžœ˜FK˜š œžœ˜'Kš
œH˜HKš
œ˜K˜—K˜/Kšžœ1žœ2˜gKš
œP˜PKšœRžœ˜pKšžœ$˜&K˜K˜——™š œžœ
žœ˜(Kšœžœ˜Kšžœ3žœ˜Všžœžœž˜BKšžœžœ
žœ
˜+Kšžœ6žœžœ!˜wKš
œ*˜*Kšžœ
˜—Kšžœ9žœ
˜JK˜K˜—š
 	œžœ
žœ2žœžœ˜rš 
œžœ˜%šœžœ˜:Kš
œ ˜ Kš
œ˜Kš
œ
˜
Kš
œ˜—Kšœ
žœ5˜Hšžœžœ
˜Kšœ
žœ
˜šžœžœ
žœž˜'Kš
œ˜š
žœž
œžœž
œžœ
˜&Kšœ
žœ
˜Kšžœ
˜K˜—Kšžœ
˜—K˜—Kšœžœ
˜Kšœ‘˜K˜—Kš
œ)˜)šžœ2žœ
žœ
ž˜MKšœžœ
˜Kšžœ
˜—Kš
œ˜Kš
œN˜NK˜Kš
œ!˜!˜K˜——š œ
žœžœžœ˜Všžœ,žœžœ
ž˜Fšžœ
žœžœ˜%Kšœžœ˜.Kšœžœ
˜Kš
œ&˜&K˜—šžœ
žœžœ˜%Kšœžœ˜.Kšœžœ
˜Kš
œ&˜&K˜—Kšžœ
˜—Kšœ‘˜K˜—š œ
žœ žœžœ˜Ušžœ0žœ
žœ
ž˜Kšžœžœ
žœ#ž˜2Kš
œ%˜%šžœ
žœ	žœ
˜šžœžœ˜$Kšœ
žœ˜Kšœžœ
˜Kš
œ˜K˜——Kšžœ
˜—Kšžœ
˜—Kšœ‘
˜K˜—š œžœ˜-Kšœ
žœ˜$Kš
œ$˜$Kšœž˜˜K˜——š œ
žœ˜*Kšœžœ˜!Kšœž˜Kš
œ@˜@˜K˜K˜——š œžœ-˜EK˜š 
œ˜(Kšžœžœžœžœ™>Kš
œ˜Kš
œ˜K˜	Kšœ
žœ˜Kšžœ
žœ
žœ
˜Kšœžœ	˜Kšœžœ
˜Kšœžœ˜Kš
œ˜šžœžœ
ž˜Kš
œ%˜%Kš
œ&˜&Kšžœ
˜—Kš
œ˜Kš
œ.˜.šžœ(žœžœ
ž˜:šžœ#žœ˜,K˜"Kšœžœ˜/Kš
œ˜Kšžœ
˜K˜—Kšžœ
˜—Kšœžœ
žœ žœ˜XK˜K˜—Kš
œ9˜9Kš
œ9˜9šžœ*žœžœ
ž˜?Kšœžœ
˜Kšœžœ
˜Kšžœ
˜—Kš
œ3˜3Kšœ‘˜K˜—š 
œžœ˜Kšœžœ
˜šžœ&žœžœ
ž˜:Kšœžœ
˜šžœ*žœžœ
ž˜?šžœžœ˜%Kšœžœ
˜
Kšžœ
˜K˜—Kšžœ
˜—šžœžœ˜Kšœžœ
˜šžœ*žœžœ
ž˜?šžœžœ˜%Kšœžœ
˜
Kšžœ
˜K˜—Kšžœ
˜—šžœžœ˜Kš
œ$˜$Kšœ
žœ˜/Kšœžœ˜<K˜—K˜—Kšžœ
˜—K˜—K˜š 
œžœ=˜MKšœžœ
˜šžœ&žœžœ
ž˜:šžœ&žœžœ
ž˜9šžœžœžœ˜>Kšžœžœ)˜BKšžœžœ)˜BKšœžœ
˜šžœ*žœžœ
ž˜?šžœžœ˜Kšœžœ
˜
Kšžœ
˜K˜—Kšžœ
˜—Kšžœžœžœ˜8K˜—Kšžœ
˜—Kšžœ
˜—K˜K˜—š
’	œžœžœžœžœ˜Cšžœ žœž˜CKšžœžœ
žœ
˜)Kšžœ
˜—Kšžœžœ
žœ
˜'Kšžœžœ
žœ
˜'Kšžœžœ
žœ
˜#Kšžœžœ
žœ
˜#Kšœžœ
˜
K˜K˜—š œžœžœ
žœ˜:Kšžœžœžœ˜QKš
žœ"žœžœžœžœ˜ˆ
K˜K˜—š 
œžœžœ˜=K˜Kš
œ˜K™K˜K˜—š œžœ žœ˜GKšžœ*˜,šžœ0žœžœ
ž˜IKšžœžœ4˜SKšžœ
˜—Kšžœ˜K˜K˜—š œžœ˜0Kšœžœ˜šžœ(žœžœ
ž˜:šžœ
žœ
ž˜šœ5žœ5žœ
žœ
ž˜‚
šžœ6žœ˜>Kšžœ%žœ
žœAžœO˜Γ
—Kšžœ
˜—šœžœ5žœ
žœ
ž˜iKš
œJ˜JKšžœ
˜—šœžœ5žœ
žœ
ž˜iKš
œJ˜JKšžœ
˜—Kšžœ
˜—Kšžœ
˜—K˜K˜—š 
œžœ˜1Kšœžœ˜KšžœT˜Všžœ(žœžœ
ž˜:Kšžœ,žœ	žœ˜QKš
œ)˜)Kšžœ˜K˜Kšžœ
˜—K˜K˜——Jšžœ
˜—…—LΎf