DIRECTORY
Asserting USING [Assertions, Assertion, Terms, RelnOf, TermsOf, ToAssertions, Assert, Test],
AssertingIO, Atom, Basics, CompareDataStructure, CompareOps, DFUtilities, FS, IO, List, OrderedSymbolTableRef, Rope;

CompareRead: CEDAR PROGRAM
IMPORTS Asserting, AssertingIO, Atom, CompareDataStructure, CompareOps, DFUtilities, FS, IO, List, OrderedSymbolTableRef, Rope
EXPORTS CompareOps =

BEGIN OPEN Asserting, CompareDataStructure, CompareOps;

DFTest: PROC [dfName: ROPE] =
BEGIN
PerItem: PROC [item: REF ANY] RETURNS [stop: BOOL _ FALSE] =
{Log["%g\n", IO.refAny[item]]};
from: IO.STREAM _ FS.StreamOpen[dfName];
Log["\nTesting DF file %g\n", IO.rope[dfName]];
DFUtilities.ParseFromStream[in: from, proc: PerItem, filter: [comments: TRUE]];
from.Close[];
Log["\nDone testing DF file %g\n", IO.rope[dfName]];
END;

EasyOpen: PROC [fileName: ROPE] RETURNS [stream: IO.STREAM] =
{stream _ FS.StreamOpen[fileName]};

ReadDesign: PROC [dfName: ROPE, keepAll: BOOL _ FALSE] RETURNS [design: Design] =
BEGIN
NonGrok: PROC [context: REF ANY, source: Source, assn: Assertion] = {
WITH context SELECT FROM
design: Design => {
CheckIgnore[source, LIST[RelnOf[assn], $Design]];
IF keepAll THEN design.other _ CONS[assn, design.other];
};
cellType: CellType => {
CheckIgnore[source, LIST[RelnOf[assn], $CellType, $Design]];
IF keepAll THEN Warn[source, "Can't represent assertion %g about %g's name", IO.refAny[assn], IO.rope[GlobalCellTypeName[cellType]]];
};
ENDCASE => ERROR;
};
ReadFrom: PROC [dfName: ROPE, usingList: REF DFUtilities.UsingList] =
BEGIN
assns: Assertions _ NIL;
dir, dfShort: ROPE _ NIL;
s: Source;
DiscardAssns: PROC =
{FOR assns _ assns, assns.rest WHILE assns # NIL DO NonGrok[design, s, assns.first] ENDLOOP};
DesignAssns: PROC =
{FOR assns _ assns, assns.rest WHILE assns # NIL DO
WITH RelnOf[assns.first] SELECT FROM
a: ATOM => SELECT a FROM
$Design, $CreatingUser, $CreationTime, $CreationSite, $Version, $DerivingProgram, $Source => NULL --absorb accounting information, because it'll become invalid--;
$DesignName => {r: ROPE _ NARROW[TermsOf[assns.first].first];
design.name _ r};
ENDCASE => NonGrok[design, s, assns.first];
ENDCASE => NonGrok[design, s, assns.first];
ENDLOOP};
PerItem: PROC [item: REF ANY] RETURNS [stop: BOOL _ FALSE] =
BEGIN
WITH item SELECT FROM
di: REF DFUtilities.DirectoryItem => {dir _ di.path1; DesignAssns[]};
fi: REF DFUtilities.FileItem => {
verless: ROPE _ DFUtilities.RemoveVersionNumber[dir.Cat[fi.name]];
IF NOT DFUtilities.SearchUsingList[file: verless, list: usingList].found THEN assns _ NIL
ELSE {
typeName: Naming _ ["?"];
ct: CellType _ NIL;
FOR assns _ assns, assns.rest WHILE assns # NIL DO
assn: Assertion _ assns.first;
WITH RelnOf[assn] SELECT FROM
a: ATOM => SELECT a FROM
$CellType => {
IF ct # NIL THEN Warn[s, "Multiple CellTypes for file %g in %g", IO.rope[fi.name], IO.rope[dfName]];
ct _ NEW [CellTypeRep _ [design: design, names: [], file: verless]];
typeName _ [NARROW[TermsOf[assn].first]];
FOR ctnas: Assertions _ ToAssertions[TermsOf[assn].rest], ctnas.rest WHILE ctnas # NIL DO
ctna: Assertion _ ctnas.first;
WITH RelnOf[ctna] SELECT FROM
ia: ATOM => SELECT a FROM
$G => typeName _ AddG[typeName, ctna, LIST[$CellType, $Design], ct];
$A => typeName _ AddA[typeName, ctna, LIST[$CellType, $Design], ct];
ENDCASE => NonGrok[ct, s, ctna];
ENDCASE => NonGrok[ct, s, ctna];
ENDLOOP;
};
ENDCASE => NonGrok[design, s, assn];
ENDCASE => NonGrok[design, s, assn];
ENDLOOP;
IF ct # NIL THEN {
ct.names _ NamingNames[typeName];
AddCellType[ct];
}
ELSE {
IF NOT dfShort.Equal[fi.name, FALSE] THEN Warn[s, "Non-understood file entry: %g", IO.rope[fi.name]];
};
};
};
ii: REF DFUtilities.ImportsItem => {ReadFrom[ii.path1, IntUL[usingList, ii.list]]; DiscardAssns[]};
ii: REF DFUtilities.IncludeItem => {ReadFrom[ii.path1, usingList]; DiscardAssns[]};
ci: REF DFUtilities.CommentItem => assns _ AddAssn[ci.text, assns];
wi: REF DFUtilities.WhiteSpaceItem => NULL;
ENDCASE => ERROR;
END;
IF usingList = NIL OR usingList.nEntries > 0 THEN {
from: IO.STREAM _ FS.StreamOpen[dfName];
cp: FS.ComponentPositions;
dfFull: ROPE;
s _ [from, dfName];
[dfFull, cp, ] _ FS.ExpandName[dfName];
dfShort _ dfFull.Substr[start: cp.base.start, len: cp.ext.start+cp.ext.length-cp.base.start];
DFUtilities.ParseFromStream[in: from, proc: PerItem, filter: [comments: TRUE]];
from.Close[];
};
END;
cp: FS.ComponentPositions;
fullDFName: ROPE;
[fullDFName, cp, ] _ FS.ExpandName[dfName];
design _ NEW [DesignRep _ [
name: fullDFName.Substr[start: cp.base.start, len: cp.base.length],
cellTypesByName: OrderedSymbolTableRef.CreateTable[CompareNames],
cellTypesByAddress: OrderedSymbolTableRef.CreateTable[CompareByAddress],
allKept: keepAll
]];
ReadFrom[dfName: dfName, usingList: NIL];
END;

AddCellType: PUBLIC PROC [ct: CellType] = {
Insert[ct.design.cellTypesByName, ct.names, ct];
ct.design.cellTypesByAddress.Insert[ct];
};

AddAssn: PROC [comment: ROPE, assns: Assertions] RETURNS [with: Assertions] = {
in: IO.STREAM _ IO.RIS[comment];
char: CHAR;
assn: Assertion;
[] _ in.SkipWhitespace[flushComments: FALSE];
IF (char _ in.GetChar[]) # '- THEN ERROR;
IF (char _ in.GetChar[]) # '- THEN ERROR;
[] _ in.SkipWhitespace[];
IF in.EndOf[] THEN RETURN [assns];
IF (char _ in.GetChar[]) = '^ THEN {
IF in.EndOf[] THEN RETURN [assns];
char _ in.GetChar[];
};
IF char # '( THEN RETURN [assns];
in.Backup['(];
assn _ AssertingIO.ReadAssn[in];
with _ CONS[assn, assns];
in.Close[];
};

IntUL: PROC [a, b: REF DFUtilities.UsingList] RETURNS [c: REF DFUtilities.UsingList] = {
IF a = NIL AND b = NIL THEN RETURN [NIL];
IF b = NIL THEN RETURN [a];
DFUtilities.SortUsingList[b];
IF a = NIL THEN RETURN [b];
c _ NEW [DFUtilities.UsingList[MIN[a.nEntries, b.nEntries]]];
c.nEntries _ 0;
FOR i: NAT IN [0 .. a.nEntries) DO
found: BOOL _ DFUtilities.SearchUsingList[file: a[i].name, list: b].found;
IF found THEN {c[c.nEntries] _ a[i]; c.nEntries _ c.nEntries + 1};
ENDLOOP;
c _ c;
};

ReadCellType: PROC [ct: CellType, privateToo: BOOL] =
BEGIN
from: IO.STREAM;
currentlyPrivate: BOOL _ FALSE;
s: Source;
IF ct.publicKnown AND (ct.privateKnown OR NOT privateToo) THEN RETURN;
s _ [from _ FS.StreamOpen[ct.file], ct.file];
DO
assn: Assertion;
NonGrok: PROC = {
CheckIgnore[s, LIST[RelnOf[assn], $CellType]];
IF NOT ct.design.allKept THEN NULL
ELSE IF currentlyPrivate THEN ct.otherPrivate _ CONS[assn, ct.otherPrivate]
ELSE ct.otherPublic _ CONS[assn, ct.otherPublic]};
[] _ from.SkipWhitespace[];
IF from.EndOf[] THEN EXIT;
assn _ AssertingIO.ReadAssn[from];
WITH RelnOf[assn] SELECT FROM
a: ATOM => SELECT a FROM
$PrivateFollows => {IF currentlyPrivate THEN Warn[s, "(PrivateFollows) seen more than once"]; currentlyPrivate _ TRUE};
ENDCASE;
ENDCASE;
IF currentlyPrivate AND NOT privateToo THEN EXIT;
IF ct.publicKnown AND NOT currentlyPrivate THEN LOOP;
WITH RelnOf[assn] SELECT FROM
a: ATOM => SELECT a FROM
$PrivateFollows => NULL;
$CreatingUser, $CreationTime, $CreationSite, $Version, $DerivingProgram, $Source => NULL --absorb old audit trail--;
$CellTypeName => {naming: Naming _ [NARROW[TermsOf[assn].first]];
FOR ctnas: Assertions _ ToAssertions[TermsOf[assn].rest], ctnas.rest WHILE ctnas # NIL DO
ctna: Assertion _ ctnas.first;
NonRep: PROC = {
CheckIgnore[s, LIST[RelnOf[ctna], $CellTypeName, $CellType]];
IF ct.design.allKept THEN Warn[s, "Cant' represent assertion %g about %g's name", IO.refAny[ctna], IO.rope[GlobalCellTypeName[ct]]];
};
WITH RelnOf[ctna] SELECT FROM
ia: ATOM => SELECT ia FROM
$G => naming _ AddG[naming, ctna, LIST[$CellTypeName, $CellType], ct];
$A => naming _ AddA[naming, ctna, LIST[$CellTypeName, $CellType], ct];
ENDCASE => NonRep[];
ENDCASE => NonRep[];
ENDLOOP;
InsistSameNames[ct.names, NamingNames[naming], ct.design];
};
$EC => {reln: ROPE _ NARROW[TermsOf[assn].first];
equivClass: ROPE _ NARROW[TermsOf[assn].rest.first];
IF NOT reln.Equal["Structure"] THEN {
CheckIgnore[s, LIST[Atom.MakeAtom[reln], $EC, $CellType]];
IF NOT ct.design.allKept THEN NULL
ELSE IF currentlyPrivate THEN ct.otherPrivate _ CONS[assn, ct.otherPrivate]
ELSE ct.otherPublic _ CONS[assn, ct.otherPublic];
}
ELSE IF ct.equivClass = implicitClass THEN ct.equivClass _ equivClass
ELSE IF NOT equivClass.Equal[ct.equivClass] THEN Warn[s, "Multiple %g equivalence classes for %g: %g and %g", IO.rope[reln], IO.rope[GlobalCellTypeName[ct]], IO.rope[ct.equivClass], IO.rope[equivClass]];
};
$Ports => ReadPorts[ct, assn];
$PN => {
portName: ROPE _ NARROW[TermsOf[assn].first];
netName: ROPE _ NARROW[TermsOf[assn].rest.first];
portIndex: NAT _ FindPort[ct.ports, portName];
IF portIndex = notFound THEN Warn[s, "CellType %g has no port named %g", IO.rope[GlobalCellTypeName[ct]], IO.refAny[portName]]
ELSE ct.ports[portIndex].netNames _ CONS[netName, ct.ports[portIndex].netNames];
};
$N => ReadNet[ct, assn];
$CI => ReadCellInstance[ct, assn];
$InsidesUnspecified => {
IF ct.parts # NIL THEN Warn[s, "Unspecified insides were specified for cell type %g", IO.rope[GlobalCellTypeName[ct]]];
};
ENDCASE => NonGrok[];
ENDCASE => NonGrok[];
ENDLOOP;
IF ct.parts # NIL AND ct.mirror = NIL THEN AddWorld[ct];
ct.publicKnown _ TRUE;
ct.privateKnown _ privateToo;
from.Close[];
IF ExpansionKnown[ct] THEN {
FOR pi: NAT IN [0 .. ct.ports.length) DO
net: Vertex _ NIL;
FOR nnl: RopeList _ ct.ports[pi].netNames, nnl.rest WHILE nnl # NIL DO
n: Vertex _ NARROW[Lookup[ct.parts, nnl.first]];
SELECT TRUE FROM
n = NIL => Err[[], "No net %g in cell type %g", IO.refAny[nnl.first], IO.rope[GlobalCellTypeName[ct]]];
net = NIL => net _ n;
net # n => Err[[], "Multiple nets connected to port %g", IO.rope[GlobalPortName[ct, pi]]];
ENDCASE;
ENDLOOP;
ENDLOOP;
};
END;

InsistSameNames: PROC [n1, n2: Names, design: Design] = {
st: SymbolTable _ OrderedSymbolTableRef.CreateTable[CompareNames];
inBoth, in1, in2: ROPE _ NIL;
Add: PROC [rl: RopeList, ns: ATOM] = {
FOR rl _ rl, rl.rest WHILE rl # NIL DO
a: Alias _ NEW [AliasRep _ [name: rl.first, thing: ns]];
st.Insert[a];
ENDLOOP;
};
Remove: PROC [rl: RopeList, ns: ATOM] = {
FOR rl _ rl, rl.rest WHILE rl # NIL DO
a: Alias _ NARROW[st.Delete[rl.first]];
SELECT TRUE FROM
a = NIL => in2 _ AddName[in2, rl.first];
a # NIL => inBoth _ AddName[inBoth, rl.first];
ENDCASE => ERROR;
ENDLOOP;
};
NoteRest: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
a: Alias _ NARROW[ra];
in1 _ AddName[in1, a.name];
stop _ FALSE;
};
AddName: PROC [r, n: ROPE] RETURNS [nr: ROPE] = {
SELECT TRUE FROM
r = NIL => nr _ n;
r # NIL => nr _ r.Cat[", ", n];
ENDCASE => ERROR;
};
Add[n1.designed, $D];
Add[n1.unknown, $U];
Add[n1.progged, $P];
Remove[n2.designed, $D];
Remove[n2.unknown, $U];
Remove[n2.progged, $P];
st.EnumerateIncreasing[NoteRest];
IF in1 # NIL OR in2 # NIL THEN {
Warn[[], "In design %g, CellType certainly named (%g) also named (%g) in DF file only and (%g) in cell file only", IO.rope[design.name], IO.rope[inBoth], IO.rope[in1], IO.rope[in2]];
};
};

ReadCellInstance: PROC [ct: CellType, assn: Assertion] = {
instanceName: ROPE _ NARROW[TermsOf[assn].first];
typeName: ROPE _ NARROW[TermsOf[assn].rest.first];
instanceType: CellType _ NARROW[Lookup[ct.design.cellTypesByName, typeName]];
cv: Vertex;
naming: Naming _ [instanceName];
IF ct.parts = NIL THEN {
ct.parts _ OrderedSymbolTableRef.CreateTable[CompareVertices];
};
IF ct.mirror = NIL THEN AddWorld[ct];
cv _ NEW [VertexRep _ [
names: [],
type: instanceType,
parent: ct,
class: cell]];
FOR cial: Assertions _ ToAssertions[TermsOf[assn].rest.rest], cial.rest WHILE cial # NIL DO
cia: Assertion _ cial.first;
NonGrok: PROC = {
CheckIgnore[[], LIST[RelnOf[cia], $CI, $CellType]];
IF ct.design.allKept THEN cv.other _ CONS[cia, cv.other];
};
WITH RelnOf[cia] SELECT FROM
a: ATOM => SELECT a FROM
$G => naming _ AddG[naming, cia, LIST[$CI, $CellType], cv];
$A => naming _ AddA[naming, cia, LIST[$CI, $CellType], cv];
$CIC => {
portIndex: NAT _ 0;
EnsurePorts[instanceType];
FOR cicl: LORA _ TermsOf[cia], cicl.rest WHILE cicl # NIL DO
cic: LORA _ NARROW[cicl.first];
portName: ROPE _ NARROW[cic.first];
netName: ROPE _ NARROW[cic.rest.first];
net: Vertex _ NARROW[Lookup[ct.parts, netName]];
IF NOT NamesInclude[instanceType.ports[portIndex].names, portName] THEN Err[[], "Cell instance connections not in order on %g.%g", IO.rope[GlobalCellTypeName[ct]], IO.rope[instanceName]];
Connect[cv, net, portIndex];
IF cic.rest.rest # NIL THEN Warn[[], "Extra cell instance connection info for %g.%g.%g", IO.rope[GlobalCellTypeName[ct]], IO.refAny[instanceName], IO.refAny[portName]];
portIndex _ portIndex + 1;
ENDLOOP;
IF portIndex # instanceType.ports.length THEN Warn[[], "Extra cell instance connections for %g.%g", IO.rope[GlobalCellTypeName[ct]], IO.refAny[instanceName]];
};
ENDCASE => NonGrok[];
ENDCASE => NonGrok[];
ENDLOOP;
cv.names _ NamingNames[naming];
AddVertex[cv];
LinkInstance[cv];
};

AddWorld: PUBLIC PROC [ct: CellType] =
BEGIN
cv: Vertex;
IF ct.ports = NIL THEN ERROR;
ct.mirror _ cv _ NEW [VertexRep _ [names: [NIL, NIL, LIST[MirrorName]], type: ct, parent: ct, class: cell]];
FOR i: CARDINAL IN [0 .. ct.ports.length) DO
port: Port _ ct.ports[i];
nv: Vertex _ NARROW[Lookup[ct.parts, ct.ports[i].netNames.first]];
Connect[cv, nv, i];
ENDLOOP;
END;

ReadNet: PROC [ct: CellType, assn: Assertion] = {
netName: ROPE _ NARROW[TermsOf[assn].first];
nv: Vertex _ NEW [VertexRep _ [names: [], parent: ct, class: net]];
naming: Naming _ [netName];
IF ct.parts = NIL THEN {
ct.parts _ OrderedSymbolTableRef.CreateTable[CompareVertices];
};
FOR nal: Assertions _ ToAssertions[TermsOf[assn].rest], nal.rest WHILE nal # NIL DO
na: Assertion _ nal.first;
NonGrok: PROC = {
CheckIgnore[[], LIST[RelnOf[na], $N, $CellType]];
IF ct.design.allKept THEN nv.other _ CONS[na, nv.other];
};
WITH RelnOf[na] SELECT FROM
a: ATOM => SELECT a FROM
$G => naming _ AddG[naming, na, LIST[$N, $CellType], nv];
$A => naming _ AddA[naming, na, LIST[$N, $CellType], nv];
ENDCASE => NonGrok[];
ENDCASE => NonGrok[];
ENDLOOP;
nv.names _ NamingNames[naming];
AddVertex[nv];
};

AddG: PROC [in: Naming, assn: Assertion, context: LORA, owner: REF ANY] RETURNS [out: Naming] = {
gener: ATOM _ NARROW[TermsOf[assn].first];
out _ in;
IF RelnOf[assn] # $G THEN ERROR;
IF out.first = NIL THEN ERROR;
SELECT gener FROM
$D => out.designed _ CONS[out.first, out.designed];
$P => out.progged _ CONS[out.first, out.progged];
ENDCASE => {
CheckIgnore[[], CONS[gener, CONS[$G, context]]];
IF KeepAll[owner] THEN Warn[[], "Unable to represent assertion %g about %g's name", IO.refAny[assn], IO.rope[GlobalName[owner, out]]];
};
out.first _ NIL;
};

AddA: PROC [in: Naming, assn: Assertion, context: LORA, owner: REF ANY] RETURNS [out: Naming] = {
out _ in;
context _ CONS[$A, context];
IF RelnOf[assn] # $A THEN ERROR;
FOR aliasList: LORA _ TermsOf[assn], aliasList.rest WHILE aliasList # NIL DO
alias: LORA _ NARROW[aliasList.first];
newName: ROPE _ NARROW[alias.first];
known, designed: BOOL _ FALSE;
FOR aal: Assertions _ ToAssertions[alias.rest], aal.rest WHILE aal # NIL DO
aa: Assertion _ aal.first;
NonRep: PROC [firstArg: BOOL] = {
ctx: LORA _ CONS[RelnOf[aa], context];
IF firstArg THEN ctx _ CONS[TermsOf[aa].first, ctx];
CheckIgnore[[], ctx];
IF KeepAll[owner] THEN Warn[[], "Unable to represent assertion %g about name %g of %g", IO.refAny[aa], IO.rope[newName], IO.rope[GlobalName[owner, out]]];
};
WITH RelnOf[aa] SELECT FROM
a: ATOM => SELECT a FROM
$G => {gener: ATOM _ NARROW[TermsOf[aa].first];
SELECT gener FROM
$D => designed _ known _ TRUE;
$P => designed _ NOT (known _ TRUE);
ENDCASE => NonRep[TRUE];
};
ENDCASE => NonRep[FALSE];
ENDCASE => NonRep[FALSE];
ENDLOOP;
SELECT TRUE FROM
NOT known => out.unknown _ CONS[newName, out.unknown];
designed => out.designed _ CONS[newName, out.designed];
ENDCASE => out.progged _ CONS[newName, out.progged];
ENDLOOP;
};

NamingNames: PUBLIC PROC [naming: Naming] RETURNS [names: Names] = {
names _ [designed: ReverseRopeList[naming.designed], unknown: ReverseRopeList[naming.unknown], progged: ReverseRopeList[naming.progged]];
IF naming.first # NIL THEN names.unknown _ CONS[naming.first, names.unknown];
};

ReverseRopeList: PROC [inHead: RopeList] RETURNS [outHead: RopeList] = {
cur: RopeList _ inHead;
prev: RopeList _ NIL;
WHILE cur # NIL DO
next: RopeList _ cur.rest;
cur.rest _ prev;
prev _ cur;
cur _ next;
ENDLOOP;
outHead _ prev;
};

ReadPorts: PROC [ct: CellType, assn: Assertion] = {
len: NAT _ List.Length[TermsOf[assn]];
i: NAT _ 0;
s: Socket _ NEW [SocketRep _ [ct, NullPortIndex]];
IF ct.ports # NIL THEN ERROR;
ct.ports _ NEW [PortSeq[len]];
FOR psl: LORA _ TermsOf[assn], psl.rest WHILE psl # NIL DO
portSpec: LORA _ NARROW[psl.first];
naming: Naming _ [NARROW[portSpec.first]];
ct.ports[i] _ [];
s.portIndex _ i;
FOR pal: Assertions _ ToAssertions[portSpec.rest], pal.rest WHILE pal # NIL DO
pa: Assertion _ pal.first;
NonGrok: PROC = {
CheckIgnore[[], LIST[RelnOf[pa], $Ports, $CellType]];
IF ct.design.allKept THEN ct.ports[i].other _ CONS[pa, ct.ports[i].other];
};
WITH RelnOf[pa] SELECT FROM
paa: ATOM => SELECT paa FROM
$EC => {
reln: ROPE _ NARROW[TermsOf[pa].first];
equivClass: ROPE _ NARROW[TermsOf[pa].rest.first];
IF reln.Equal["Structure"] THEN {
IF ct.ports[i].equivClass = implicitClass THEN ct.ports[i].equivClass _ equivClass
ELSE IF NOT ct.ports[i].equivClass.Equal[equivClass] THEN Warn[[], "Multiple Sturcture equivalence classes for port %g : %g and %g", IO.rope[GlobalPortName[ct, i]], IO.refAny[ct.ports[i].equivClass], IO.refAny[equivClass]];
};
};
$G => naming _ AddG[naming, pa, LIST[$Ports, $CellType], s];
$A => naming _ AddA[naming, pa, LIST[$Ports, $CellType], s];
ENDCASE => NonGrok[];
ENDCASE => NonGrok[];
ENDLOOP;
ct.ports[i].names _ NamingNames[naming];
i _ i + 1;
ENDLOOP;
IF i # len THEN ERROR;
};

Connect: PUBLIC PROC [cv, nv: Vertex, portIndex: PortIndex] =
BEGIN
e: Edge _ NEW [EdgeRep _ [
sides: [net: [nv, NIL, nv.lastEdge], cell: [cv, NIL, cv.lastEdge]],
color: noColor,
portIndex: portIndex]];
IF nv.lastEdge # NIL THEN nv.lastEdge.sides[net].next _ e ELSE nv.firstEdge _ e;
IF cv.lastEdge # NIL THEN cv.lastEdge.sides[cell].next _ e ELSE cv.firstEdge _ e;
nv.lastEdge _ cv.lastEdge _ e;
END;

EnsureAllIn: PUBLIC PROC [design: Design] = {
PerType: PROC [ra: REF ANY] RETURNS [stop: BOOL] = {
ct: CellType _ NARROW[ra];
EnsureParts[ct];
stop _ FALSE};
IF design.allKnown THEN RETURN;
design.allKnown _ TRUE;
design.cellTypesByAddress.EnumerateIncreasing[PerType];
};

EnsurePorts: PUBLIC PROC [ct: CellType] = {
IF NOT ct.publicKnown THEN ReadCellType[ct, FALSE];
IF ct.ports = NIL THEN ERROR;
};

EnsureParts: PUBLIC PROC [ct: CellType] = {
IF NOT ct.privateKnown THEN ReadCellType[ct, TRUE];
};

ExpansionKnown: PUBLIC PROC [ct: CellType] RETURNS [known: BOOL] = {
known _ ct.parts # NIL OR ct.asArray # NIL;
};

GetInternalStyle: PUBLIC PROC [ct: CellType] RETURNS [is: InternalStyle] = {
is _ SELECT TRUE FROM
ct.asArray # NIL => array,
ct.parts # NIL => graph,
ENDCASE => ERROR;
};

NoteChange: PUBLIC PROC [ct: CellType] = {
IF NOT (ct.publicKnown AND ct.privateKnown) THEN ERROR;
ct.file _ NIL;
ct.inittedFor _ 0;};

WriteAll: PUBLIC PROC [when: ROPE, a, b: CellType, hashTable: HashTable] =
BEGIN
Log["\n%g\n", IO.rope[when]];
WriteHashTable[hashTable];
WriteSymbolTable["A", a.parts];
WriteSymbolTable["B", b.parts];
Log["\nDone %g\n", IO.rope[when]];
END;

WriteHashTable: PROC [hashTable: HashTable] =
BEGIN
Log["\nHashTable:\n"];
FOR hti: HashTableIndex _ hashTable.firstNonEmpty, hashTable[hti].nextNonEmpty WHILE hti # NullIndex DO
hte: HashTableEntry _ hashTable[hti];
Log["%05d %4g %4g", IO.card[hti], IO.card[hte.count[A]], IO.card[hte.count[B]]];
Log[" %05d %5g %5g", IO.card[hte.newColor], IO.bool[hte.multicolored], IO.bool[hte.suspect]];
FOR v: Vertex _ hte.v, v.colorNext WHILE v # NIL DO
Log[" %g.%g", IO.rope[graphIDToRope[v.graph]], IO.rope[PickAName[v.names]]];
ENDLOOP;
Log["\n"];
ENDLOOP;
END;

WriteSymbolTable: PROC [graphID: ROPE, vertices: SymbolTable] =
BEGIN
WriteVertex: PROC [any: REF ANY] RETURNS [stop: BOOL] =
BEGIN
a: Alias _ NARROW[any];
v: Vertex _ NARROW[a.thing];
stop _ FALSE;
IF PickAName[v.names] # a.name THEN RETURN;
Log["(%05d)\t%05d\t%5g\t%5g\t%12g", IO.card[v.oldColor], IO.card[v.curColor], IO.bool[v.unique], IO.bool[v.suspect], IO.rope[PickAName[v.names]]];
IF v.equiv # NIL THEN Log["\t%g\n", IO.rope[PickAName[v.equiv.names]]] ELSE Log["\n"];
END;
Log["\nGraph %g vertices:\n", IO.rope[graphID]];
vertices.EnumerateIncreasing[WriteVertex];
END;

ignorable: Asserting.Assertions _ NIL;

CheckIgnore: PROC [source: Source, what: LORA] = {
IF NOT Asserting.Test[what.first, what.rest, ignorable] THEN Warn[source, "Unknown assertion %g", IO.refAny[what]];
};

AddIgnorance: PROC [spec: LORA, context: LORA] = {
FOR spec _ spec, spec.rest WHILE spec # NIL DO
WITH spec.first SELECT FROM
a: ATOM => ignorable _ Asserting.Assert[a, context, ignorable];
l: LORA => AddIgnorance[l.rest, CONS[l.first, context]];
ENDCASE => ERROR;
ENDLOOP;
};

Start: PROC = {
ignoreSpec: LORA _ NARROW[FS.StreamOpen["Compare.ignorable"].GetRefAny[]];
AddIgnorance[ignoreSpec, NIL];
};

Start[];

END.
|CompareRead.Mesa
Last Edited by: Spreitzer, June 6, 1985 2:41:23 pm PDT
AddVertex[cv];	--AM1
LinkInstance[cv];	--AM2
Κ³–

"cedar" style˜Icode™J™6K˜š
Οk	˜	Kšœ
œM˜\KšœJœœ$˜t—K˜šΠbxœœ
˜KšœNœœ#˜~Kšœ
˜K˜Kšœ
œ-˜7K˜šΟnœœ
œ˜Kš
˜šŸœœœ
œœœœ˜<Kšœ
œ˜—Kšœœ
œœ˜(Kšœœ˜/KšœHœ˜OK˜
Kšœ#œ˜4Kšœ
˜—K˜šŸœœœœ
œ
œ˜=Kšœ
œ˜#—K˜šŸ
œœ
œœœœ˜QKš
˜šŸœœœ
œ&˜Ešœ	œ
˜˜Kšœœ˜1Kšœ	œœ˜8K˜—˜Kšœœ$˜<Kšœ	œ>œœ%˜…
K˜—Kšœœ
˜—K˜—šŸœœ
œ
œ˜EKš
˜Kšœœ
˜Kšœœœ
˜K˜
šŸœœ˜Kšœ
œœ	œ
œ!œ˜]—šŸœœ˜šœ
œœ	œ
˜3šœœ
˜$šœœœ˜Kšœ]œ
Οc?œ
˜’
šœœœ˜=K˜—Kšœ$˜+—Kšœ$˜+—Kšœ˜	——šŸœœœ
œœœœ˜<Kš
˜šœœ
˜Kšœœ>˜Ešœœ˜!Kšœ	œ5˜BKšœ
œCœ	˜Yšœ˜Kš
œ˜Kšœœ
˜šœœ	œ
˜2Kš
œ˜šœœ
˜šœœœ˜š
œ˜Kš
œœ
œ1œœ˜dKšœœ<˜DKšœœ˜)šœBœ	œ
˜YKš
œ˜šœœ
˜šœœœ˜Kšœ&œ˜DKšœ&œ˜DKšœ˜ —Kšœ˜ —Kšœ
˜—Kš
œ˜—Kšœ˜$—Kšœ˜$—Kšœ
˜—šœœ
œ˜K˜!Kš
œ˜K˜
—šœ˜Kš
œ
œœœ*œ˜eK˜—K˜—K˜—Kšœœ\˜cKšœœL˜SKšœœ<˜CKšœœœ
˜+Kšœœ
˜—Kšœ
˜—šœ
œ
œœ˜3Kšœœ
œœ˜(K˜Kšœœ
˜
K˜Kšœœ˜'Kš
œ]˜]KšœHœ˜OK˜
K˜—Kšœ
˜—Kšœœ˜Kšœœ
˜Kšœœ˜+šœ	œ˜Kš
œC˜CKš
œA˜AKš
œH˜HK˜K˜—Kšœ$œ˜)Kšœ
˜—K˜šŸœœ
œ˜+K˜0Kš
œ(˜(K˜—K˜šŸœœœœ˜OKš	œœ
œœ
œ
˜ Kšœœ
˜K˜Kšœ&œ˜-Kšœœ
œ
˜)Kšœœ
œ
˜)K˜Kšœœ
œ	˜"šœœ˜$Kšœœ
œ	˜"Kš
œ˜K˜—Kšœœ
œ	˜!K˜K˜ Kšœœ˜K˜K˜—K˜š
Ÿœœœœœ˜XKšœœ
œœ
œ
œœ˜)Kšœœ
œ
œ˜K˜Kšœœ
œ
œ˜Kšœœœ˜=K˜šœœ
œ˜"Kšœœ?˜JKšœœ5˜BKšœ
˜—K˜K˜—K˜šŸœœœ˜5Kš
˜Kšœœ
œ
˜Kšœœœ
˜K˜
Kšœœœ
œ
œ
œ
˜FKšœœ˜-š
˜Kš
œ˜šŸœœ˜Kšœœ˜.Kšœ
œœ
˜"Kšœ
œœœ˜KKšœœ˜2—K˜Kšœœ
œ
˜Kš
œ"˜"šœœ
˜šœœœ˜KšœœœEœ˜wKšœ
˜—Kšœ
˜—Kš
œœ
œœ
œ
˜1Kš
œœ
œœ
œ
˜5šœœ
˜šœœœ˜Kšœœ
˜KšœTœ
 œ
˜tšœ$œ˜AšœBœ	œ
˜YKš
œ˜šŸœœ˜Kšœœ*˜=Kšœœ9œœ˜„
K˜—šœœ
˜šœœœ˜Kšœ"œ ˜FKšœ"œ ˜FKšœ
˜—Kšœ
˜—Kšœ
˜—K˜:K˜—šœœœ˜1Kšœœœ˜4šœ
œœ˜%Kšœœ'˜:Kšœ
œœ
˜"Kšœ
œœœ˜KKšœœ˜1K˜
—Kšœ
œœ˜EKšœ
œ
œ!œ>œ
œœœ˜Λ
Kš
œ˜—K˜˜Kšœ
œœ˜-Kšœ	œœ˜1Kšœœ ˜.Kšœœ-œœ˜~Kšœ œ(˜PK˜—K˜K˜"š
œ˜Kšœœ
œ@œ˜wK˜—Kšœ˜—Kšœ˜—Kšœ
˜—Kš
œœ
œ
œ
œ˜8Kšœœ
˜Kš
œ˜K˜
šœœ˜šœœ
œ˜(Kšœœ
˜šœ1œœ
˜FKšœœ˜0šœ
œ
˜Kšœœ)œœ˜gKšœœ˜Kšœ9œ˜ZKšœ
˜—Kšœ
˜—Kšœ
˜—K˜—Kšœ
˜—K˜šŸœœ$˜9Kš
œB˜BKšœœœ
˜šŸœœœ˜&šœœœ
˜&Kšœœ*˜8K˜
Kšœ
˜—K˜—šŸœœœ˜)šœœœ
˜&Kšœœ˜'šœ
œ
˜Kšœœ!˜(Kšœœ'˜.Kšœœ
˜—Kšœ
˜—K˜—šŸœœœ
œœœ˜5Kšœœ˜K˜Kšœœ
˜
K˜—š
Ÿœœœœœ˜1šœ
œ
˜Kšœœ˜Kšœœ˜Kšœœ
˜—K˜—K˜K˜K˜K˜K˜K˜K˜!š
œœ
œœ
œ˜ Kš	œsœœœœ˜Ά
K˜—K˜—K˜šŸœœ$˜:Kšœœœ˜1Kšœ
œœ˜2Kšœœ.˜MKš
œ˜Kš
œ ˜ šœœ
œ˜Kš
œ>˜>K˜—Kšœ
œ
œ˜%šœœ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜—šœEœœ
˜[Kš
œ˜šŸœœ˜Kšœœ˜3Kšœœœ˜9K˜—šœ
œ
˜šœœœ˜Kšœ!œ˜;Kšœ!œ˜;˜	Kšœœ˜Kš
œ˜š	œœœœ
˜<Kšœœœ
˜Kšœ
œœ˜#Kšœ	œœ˜'Kšœœ˜0Kš
œ
œ=œ<œœ˜»
K˜Kšœœ
œ>œœœ˜¨
Kš
œ˜Kšœ
˜—Kšœ'œ7œœ˜ž
K˜—Kšœ˜—Kšœ˜—Kšœ
˜—K˜K˜K˜K˜—K˜šŸœœ
œ˜&Kš
˜K˜Kšœœ
œ
œ
˜Kš	œœœœœ3˜lKšœ ™Kšœ ™šœœ
œ˜,K˜Kšœ
œ/˜BK˜Kšœ
˜—Kšœ
˜—K˜šŸœœ$˜1Kšœ	œœ˜,Kšœ
œ3˜CKš
œ˜šœœ
œ˜Kš
œ>˜>K˜—šœ>œœ
˜SKš
œ˜šŸœœ˜Kšœœ˜1Kšœœœ˜8K˜—šœœ
˜šœœœ˜Kšœ œ˜9Kšœ œ˜9Kšœ˜—Kšœ˜—Kšœ
˜—K˜K˜K˜—K˜šŸœœ(œ	œ
œœ˜aKšœœœ˜*K˜	Kšœœ
œ
˜ Kšœ
œ
œ
œ
˜šœ˜Kšœœ˜3Kšœœ˜1šœ˜Kšœœœ˜0KšœTœœ˜†
Kš
œ˜——Kšœœ
˜K˜—K˜šŸœœ(œ	œ
œœ˜aK˜	Kšœ
œ˜Kšœœ
œ
˜ š	œœ!œ
œ
˜LKšœœœ˜&Kšœ	œœ˜$Kšœœœ
˜šœ6œœ
˜KKš
œ˜šŸœœœ˜!Kšœœœ˜&Kšœ
œœ˜4Kš
œ˜Kš
œœBœ
œœ˜š
J˜—šœœ
˜šœœœ˜šœœœ˜/šœ˜Kšœœ
˜Kšœœ
œ˜$Kšœœ˜—K˜—Kšœœ˜—Kšœœ˜—Kšœ
˜—šœ
œ
˜Kšœœ˜6Kšœœ˜7Kšœœ˜4—Kšœ
˜—K˜—K˜šŸœœ
œœ˜DKš
œ‰
˜‰
Kšœœ
œœ˜MKš
œ˜—K˜šŸœœœ˜HKš
œ˜Kšœœ
˜šœœ
˜K˜K˜K˜K˜Kšœ
˜—K˜K˜—K˜šŸ	œœ$˜3Kšœœ˜&Kšœœ˜Kšœœ#˜2Kšœœ
œ
œ
˜Kšœœ˜š	œœœœ
˜:Kšœ
œœ˜#Kšœœ˜*Kš
œ˜Kš
œ˜šœ9œœ
˜NKš
œ˜šŸœœ˜Kšœœ!˜5Kšœœœ˜JK˜—šœœ
˜šœœœ˜˜Kšœœœ˜'Kšœœœ˜2šœœ˜!Kšœ(œ$˜RKšœ
œ
œ*œLœœ!œ˜ί
K˜—K˜—Kšœ œ˜<Kšœ œ˜<Kšœ˜—Kšœ˜—Kšœ
˜—Kš
œ(˜(K˜
Kšœ
˜—Kšœ	œ
œ
˜K˜—K˜šŸœœ
œ)˜=Kš
˜šœ
œ
˜Kšœœœ˜CKš
œ˜Kš
œ˜—Kšœœ
œ!œ˜PKšœœ
œ"œ˜QKš
œ˜Kšœ
˜—K˜šŸœœ
œ˜-šŸœœœ
œœœ˜4Kšœœ˜K˜Kšœœ˜—Kšœœ
œ
˜Kšœœ
˜Kš
œ7˜7K˜—K˜šŸœœ
œ˜+Kšœ
œœœ˜3Kšœœ
œ
œ
˜K˜—K˜šŸœœ
œ˜+Kšœ
œœœ˜3K˜—K˜š
Ÿœœ
œœ	œ˜DKšœœ
œœ
˜+Kš
œ˜—K˜šŸœœ
œœ˜Lšœœ
œ
˜Kšœ
œ
˜Kšœœ
˜Kšœœ
˜—Kš
œ˜—K˜šŸ
œœ
œ˜*Kš
œ
œœœ
œ
˜7Kšœ
œ
˜Kš
œ˜—K˜šŸœœ
œœ)˜JKš
˜Kšœœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ
˜"Kšœ
˜—K˜šŸœœ˜-Kš
˜K˜šœLœ˜gK˜%Kšœœœ
œœ
œ˜PKšœœœœ˜]šœ œœ
˜3Kšœœœ˜LKšœ
˜—K˜
Kšœ
˜—Kšœ
˜—K˜šŸœœœ˜?Kš
˜šŸœœœ
œœœ˜7Kš
˜Kšœœ˜Kšœœ
˜Kšœœ
˜
Kšœœ
œ
˜+Kšœ$œœœœœ˜’
Kš
œœ
œœ!œ˜VKšœ
˜—Kšœœ˜0Kš
œ*˜*Kšœ
˜—K˜Kšœ"œ
˜&K˜šŸœœœ˜2Kšœ
œ2œ&œ˜sK˜—K˜šŸœœœœ˜2šœœœ
˜.šœœ
˜Kšœœ8˜?Kšœœœ˜8Kšœœ
˜—Kšœ
˜—K˜—K˜šŸœœ˜Kšœœœ
œ.˜JKšœœ˜Kš
œ˜—K˜K˜K˜Kšœ
˜——…—Qζm