DIRECTORY Basics, BitHacks, Convert, Core, CoreClasses, CoreFlat, CoreOps, HashTable, IO, Rope;

CoreFlatImpl: CEDAR PROGRAM
IMPORTS Basics, BitHacks, Convert, CoreClasses, CoreOps, HashTable, IO, Rope
EXPORTS CoreFlat
= BEGIN OPEN CoreFlat;

PathError: PUBLIC ERROR [msg: ROPE _ NIL] = CODE;
GetCellType: PUBLIC PROC [root: Core.CellType, path: PackedPath] RETURNS [cellType: Core.CellType _ NIL] = {

SetCellType: EachUnboundInstanceProc = {
innerCellType _ CoreOps.ToBasic[instance.instance.type]
};

innerCellType: Core.CellType _ root;
VisitUnboundPath[root, path, SetCellType];
cellType _ innerCellType;
};

VisitUnboundPath: PUBLIC PROC [root: Core.CellType, path: PackedPath, eachInstance: EachUnboundInstanceProc] = {
currentPath: PackedPath _ NullPath;
UNTIL currentPath.length=path.length DO
cellType: Core.CellType _ CoreOps.ToBasic[root];
rct: CoreClasses.RecordCellType _ NARROW [cellType.data];
pathBits: NAT _ BitHacks.NBits[rct.size];
instanceBits: PACKED ARRAY [0..16) OF BOOL _ ALL [FALSE];
instance: CoreClasses.CellInstance;
oldPath: PackedPath _ currentPath;
FOR bit: NAT IN [0..pathBits) DO
instanceBits[16-pathBits+bit] _ path.bits[currentPath.length+bit];
currentPath.bits[currentPath.length+bit] _ path.bits[currentPath.length+bit];
ENDLOOP;
currentPath.length _ currentPath.length+pathBits;
instance _ rct[LOOPHOLE[instanceBits]];
root _ instance.type;
eachInstance[[oldPath, instance], cellType];
ENDLOOP;
};

BoundCellType: PUBLIC PROC [root: Core.CellType, path: PackedPath] RETURNS [bindings: HashTable.Table, cellType: Core.CellType] = {

SetInnerCellType: EachBoundInstanceProc = {
innerCellType _ cellType;
};

innerCellType: Core.CellType _ root;
bindings _ VisitBoundPath[root, path, SetInnerCellType];
cellType _ innerCellType;
};

VisitBoundPath: PUBLIC PROC [root: Core.CellType, path: PackedPath, eachInstance: EachBoundInstanceProc] RETURNS [bindings: HashTable.Table] = {

BindCellTypeAndInstance: EachUnboundInstanceProc = {
BindInternal[bindings, instance.path, cellType];
[bindings, innerCellType] _ BindInstance[instance.instance, bindings];
eachInstance[bindings, instance, cellType];
};

innerCellType: Core.CellType;
[bindings, innerCellType] _ InitializeBindings[root];
VisitUnboundPath[root, path, BindCellTypeAndInstance];
BindInternal[bindings, path, innerCellType];
};

EnumerateLeaves: PUBLIC PROC [root: Core.CellType, eachInstance: EachInstanceProc, rootCellType, beforeInstances, afterInstances: EachCellTypeProc _ NIL] = {

VisitCellType: PROC [bindings: HashTable.Table, path: PackedPath, parent: Core.CellType] = {
parentRCT: CoreClasses.RecordCellType _ NARROW[parent.data];
pathBits: NAT _ BitHacks.NBits[parentRCT.size];
BindInternal[bindings, path, parent];
IF beforeInstances#NIL THEN beforeInstances[bindings, path, parent];
FOR in: NAT IN [0..parentRCT.size) DO
instance: CoreClasses.CellInstance _ parentRCT[in];
IF eachInstance[bindings, path, instance] THEN {
newBindings: HashTable.Table;
child: Core.CellType;
[newBindings, child] _ BindInstance[instance, bindings];
VisitCellType[newBindings, ExtendPath[path, in, pathBits], child];
};
ENDLOOP;
IF afterInstances#NIL THEN afterInstances[bindings, path, parent];
};

bindings: HashTable.Table;
path: PackedPath _ NullPath;
rootRCT: Core.CellType;
[bindings, rootRCT] _ InitializeBindings[root];
IF rootCellType#NIL THEN rootCellType[bindings, path, rootRCT];
VisitCellType[bindings, path, rootRCT];
};
EnumerateAtomicWireLeaves: PUBLIC PROC [root: Core.CellType, rootWire: Core.Wire, eachInternalWire: EachInternalWireProc _ NIL, eachWireInstance: EachWireInstanceProc _ NIL] = {

FilterWire: EachCellTypeProc = {

FindWire: CoreOps.EachWireProc = {
bind: WireBind;
IF wire.size#0 THEN RETURN;
bind _ NARROW [HashTable.Fetch[table: bindings, key: wire].value];
IF (quit _ bind.wire=rootWire) THEN thisWire _ wire;
};

IF NOT CoreOps.VisitWire[NARROW [cellType.data, CoreClasses.RecordCellType].internal, FindWire] THEN ERROR;
IF eachInternalWire#NIL THEN eachInternalWire[bindings: bindings, path: path, cellType: cellType, wire: thisWire]
};

FilterInstance: EachInstanceProc = {
bound: BOOL _ CoreOps.RecursiveMember[wire: instance.actual, candidate: thisWire];
IF eachWireInstance#NIL AND bound THEN flatten _ eachWireInstance[bindings: bindings, path: path, instance: instance, wire: thisWire] ELSE {
IF bound THEN {
cellType: Core.CellType _ CoreOps.ToBasic[instance.type];
flatten _ cellType.class#CoreClasses.transistorCellClass AND cellType.class#CoreClasses.unspecifiedCellClass;
}
ELSE flatten _ FALSE;
};
};

thisWire: Core.Wire;
IF rootWire.size#0 THEN ERROR;
EnumerateLeaves[root: root, beforeInstances: FilterWire, eachInstance: FilterInstance];
};

InitializeBindings: PROC [root: Core.CellType] RETURNS [bindings: HashTable.Table, rootRCT: Core.CellType] = {

InsertBindings: CoreOps.EachWireProc = {
[] _ HashTable.Store[
table: bindings, key: wire, 
value: NEW [WireBindRec _ [path: NullPath, wire: wire]]
];
};

rootRCT _ CoreOps.ToBasic[root];
bindings _ HashTable.Create[rootRCT.public.size+1];
FOR i: NAT IN [0..rootRCT.public.size) DO
IF CoreOps.VisitWire[wire: rootRCT.public[i], eachWire: InsertBindings] THEN ERROR;
ENDLOOP;
};
BindInternal: PROC [bindings: HashTable.Table, path: PackedPath, cellType: Core.CellType] = {

InsertBindings: CoreOps.EachWireProc = {
wireBind: WireBind _ NARROW [HashTable.Fetch[table: bindings, key: wire].value];
IF wireBind=NIL THEN [] _ HashTable.Store[
table: bindings, key: wire, 
value: NEW [WireBindRec _ [path: path, wire: wire]]
];
};

internal: Core.Wire _ NARROW [cellType.data, CoreClasses.RecordCellType].internal;
FOR i: NAT IN [0..internal.size) DO
IF CoreOps.VisitWire[wire: internal[i], eachWire: InsertBindings] THEN ERROR;
ENDLOOP;
};

BindInstance: PROC [instance: CoreClasses.CellInstance, bindings: HashTable.Table] RETURNS [newBindings: HashTable.Table, child: Core.CellType] = {

BindPublicToActual: CoreOps.EachWirePairProc = {
bind: WireBind _ NARROW [HashTable.Fetch[table: bindings, key: actualWire].value];
IF bind=NIL THEN ERROR;
[] _ HashTable.Store[table: newBindings, key: publicWire, value: bind];
};

actual: Core.Wire _ instance.actual;
child _ CoreOps.ToBasic[instance.type];
newBindings _ HashTable.Create[child.public.size+1];
FOR i: NAT IN [0..actual.size) DO
IF CoreOps.VisitBinding[actual: actual[i], public: child.public[i], eachWirePair: BindPublicToActual] THEN ERROR;
ENDLOOP;
};

FindPath: PUBLIC PROC [root: Core.CellType, pathRope: ROPE] RETURNS [path: PackedPath] = {
token: ROPE;
ts: IO.STREAM;
firstChar: CHAR;
tokenKind: IO.TokenKind;
within: Core.CellType;
[path, token, ts, firstChar, tokenKind, within] _ ParseFullPath[root, pathRope];
CheckNoMore[ts, firstChar, tokenKind];
};

PathRope: PUBLIC PROC [root: Core.CellType, path: PackedPath] RETURNS [pathRope: ROPE _ NIL] = {

AppendName: EachUnboundInstanceProc = {
coreInstance: CoreClasses.CellInstance _ instance.instance;
name: ROPE _ CoreClasses.GetCellInstanceName[coreInstance];
IF name=NIL THEN {
cellTypeName: ROPE _ CoreOps.GetCellTypeName[coreInstance.type];
name _ Convert.RopeFromInt[InstanceIndex[cellType, coreInstance]];
IF cellTypeName#NIL THEN name _ Rope.Cat[name, "(", cellTypeName, ")"];
};
pathRope _ Rope.Cat[pathRope, "/", name];
};

VisitUnboundPath[root, path, AppendName];
};

PathEqual: PUBLIC PROC [one: PackedPath, other: PackedPath] RETURNS [equal: BOOL] = {
oneBits: INT _ LOOPHOLE[one.bits];
otherBits: INT _ LOOPHOLE[other.bits];
equal _ one.length=other.length AND oneBits=otherBits;
};

PathHash: PUBLIC PROC [path: PackedPath] RETURNS [hash: CARDINAL] = TRUSTED {
pathAsLN: Basics.LongNumber _ Basics.SwapHalves[LOOPHOLE[path.bits]];
pathAsLN _ Basics.DoubleShiftRight[pathAsLN, 32-path.length];
hash _ Basics.BITXOR[pathAsLN.lowbits, pathAsLN.highbits];
};

ComputePackedPath: PUBLIC PROC [root: Core.CellType, instantiationPath: InstantiationPath] RETURNS [path: PackedPath] = {
path.length _ 0;
instantiationPath _ CoreClasses.ReverseCellInstances[instantiationPath];
FOR instPath: InstantiationPath _ instantiationPath, instPath.rest UNTIL instPath=NIL DO
rc: Core.CellType _ CoreOps.ToBasic[root];
rct: CoreClasses.RecordCellType _ NARROW[rc.data];
FOR in: NAT IN [0..rct.size) DO
IF rct[in]=instPath.first THEN {
pathBits: NAT _ BitHacks.NBits[rct.size];
path _ ExtendPath[path, in, pathBits];
root _ rct[in].type;
EXIT;
};
REPEAT
FINISHED => ERROR;
ENDLOOP;
ENDLOOP;
};

FindInstance: PUBLIC PROC [root: Core.CellType, instancePathRope: ROPE] RETURNS [instance: FlatInstanceRec] = {
within: Core.CellType;
token: ROPE;
ts: IO.STREAM;
firstChar: CHAR;
tokenKind: IO.TokenKind;
[instance.path, instance.instance, within, token, ts, firstChar, tokenKind] _ ParseInstancePath[root, instancePathRope];
CheckNoMore[ts, firstChar, tokenKind];
};

InstancePathRope: PUBLIC PROC [root: Core.CellType, instance: FlatInstanceRec] RETURNS [instancePathRope: ROPE] = {
pathWithInstance: PackedPath _ AddInstance[instance.path, instance.instance, GetCellType[root, instance.path]];
instancePathRope _ PathRope[root, pathWithInstance];
};

FlatInstanceEqual: PUBLIC PROC [one, other: REF ANY -- FlatInstance --] RETURNS [equal: BOOL] = {
equal _ FlatInstanceEqualRec[NARROW[one, FlatInstance]^, NARROW[other, FlatInstance]^];
};

FlatInstanceEqualRec: PUBLIC PROC [one, other: FlatInstanceRec] RETURNS [equal: BOOL] = {
equal _ PathEqual[one.path, other.path] AND one.instance=other.instance;
};

FlatInstanceHash: PUBLIC PROC [instance: REF ANY -- FlatInstance --] RETURNS [hash: CARDINAL] = {
hash _ FlatInstanceHashRec[NARROW[instance, FlatInstance]^];
};

FlatInstanceHashRec: PUBLIC PROC [instance: FlatInstanceRec] RETURNS [hash: CARDINAL] = {
hash _ PathHash[instance.path];
hash _ Basics.BITXOR[hash, Basics.LowHalf[LOOPHOLE[instance.instance]]];
hash _ Basics.BITXOR[hash, Basics.HighHalf[LOOPHOLE[instance.instance]]];
};

FindWire: PUBLIC PROC [root: Core.CellType, wirePathRope: ROPE] RETURNS [wire: FlatWireRec, wireRoot: WireRoot] = {

AppendNameWire: PROC = {
state _ sawWireNameOrNumber;
IF RootWire[]#none THEN MakeError["Cannot name a wire actual, internal, or public"];
FOR subWire: CARDINAL IN [0..wire.wire.size) DO
IF Rope.Equal[token, CoreOps.GetShortWireName[wire.wire[subWire]]] THEN {
wire.wire _ wire.wire[subWire];
EXIT;
};
REPEAT FINISHED => MakeError["Can't find wire"];
ENDLOOP;
};

AppendNumberWire: PROC = {
parent: Core.Wire _ IF wire.wire=NIL THEN NARROW[CoreOps.ToBasic[within].data, CoreClasses.RecordCellType].internal ELSE wire.wire;
subWire: CARDINAL _ Convert.CardFromRope[token];
IF subWire>=parent.size THEN MakeError["No such wire"];
wire.wire _ parent[subWire];
};

PossibleRootWire: PROC = {
wireType: RootWireType _ RootWire[];
SELECT wireType FROM
public => {
state _ sawWireRoot;
wire.wire _ within.public;
wireRoot _ public; 
};
internal => {
rct: CoreClasses.RecordCellType _ NARROW[CoreOps.ToBasic[within].data];
state _ sawWireRoot;
wire.wire _ rct.internal;
wireRoot _ internal; 
};
actual => {
MakeError["Visiting actual not implemented"];
};
none => {
wire.wire _ NARROW[CoreOps.ToBasic[within].data, CoreClasses.RecordCellType].internal;
AppendNameWire[];
wireRoot _ internal; 
};
ENDCASE => ERROR;
};

RootWireType: TYPE = {public, internal, actual, none};

RootWire: PROC RETURNS [RootWireType] = {
RETURN [SELECT TRUE FROM
Rope.Equal[token, "PUBLIC", FALSE] => public,
Rope.Equal[token, "INTERNAL", FALSE] => internal,
Rope.Equal[token, "ACTUAL", FALSE] => actual,
ENDCASE => none];
};

WirePathParseStates: TYPE = {start, expectMaybeRoot, sawWireRoot, expectWireNameOrNumber, sawWireNameOrNumber, sawLeft, sawNumber, sawRight};
token: ROPE;
ts: IO.STREAM;
firstChar: CHAR;
tokenKind: IO.TokenKind;
within: Core.CellType;
state: WirePathParseStates _ start;
[wire.path, token, ts, firstChar, tokenKind, within] _ ParseFullPath[root, wirePathRope];
DO
SELECT state FROM
start => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'[ => state _ sawLeft;
'. => state _ expectMaybeRoot;
ENDCASE => MakeError[];
tokenID => PossibleRootWire[];
tokenDECIMAL => {AppendNumberWire[]; state _ sawWireNameOrNumber};
ENDCASE => MakeError[];
expectMaybeRoot => SELECT tokenKind FROM
tokenID => PossibleRootWire[];
tokenDECIMAL => {AppendNumberWire[]; state _ sawWireNameOrNumber};
ENDCASE => MakeError[];
sawWireRoot => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'. => state _ expectWireNameOrNumber;
ENDCASE => MakeError[];
ENDCASE => MakeError[];
expectWireNameOrNumber => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'[ => state _ sawLeft;
ENDCASE => MakeError[];
tokenID => AppendNameWire[];
tokenDECIMAL => {AppendNumberWire[]; state _ sawWireNameOrNumber};
ENDCASE => MakeError[];
sawWireNameOrNumber => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'. => state _ expectWireNameOrNumber;
'[ => state _ sawLeft;
ENDCASE => MakeError[];
ENDCASE => MakeError[];
sawLeft => SELECT tokenKind FROM
tokenDECIMAL => {AppendNumberWire[]; state _ sawNumber};
ENDCASE => MakeError[];
sawNumber => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'] => state _ sawRight;
ENDCASE => MakeError[];
ENDCASE => MakeError[];
sawRight => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'[ => state _ sawLeft;
ENDCASE => MakeError[];
tokenID => AppendNameWire[];
tokenDECIMAL => {AppendNumberWire[]; state _ sawWireNameOrNumber};
ENDCASE => MakeError[];
ENDCASE => MakeError[];
[token, firstChar, tokenKind] _ ParseToken[ts ! IO.EndOfStream => EXIT];
ENDLOOP;
IF state=sawWireRoot OR state=expectWireNameOrNumber OR state=sawLeft OR state=sawNumber THEN MakeError[];
};

WirePathRope: PUBLIC PROC [root: Core.CellType, wire: FlatWireRec, wireRoot: WireRoot _ internal] RETURNS [wirePathRope: ROPE] = {
rootWire: Core.Wire;
pathRope: ROPE;
SELECT wireRoot FROM
public => {

SetContainerCell: EachUnboundInstanceProc = {
containerCell _ instance.instance.type;
};

containerCell: Core.CellType _ root;
VisitUnboundPath[root, wire.path, SetContainerCell];
rootWire _ containerCell.public;
};
internal => rootWire _ NARROW[CoreOps.ToBasic[GetCellType[root, wire.path]].data, CoreClasses.RecordCellType].internal;
actual => ERROR;  -- not implemented
ENDCASE => ERROR;
pathRope _ PathRope[root, wire.path];
IF NOT Rope.IsEmpty[pathRope] THEN pathRope _ Rope.Cat[pathRope, "."]; 
wirePathRope _ Rope.Cat[pathRope, SELECT wireRoot FROM public => "public.", internal => "internal.", actual => "actual.", ENDCASE => ERROR, CoreOps.GetFullWireNames[rootWire, wire.wire].first];
};

FlatWireEqual: PUBLIC PROC [one, other: REF ANY -- FlatWire --] RETURNS [equal: BOOL] = {
equal _ FlatWireEqualRec[NARROW[one, FlatWire]^, NARROW[other, FlatWire]^];
};

FlatWireEqualRec: PUBLIC PROC [one, other: FlatWireRec] RETURNS [equal: BOOL] = {
equal _ PathEqual[one.path, other.path] AND one.wire=other.wire;
};

FlatWireHash: PUBLIC PROC [wire: REF ANY -- FlatWire --] RETURNS [hash: CARDINAL] = {
hash _ FlatWireHashRec[NARROW[wire, FlatWire]^];
};

FlatWireHashRec: PUBLIC PROC [wire: FlatWireRec] RETURNS [hash: CARDINAL] = TRUSTED {
hash _ PathHash[wire.path];
hash _ Basics.BITXOR[hash, Basics.LowHalf[LOOPHOLE[wire.wire]]];
hash _ Basics.BITXOR[hash, Basics.HighHalf[LOOPHOLE[wire.wire]]];
};

InstanceIndex: PROC [within: Core.CellType, instance: CoreClasses.CellInstance] RETURNS [index: NAT] = {
withinCT: Core.CellType _ CoreOps.ToBasic[within];
withinRCT: CoreClasses.RecordCellType _ NARROW[withinCT.data];
FOR index IN [0..withinRCT.size) DO
IF withinRCT[index]=instance THEN EXIT;
REPEAT FINISHED => ERROR;
ENDLOOP;
};

ParseFullPath: PUBLIC PROC [root: Core.CellType, pathRope: ROPE] RETURNS [path: PackedPath, token: ROPE, ts: IO.STREAM, firstChar: CHAR, tokenKind: IO.TokenKind, within: Core.CellType] = {
instance: CoreClasses.CellInstance;
[path, instance, within, token, ts, firstChar, tokenKind] _ ParseInstancePath[root, pathRope];
path _ AddInstance[path, instance, within];
IF instance#NIL THEN within _ instance.type;
};

ParseInstancePath: PROC [root: Core.CellType, pathRope: ROPE] RETURNS [path: PackedPath _ CoreFlat.NullPath, instance: CoreClasses.CellInstance _ NIL, within: Core.CellType, token: ROPE, ts: IO.STREAM, firstChar: CHAR, tokenKind: IO.TokenKind] = {

AppendNameInstance: PROC = {
found: BOOL _ FALSE;
rct: CoreClasses.RecordCellType;
path _ AddInstance[path, instance, within];
within _ IF instance=NIL THEN root ELSE instance.type;
rct _ NARROW[CoreOps.ToBasic[within].data];
FOR inst: CARDINAL IN [0..rct.size) DO
IF Rope.Equal[token, CoreClasses.GetCellInstanceName[rct[inst]]] THEN {
instance _ rct[inst];
found _ TRUE;
EXIT;
};
REPEAT FINISHED => FOR inst: CARDINAL IN [0..rct.size) DO
IF Rope.Equal[token, CoreOps.GetCellTypeName[rct[inst].type]] THEN {
IF found THEN MakeError["Append by cell type name is ambiguous"];
instance _ rct[inst];
found _ TRUE;
};
ENDLOOP;
ENDLOOP;
IF NOT found THEN MakeError[Rope.Cat["Can't find instance or cell type of name ", token]];
state _ sawInstanceNameOrNumber;
};

AppendNumberInstance: PROC = {
rct: CoreClasses.RecordCellType;
inst: CARDINAL _ Convert.CardFromRope[token];
path _ AddInstance[path, instance, within];
within _ IF instance=NIL THEN root ELSE instance.type;
rct _ NARROW[CoreOps.ToBasic[within].data];
IF inst>=rct.size THEN MakeError[Rope.Cat["No such instance ", token]];
instance _ rct[inst];
state _ sawInstanceNumber;
};

CheckCellTypeName: PROC = {
IF NOT Rope.Equal[token, CoreOps.GetCellTypeName[instance.type]] THEN MakeError[Rope.Cat["Incorrect cell type name ", token]];
state _ sawCellTypeName;
};

InstancePathParseStates: TYPE = {start, expectInstanceNameOrNumber, sawInstanceNumber, sawLeftParan, sawCellTypeName, sawInstanceNameOrNumber};
state: InstancePathParseStates _ start;
within _ root;
ts _ IO.RIS[pathRope];
DO
[token, firstChar, tokenKind] _ ParseToken[ts ! IO.EndOfStream => {tokenKind _ tokenEOF; EXIT}];
SELECT state FROM
start => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'/ => state _ expectInstanceNameOrNumber;
'[ => EXIT;
ENDCASE => MakeError[];
tokenID => EXIT;
tokenDECIMAL => EXIT;
ENDCASE => MakeError[];
expectInstanceNameOrNumber => SELECT tokenKind FROM
tokenID => AppendNameInstance[];
tokenDECIMAL => AppendNumberInstance[];
ENDCASE => MakeError[];
sawInstanceNumber => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'( => state _ sawLeftParan;
'/ => state _ expectInstanceNameOrNumber;
'. => EXIT;
ENDCASE => MakeError[];
ENDCASE => MakeError[];
sawLeftParan => SELECT tokenKind FROM
tokenID => CheckCellTypeName[];
ENDCASE => MakeError[];
sawCellTypeName => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
') => state _ sawInstanceNameOrNumber;
ENDCASE => MakeError[];
ENDCASE => MakeError[];
sawInstanceNameOrNumber => SELECT tokenKind FROM
tokenSINGLE => SELECT firstChar FROM
'/ => state _ expectInstanceNameOrNumber;
'., '[ => EXIT;
ENDCASE => MakeError[];
ENDCASE => MakeError[];
ENDCASE => MakeError[];
ENDLOOP;
IF state=expectInstanceNameOrNumber OR state=sawLeftParan OR state=sawCellTypeName THEN MakeError[];
};

AddInstance: PUBLIC PROC [currentPath: PackedPath, instance: CoreClasses.CellInstance, within: Core.CellType] RETURNS [newPath: PackedPath] = {
newPath _ currentPath;
IF instance#NIL THEN {
withinCT: Core.CellType _ CoreOps.ToBasic[within];
withinRCT: CoreClasses.RecordCellType _ NARROW[withinCT.data];
index: NAT _ InstanceIndex[within, instance];
pathBits: NAT _ BitHacks.NBits[withinRCT.size];
newPath _ ExtendPath[currentPath, index, pathBits];
};
};

ExtendPath: PROC [currentPath: PackedPath, index: NAT, pathBits: NAT] RETURNS [newPath: PackedPath] = {
newPath _ currentPath;
FOR bit: NAT IN [0..pathBits) DO
newPath.bits[newPath.length+bit] _ BitHacks.XthBitOfN[pathBits-bit-1, index];
ENDLOOP;
newPath.length _ newPath.length + pathBits;
};

CheckNoMore: PROC [ts: IO.STREAM, firstChar: CHAR, tokenKind: IO.TokenKind] = {
token: ROPE;
IF tokenKind=tokenSINGLE AND firstChar='. THEN [token, firstChar, tokenKind] _ ParseToken[ts ! IO.EndOfStream => {tokenKind _ tokenEOF; CONTINUE}];
IF tokenKind#tokenEOF THEN MakeError[];
};

MakeError: PROC [m: ROPE _ NIL] = {
IF m=NIL THEN m _ "parse failed";
ERROR PathError[m];
};

ParseToken: PROC [ts: IO.STREAM] RETURNS [token: ROPE, firstChar: CHAR, tokenKind: IO.TokenKind] = {
token _ IO.GetTokenRope[ts, Breaks].token;
firstChar _ Rope.Fetch[token];
tokenKind _ SELECT TRUE FROM
Rope.Length[token]=1 AND Breaks[firstChar]=break => tokenSINGLE,
firstChar IN ['0..'9] => tokenDECIMAL,
ENDCASE => tokenID;
};

Breaks: IO.BreakProc = {
RETURN[SELECT char FROM
IN [IO.NUL .. IO.SP] => sepr,
'/, '., '(, '), '[, '] => break,
ENDCASE => other]
};

END.
0CoreFlatImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Barth, May 1, 1986 3:52:25 pm PDT
Spreitzer, April 8, 1986 4:31:47 pm PST
Last Edited by: Neil Gunther May 8, 1986 6:12:55 pm PDT
Bertrand Serlet May 16, 1986 11:28:14 am PDT

Flatten


Paths
IF equal THEN FOR bit: NAT IN [0..one.length) DO
IF one.bits[bit]#other.bits[bit] THEN {
equal _ FALSE;
EXIT;
};
ENDLOOP;
Instances
Wires
WirePath ::= {start} ?((PUBLIC | INTERNAL | ACTUAL ) {sawWireRoot} . {expectWireNameOrNumber} )  (( Name | Number ) {sawWireNameOrNumber} ?( . {expectWireNameOrNumber})) | ( [ {sawLeft} Number {sawNumber} ] {sawRight} )
Utilities
InstancePath ::= {start} / {expectInstanceNameOrNumber} ( Name | (Number {sawInstanceNumber} ?( ( {sawLeftParan} Name {sawCellTypeName} ) ) )  {sawInstanceNameOrNumber} )
ΚΥ–

"cedar" style˜
codeš
œ™Kšœ
Οm
œ1™<K™!K™'K™7K™,K™—KšΟk	œMžœ˜_K˜•StartOfExpansion[]šΠbnœžœ
ž˜Kšžœ=žœ˜LKšžœ	˜Kšœžœ
žœ
˜—K˜KšΟn	œžœ
žœžœžœžœ
˜1
head™š
 œžœ
žœ)žœžœ˜lK˜šŸœ˜(Kš
œ7˜7Kš
œ˜K˜—Kš
œ$˜$Kš
œ*˜*Kš
œ˜Kš
œ˜K˜—š œžœ
žœS˜pKš
œ#˜#šžœ ž˜'Kš
œ0˜0Kšœ"žœ˜9Kšœ
žœ˜)Kš
œžœ
žœ	žœ
žœžœžœ˜9Kš
œ#˜#Kš
œ"˜"šžœžœ
žœž˜ Kš
œB˜BKš
œM˜MKšžœ
˜—Kš
œ1˜1Kšœžœ˜'Kš
œ˜Kš
œ,˜,Kšžœ
˜—Kš
œ˜K˜—š 
œžœ
žœ)žœ9˜ƒ
K˜šŸœ˜+Kš
œ˜Kš
œ˜K˜—Kš
œ$˜$Kš
œ8˜8Kš
œ˜Kš
œ˜K˜—š œžœ
žœNžœ ˜
K˜š œ˜4Kš
œ0˜0Kš
œF˜FKš
œ+˜+K˜K˜—Kš
œ˜Kš
œ5˜5K˜6Kš
œ,˜,Kš
œ˜K˜—š œžœ
žœyžœ˜
K˜š 
œžœI˜\Kšœ(žœ˜<Kšœ
žœ"˜/Kš
œ%˜%Kšžœžœ
žœ)˜Dšžœžœ
žœž˜%Kš
œ3˜3šžœ(žœ˜0Kš
œ˜K˜Kš
œ8˜8Kš
œB˜BKš
œ˜—Kšžœ
˜—Kšžœžœ
žœ(˜BK˜K˜—Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ/˜/Kšžœžœ
žœ'˜?Kš
œ'˜'˜K™——š
 œžœ
žœUžœ+žœ˜±
K˜š 
œ˜ K˜š œ˜"Kš
œ˜Kšžœ
žœ
žœ
˜Kšœžœ5˜BKšžœžœ˜4K˜K˜—Kš
žœ
žœžœAžœ
žœ
˜kKšžœžœ
žœU˜qK˜K˜—šŸœ˜$KšœžœG˜Rš
žœžœ
žœžœ`žœ˜Œ
šžœžœ˜K˜9Kšœ9žœ1˜mK˜
—Kšžœžœ
˜Kš
œ˜—K˜K˜—K˜Kšžœžœ
žœ
˜Kš
œW˜W˜K˜——š œžœžœ8˜nK˜šŸœ˜(š
œ˜Kš
œ˜Kšœžœ-˜7Kš
œ˜—Kš
œ˜K˜—Kš
œ ˜ Kš
œ3˜3šžœžœ
žœž˜)KšžœFžœ
žœ
˜SKšžœ
˜—˜K™——š œžœK˜]K˜šŸœ˜(Kšœžœ5˜Pšžœ
žœ
žœ˜*Kš
œ˜Kšœžœ)˜3Kš
œ˜—Kš
œ˜K˜—Kšœžœ5˜Ršžœžœ
žœž˜#Kšžœ@žœ
žœ
˜MKšžœ
˜—K˜K˜—š œžœAžœ9˜“
K˜š œ˜0Kšœžœ;˜RKšžœžœ
žœ
žœ
˜Kš
œG˜GKš
œ˜K˜—K˜$Kš
œ'˜'Kš
œ4˜4šžœžœ
žœž˜!Kšžœdžœ
žœ
˜qKšžœ
˜—K˜K˜——™š
 œžœ
žœ!žœžœ˜ZKšœžœ
˜Kšœžœ
žœ
˜Kšœžœ
˜Kšœžœ˜Kš
œ˜Kš
œP˜PKš
œ&˜&Kš
œ˜K˜—š œžœ
žœ)žœžœžœ˜`K˜šŸ
œ˜'Kš
œ;˜;Kšœžœ1˜;šžœžœ
žœ˜Kšœžœ.˜@Kš
œB˜BKšžœžœ
žœ/˜GK˜—Kš
œ)˜)Kš
œ˜K˜—Kš
œ)˜)Kš
œ˜K˜—š
 	œžœ
žœ&žœ	žœ˜UKšœ	žœžœ˜"Kšœžœžœ
˜&Kšœ žœ˜6šžœžœ
žœžœ
žœž™0šžœžœ™'Kšœžœ
™Kšžœ
™K™—Kšžœ
™—Kš
œ˜K˜—š œžœ
žœžœžœžœ˜MKšœ0žœ
˜EKš
œ=˜=Jšœžœ&˜:Kš
œ˜K˜—š œžœ
žœ=žœ˜yKš
œ˜Kš
œH˜Hšžœ@žœ
žœ
ž˜XKš
œ*˜*Kšœ"žœ
˜2šžœžœ
žœž˜šžœžœ˜ Kšœ
žœ˜)Kš
œ&˜&Kš
œ˜Kšžœ
˜K˜—š
ž˜Kšžœžœ
˜—Kšžœ
˜—Kšžœ
˜—Kš
œ˜K˜——™	š
 œžœ
žœ)žœžœ ˜oKš
œ˜Kšœžœ
˜Kšœžœ
žœ
˜Kšœžœ
˜Kšœžœ˜Kš
œx˜xKš
œ&˜&K˜K˜—š
 œžœ
žœ2žœžœ˜sKš
œo˜oKš
œ4˜4Kš
œ˜K˜—š œžœ
žœžœ
žœ
Οcœžœ	žœ˜aKšœžœžœ˜WKš
œ˜K˜—š
 œžœ
žœžœ	žœ˜YJšœ(žœ˜HKš
œ˜K˜—š œžœ
žœžœ
žœ
‘œžœžœ˜aKšœžœ˜<K˜K˜—š
 œžœ
žœžœžœ˜YJš
œ˜Jšœžœžœ˜HJšœžœžœ˜IK˜K˜——™š
 œžœ
žœ%žœžœ,˜sK˜š œžœ˜Kš
œ˜Kšžœžœ=˜Tšžœ
žœ
žœž˜/šžœAžœ˜IKš
œ˜Kšžœ
˜K˜—Kšžœ
žœ!˜0Kšžœ
˜—K˜K˜—š œžœ˜Kšœžœžœ
žœ
žœDžœ˜ƒ
Kšœ	žœ˜0Kšžœžœ˜7Kš
œ˜Kš
œ˜K˜—š œžœ˜Kš
œ$˜$šžœ
ž˜š
œ˜Kš
œ˜K˜Kš
œ˜K˜—š
œ
˜
Kšœ"žœ˜GKš
œ˜Kš
œ˜Kš
œ˜K˜—š
œ˜Kš
œ-˜-K˜—š
œ	˜	KšœžœD˜VKš
œ˜Kš
œ˜K˜—Kšžœžœ
˜—K˜K˜—šœžœ$˜6K˜—š œžœ
žœ˜)šžœžœ
žœ
ž˜Kšœžœ˜-Kšœžœ˜1Kšœžœ˜-Kšžœ
˜—K˜K˜—Kš Οbœ’žœ
’
œ
žœ
’
œ
žœ
’
œ*’œ
’œ’
œ’
œ’œ’œ
’
œ
’
œ-’
™Ϋ
Kšœžœt˜
Kšœžœ
˜Kšœžœ
žœ
˜Kšœžœ
˜Kšœžœ˜Kš
œ˜Kš
œ#˜#Kš
œY˜Yš
ž˜šžœž˜šœ	žœž˜šœžœž˜$Kš
œ˜Kš
œ˜Kšžœ˜—Kš
œ˜Kš
œB˜BKšžœ˜—šœžœž˜(Kš
œ˜Kš
œB˜BKšžœ˜—šœžœž˜$šœžœž˜$Kš
œ%˜%Kšžœ˜—Kšžœ˜—šœžœž˜/šœžœž˜$Kš
œ˜Kšžœ˜—Kš
œ˜Kš
œB˜BKšžœ˜—šœžœž˜,šœžœž˜$Kš
œ%˜%Kš
œ˜Kšžœ˜—Kšžœ˜—šœžœž˜ Kš
œ8˜8Kšžœ˜—šœ
žœž˜"šœžœž˜$Kš
œ˜Kšžœ˜—Kšžœ˜—šœžœž˜!šœžœž˜$Kš
œ˜Kšžœ˜—Kš
œ˜Kš
œB˜BKšžœ˜—Kšžœ˜—Kšœ0žœžœ˜HKšžœ
˜—Kš
žœžœžœžœžœ
˜jK˜K˜—š
 œžœ
žœIžœžœ˜‚
Kš
œ˜Kšœ
žœ
˜šžœ
ž˜š
œ˜K˜š œ˜-Kš
œ'˜'Kš
œ˜K˜—Kš
œ$˜$Kš
œ4˜4Kš
œ ˜ K˜—KšœžœZ˜wKšœ
žœ‘˜$Kšžœžœ
˜—Kš
œ%˜%Kšžœ
žœžœ%˜GKš	œ"žœ
žœDžœžœ7˜Α
K˜K˜—š 
œžœ
žœžœ
žœ
‘œžœ	žœ˜YKšœžœžœ˜KKš
œ˜K˜—š
 œžœ
žœžœ	žœ˜QJšœ(žœ˜@Kš
œ˜K˜—š œžœ
žœžœ
žœ
‘œžœžœ˜UKšœžœ˜0Kš
œ˜K˜—š œžœ
žœžœžœžœ˜UJš
œ˜Jšœžœžœ˜@Jšœžœžœ˜AKš
œ˜K˜——™	š 
œžœ=žœ	žœ˜hKš
œ2˜2Kšœ(žœ˜>šžœžœž˜#Kšžœžœ
žœ
˜'Kšžœ
žœžœ
˜Kšžœ
˜—Kš
œ˜K˜—š 
œžœ
žœ!žœžœžœžœ
žœ
žœ
žœ&˜Ό
Kš
œ#˜#Kš
œ^˜^Kš
œ+˜+Kšžœ
žœ
žœ˜,Kš
œ˜K˜—š œžœ!žœžœMžœ žœžœ
žœ
žœ
žœ˜χ
K˜š œžœ˜Kšœžœžœ
˜Kš
œ ˜ Kš
œ+˜+Kš	œ	žœ
žœ
žœžœ˜6Kšœžœ˜+šžœžœ
žœž˜&šžœ?žœ˜GKš
œ˜Kšœžœ
˜
Kšžœ
˜K˜—šžœ
žœžœžœ
žœž˜9šžœ<žœ˜DKšžœžœ4˜AKš
œ˜Kšœžœ
˜
K˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
žœžœI˜ZKš
œ ˜ K˜K˜—š œžœ˜Kš
œ ˜ Kšœžœ˜-Kš
œ+˜+Kš	œ	žœ
žœ
žœžœ˜6Kšœžœ˜+Kšžœžœ1˜GKš
œ˜Kš
œ˜Kš
œ˜K˜—š œžœ˜Kšžœ
žœ;žœ9˜~Kš
œ˜K˜K˜—Kš’œ’
œ’
œ’
œ
’
œ’œ+’
œ
’
œ’
™ͺ
Kšœžœr˜
Kš
œ'˜'Kš
œ˜Kšœžœ
žœ˜š
ž˜Kšœ0žœ'žœ˜`šžœž˜šœ	žœž˜šœžœž˜$Kš
œ)˜)Kšœžœ
˜Kšžœ˜—Kšœžœ
˜Kšœžœ
˜Kšžœ˜—šœžœž˜3Kš
œ ˜ Kš
œ'˜'Kšžœ˜—šœžœž˜*šœžœž˜$Kš
œ˜Kš
œ)˜)Kšœžœ
˜Kšžœ˜—Kšžœ˜—šœžœž˜%Kš
œ˜Kšžœ˜—šœžœž˜(šœžœž˜$Kš
œ&˜&Kšžœ˜—Kšžœ˜—šœžœž˜0šœžœž˜$Kš
œ)˜)Kšœ
žœ
˜Kšžœ˜—Kšžœ˜—Kšžœ˜—Kšžœ
˜—Kšžœ"žœžœžœ
˜dKš
œ˜K˜—š œžœ
žœVžœ˜
Kš
œ˜šžœ
žœ
žœ˜Kš
œ2˜2Kšœ(žœ˜>Kšœžœ#˜-Kšœ
žœ"˜/Kš
œ3˜3Kš
œ˜—Kš
œ˜K˜—š
 
œžœ"žœžœžœ˜gKš
œ˜šžœžœ
žœž˜ Kš
œM˜MKšžœ
˜—Kš
œ+˜+K˜K˜—š œžœžœ
žœ
žœ
žœ˜OKšœžœ
˜Kš
žœžœžœ1žœ'žœ˜“
Kšžœžœ
˜'K˜K˜—š 	œžœžœžœ˜#Kšžœžœ
žœ˜!Kšžœ˜K˜K˜—š 
œžœžœ
žœžœ	žœ
žœ
žœ˜dKšœžœ ˜*Kš
œ˜šœžœ
žœ
ž˜Kšœžœ(˜@Kšœ
žœ˜&Kšžœ˜—Kš
œ˜K˜—šŸœžœ˜šžœ
žœž˜Kš
žœžœ
žœžœ
žœ
˜Kš
œ ˜ Kšžœ
˜—K˜K˜——Kšžœ
˜—…—PŒk‘