DIRECTORY AbSets, AMBridge, BasicTime, BiRelImplementor, BiRels, Convert, FS, Interpreter, InterpreterOps, IO, LichenDataOps, LichenDataStructure, LichenIntBasics, List, ProcessProps, Rope, RopeHash, SetBasics, SymTab;

LichenDataImpl1B: CEDAR PROGRAM
IMPORTS AbSets, AMBridge, BiRelImplementor, BiRels, Convert, FS, InterpreterOps, IO, LichenDataOps, LichenDataStructure, LichenIntBasics, List, ProcessProps, Rope, RopeHash, SetBasics, SymTab
EXPORTS LichenDataStructure
=

BEGIN OPEN IB:LichenIntBasics, IB, LichenDataStructure, LichenDataOps, Sets:AbSets;

nyet: PUBLIC ERROR ~ CODE;

Warning: PUBLIC SIGNAL [msg: ROPE, v1, v2, v3, v4, v5: REF ANY _ NIL] ~ CODE;

Error: PUBLIC ERROR [msg: ROPE, v1, v2, v3, v4, v5: REF ANY _ NIL] ~ CODE;

PartClassName: PUBLIC ARRAY PartClass OF ROPE _ [
p: "port",
w: "wire",
i: "cell instance"];

anyROPE: PUBLIC ROPE ~ R["any rope"];
anyInt: PUBLIC REF INT ~ NEW [INT _ INT.LAST-1];

DimName: ARRAY Dim2 OF ROPE = [X: "X", Y: "Y"];

genBland: NameGenerator = NEW [NameGeneratorPrivate _ [
GenerateBlandName,
NEW [NameCountsPrivate _ []]
]];

NameCounts: TYPE = REF NameCountsPrivate;
NameCountsPrivate: TYPE = RECORD [
d, cellType, port, vertex: INT _ 0
];

genSymbol: NameGenerator = NEW [NameGeneratorPrivate _ [
GenerateSymbolName,
NEW [TVNameGeneratorPrivate _ [
nc: NEW [NameCountsPrivate _ []],
symbols: LIST[SymTab.Create[]]
]]
]];

TVNameGenerator: TYPE = REF TVNameGeneratorPrivate;
TVNameGeneratorPrivate: TYPE = RECORD [
nc: NameCounts,
symbols: Interpreter.SymbolsList
];

defaultNameGen: NameGenerator ~ genSymbol;

nameStepSpace: PUBLIC SetBasics.Space ~ NEW [SetBasics.SpacePrivate _ [
Contains: StepContains,
Equal: StepEqual,
AHash: StepHash,
ACompare: StepCompare,
Print: StepPrint,
name: "name steps"
]];

steplistSpace: PUBLIC SetBasics.Space ~ NEW [SetBasics.SpacePrivate _ [
Contains: SteppyNamesContains,
Equal: SteplistEqual,
AHash: SteppyNamesHash,
ACompare: SteplistCompare,
Print: SteppyNamesPrint,
name: "steplists"
]];

steppyNameSpace: PUBLIC SetBasics.Space ~ NEW [SetBasics.SpacePrivate _ [
Contains: SteppyNamesContains,
Equal: SteppyNamesEqual,
AHash: SteppyNamesHash,
ACompare: SteppyNamesCompare,
Print: SteppyNamesPrint,
name: "steppy names"
]];

emptyRopeSet: PUBLIC Set ~ Sets.CreateEmptySet[SetBasics.ropes[TRUE]];
emptySteppySet: PUBLIC Set ~ Sets.CreateEmptySet[steppyNameSpace];
gends: PUBLIC Set ~ Sets.CreateFilter[[TestGrade, steppyNameSpace, $gend], constant];
longNames: PUBLIC Set ~ Sets.CreateFilter[[TestGrade, steppyNameSpace, $long], constant];
nonGlobals: PUBLIC Set ~ Sets.CreateFilter[[TestGrade, steppyNameSpace, $nonGlobal], constant];
powerNames: PUBLIC Set ~ Sets.CreateFilter[[TestGrade, steppyNameSpace, $power], constant];
lastRope: PUBLIC BiRel ~ BiRels.FnFromProc[Apply: ApplyLastRope, spaces: [steppyNameSpace, SetBasics.ropes[TRUE]], constant: TRUE];
vddRopes: PUBLIC Set ~ Sets.RopesMatching[["vdd*", FALSE, star]];
gndRopes: PUBLIC Set ~ Sets.RopesMatching[["gnd*", FALSE, star]];
vddNames: PUBLIC Set ~ lastRope.Image[vddRopes, rightToLeft];
gndNames: PUBLIC Set ~ lastRope.Image[gndRopes, rightToLeft];

endOfQ: PUBLIC Vertex ~ NEW [VertexPrivate[i]];

IntRefArray: TYPE ~ ARRAY [0 .. 64] OF REF INT;
intRefs: REF IntRefArray ~ NEW [IntRefArray _ ALL[NIL]];

matchingClass: BiRels.BiRelClass ~ BiRelImplementor.CreateClass[[HasPair: MatchingHasPair, Spaces: BothSNSpace, mutability: constant]];
overlapClass: BiRels.BiRelClass ~ BiRelImplementor.CreateClass[[HasPair: OverlapHasPair, Spaces: BothSNSpace, mutability: constant]];
matching: PUBLIC BiRel ~ [matchingClass, NIL];
difoverlap: PUBLIC BiRel ~ [overlapClass, NIL];

Describe: PUBLIC PROC [d: Design, subject: REF ANY, relativeTo: REF ANY _ NIL, nameGen: NameGenerator _ NIL] RETURNS [name: ROPE] = {
name _ UnparseRootedSteppyName[SteppyDescribe[d, subject, relativeTo, nameGen]];
RETURN};

SteppyDescribe: PUBLIC PROC [d: Design, subject: REF ANY, relativeTo: REF ANY _ NIL, nameGen: NameGenerator _ NIL] RETURNS [RootedSteppyName] = {
IF nameGen = NIL THEN nameGen _ defaultNameGen;
IF subject = relativeTo THEN RETURN [[noName, FALSE]] ELSE WITH subject SELECT FROM
sd: Design => {
short: ROPE _ NARROW[sd.names.AnElt[].MDA];
IF short=NIL THEN {
short _ nameGen.GenerateName[nameGen.data, subject];
IF NOT sd.names.AddA[short] THEN ERROR};
RETURN [[OSn[short], FALSE]]};
ct: CellType => {
mv: Sets.MaybeValue ~ ct.d.ctName.Lookup[goal: AV[ct], side: left, order: Sets.alleq];
short: ROPE;
IF mv.found THEN short _ NARROW[mv.it.VA] ELSE {
short _ nameGen.GenerateName[nameGen.data, subject];
d.ctName.AddNewAA[ct, short]};
IF NOT d.cellTypes.HasMemA[ct] THEN ERROR;
RETURN RSNCat[SteppyDescribe[d, d, relativeTo, nameGen], OSn[short]]};
v: Vertex => {
cct: CellType ~ d.VCct[v];
WITH relativeTo SELECT FROM
aw: Wire => {w: Wire ~ NARROW[v];
IF NOT PWIsAncestor[d, aw, w] THEN ERROR;
{msn: MaybeSteppyName ~ ScanRelativeNames[cct, w, aw, w, AcceptAnySteppyName];
IF msn.found THEN RETURN [[msn.it, FALSE]];
RETURN [[SteppyDescribe[d, subject, cct, nameGen].name, Zork[]]]}};
ENDCASE => NULL;
{mv: Sets.MaybeValue ~ cct.fullName[v.class].Lookup[goal: AV[v], side: left];
tail: SteppyName;
IF mv.found THEN tail _ VSn[mv.it] ELSE KnowVertexName[cct, v, tail _ OSn[nameGen.GenerateName[nameGen.data, subject]], FALSE];
RETURN RSNCat[SteppyDescribe[d, cct, relativeTo, nameGen], tail]}};
port: Port => {
cct: CellType ~ d.PCct[port];
WITH relativeTo SELECT FROM
ap: Port => {
IF NOT PWIsAncestor[d, ap, port] THEN ERROR;
{msn: MaybeSteppyName ~ ScanRelativeNames[cct, p, ap, port, AcceptAnySteppyName];
IF msn.found THEN RETURN [[msn.it, FALSE]];
RETURN [[SteppyDescribe[d, subject, cct, nameGen].name, Zork[]]]}};
ENDCASE => NULL;
{mv: Sets.MaybeValue ~ cct.fullName[p].Lookup[goal: AV[port], side: left];
tail: SteppyName;
IF mv.found THEN tail _ VSn[mv.it] ELSE KnowPortName[cct, port, tail _ OSn[nameGen.GenerateName[nameGen.data, subject]], FALSE];
RETURN RSNCat[SteppyDescribe[d, cct, relativeTo, nameGen], tail]}};
ENDCASE => ERROR;
};

Zork: PROC RETURNS [BOOL]
~ {IF sigz THEN Hard[]; hards _ hards + 1; RETURN [TRUE]};
sigz: BOOL _ TRUE;
Hard: SIGNAL ~ CODE;
hards: INT _ 0;

GenerateBlandName: PROC [data, subject: REF ANY] RETURNS [name: ROPE] = {
nc: NameCounts = NARROW[data];
name _ GenByCount[nc, "#", subject];
};

GenByCount: PROC [nc: NameCounts, sep: ROPE, subject: REF ANY] RETURNS [name: ROPE] = {
n: INT _ 0;
WITH subject SELECT FROM
d: Design => {n _ nc.d _ nc.d + 1; name _ "D"};
ct: CellType => {n _ nc.cellType _ nc.cellType + 1; name _ "CT"};
p: Port => {n _ nc.port _ nc.port + 1; name _ "P"};
v: Vertex => {n _ nc.vertex _ nc.vertex + 1; name _ "V"};
ENDCASE => ERROR;
name _ name.Cat[sep, Convert.RopeFromInt[n]];
};

GenerateSymbolName: PROC [data, subject: REF ANY] RETURNS [name: ROPE] = {
tvng: TVNameGenerator ~ NARROW[data];
evalHead: InterpreterOps.EvalHead ~ NARROW[List.Assoc[$EvalHead, ProcessProps.GetPropList[]]];
syms: Interpreter.SymbolsList ~ IF evalHead#NIL AND evalHead.specials#NIL THEN evalHead.specials ELSE tvng.symbols;
name _ Rope.Concat[IF syms=tvng.symbols THEN "&&" ELSE "&", GenByCount[tvng.nc, "", subject]];
TRUSTED {InterpreterOps.RegisterTV[
name: name,
tv: AMBridge.TVForReferent[WITH subject SELECT FROM
d: Design => NEW [Design _ d],
ct: CellType => NEW [CellType _ ct],
p: Port => NEW [Port _ p],
v: Vertex => NEW [Vertex _ v],
ENDCASE => ERROR],
symbolsList: syms]};
RETURN};

SteppyNameGradeCompare: PUBLIC PROC [g1, g2: SteppyNameGrade] RETURNS [SetBasics.TotalComparison] ~ {
IF g1 = g2 THEN RETURN [equal];
RETURN [SELECT TRUE FROM
g1.global<g2.global => greater,
g1.global>g2.global => less,
g1.gend<g2.gend => less,
g1.gend>g2.gend => greater,
g1.power<g2.power => greater,
g1.power>g2.power => less,
g1.nonsubs<g2.nonsubs => less,
g1.nonsubs>g2.nonsubs => greater,
g1.subs<g2.subs => less,
g1.subs>g2.subs => greater,
ENDCASE => ERROR--they were equal!--];
};

NameStepListCompare: PUBLIC PROC [l1, l2: NameStepList] RETURNS [c: SetBasics.TotalComparison] ~ {
WHILE l1#l2 DO
IF l1=NIL THEN RETURN [less];
IF l2=NIL THEN RETURN [greater];
WITH l1.first SELECT FROM
x1: REF INT => WITH l2.first SELECT FROM
x2: REF INT => IF (c _ SetBasics.CompareIntI[x1^, x2^]) # equal THEN RETURN;
x2: ROPE => RETURN [greater];
ENDCASE => ERROR;
x1: ROPE => WITH l2.first SELECT FROM
x2: ROPE => {
s1: BOOL ~ x1.Equal["gnd", FALSE] OR x1.Equal["vdd", FALSE];
s2: BOOL ~ x2.Equal["gnd", FALSE] OR x2.Equal["vdd", FALSE];
IF s1#s2 THEN RETURN [IF s1 THEN less ELSE greater];
IF (c _ SetBasics.Unbasicify[x1.Compare[x2, FALSE]]) # equal THEN RETURN;
IF (c _ SetBasics.Unbasicify[x1.Compare[x2, TRUE]]) # equal THEN RETURN};
x2: REF INT => RETURN [less];
ENDCASE => ERROR;
ENDCASE => ERROR;
l1 _ l1.rest;
l2 _ l2.rest;
ENDLOOP;
RETURN [equal]};

NameStepListEqual: PUBLIC PROC [l1, l2: NameStepList, clip1, clip2: NameStepList _ NIL] RETURNS [BOOL] ~ {
WHILE l1#clip1 AND l2#clip2 DO
WITH l1.first SELECT FROM
x: ROPE => WITH l2.first SELECT FROM
y: ROPE => IF NOT x.Equal[y] THEN RETURN [FALSE];
y: REF INT => RETURN [FALSE];
ENDCASE => ERROR;
x: REF INT => WITH l2.first SELECT FROM
y: ROPE => RETURN [FALSE];
y: REF INT => IF x^#y^ THEN RETURN [FALSE];
ENDCASE => ERROR;
ENDCASE => ERROR;
l1 _ l1.rest;
l2 _ l2.rest;
ENDLOOP;
RETURN [(l1=clip1) = (l2=clip2)]};

StepContains: PROC [data: REF ANY, v: Sets.Value] RETURNS [BOOL] ~ {
RETURN [WITH v.ra SELECT FROM
y: ROPE => TRUE,
y: REF INT => TRUE,
ENDCASE => FALSE]};

StepEqual: PROC [data: REF ANY, v1, v2: Sets.Value] RETURNS [BOOL] ~ {
WITH v1.VA SELECT FROM
x: REF INT => WITH v2.VA SELECT FROM
y: REF INT => RETURN [x^ = y^];
y: ROPE => RETURN [FALSE];
ENDCASE => ERROR;
x: ROPE => WITH v2.VA SELECT FROM
y: REF INT => RETURN [FALSE];
y: ROPE => RETURN [x.Equal[y]];
ENDCASE => ERROR;
ENDCASE => ERROR;
};

StepHash: PROC [data: REF ANY, v: Sets.Value] RETURNS [CARDINAL] ~ {
WITH v.VA SELECT FROM
x: REF INT => RETURN SetBasics.HashIntI[x^];
x: ROPE => RETURN [RopeHash.FromRope[rope: x]];
ENDCASE => ERROR;
};

StepCompare: PROC [data: REF ANY, v1, v2: Sets.Value] RETURNS [SetBasics.TotalComparison] ~ {
WITH v1.VA SELECT FROM
x: REF INT => WITH v2.VA SELECT FROM
y: REF INT => RETURN [SetBasics.CompareIntI[x^, y^]];
y: ROPE => RETURN [less];
ENDCASE => ERROR;
x: ROPE => WITH v2.VA SELECT FROM
y: REF INT => RETURN [greater];
y: ROPE => RETURN [SetBasics.Unbasicify[x.Compare[y]]];
ENDCASE => ERROR;
ENDCASE => ERROR;
};

StepPrint: PROC [data: REF ANY, v: Sets.Value, to: IO.STREAM, depth, length: INT, verbose: BOOL] ~ {
WITH v.VA SELECT FROM
x: ROPE => to.PutRope[x];
x: REF INT => to.Put[[integer[x^]]];
ENDCASE => ERROR;
RETURN};

SteppyNamesContains: PROC [data: REF ANY, v: Sets.Value] RETURNS [BOOL] ~ {
RETURN [WITH v.ra SELECT FROM
x: NameStepList => TRUE,
ENDCASE => FALSE]};

SteplistEqual: PROC [data: REF ANY, v1, v2: Sets.Value] RETURNS [BOOL] ~ {
RETURN [SteplistCompare[data, v1, v2]=equal]};

SteppyNamesEqual: PROC [data: REF ANY, v1, v2: Sets.Value] RETURNS [BOOL] ~ {
RETURN [SteppyNamesCompare[data, v1, v2]=equal]};

SteppyNamesHash: PROC [data: REF ANY, v: Sets.Value] RETURNS [hash: CARDINAL _ 0] ~ {
n: SteppyName _ VSn[v];
FOR steps: NameStepList _ n.steps, steps.rest WHILE steps#NIL DO
hash _ hash + (WITH steps.first SELECT FROM
x: ROPE => RopeHash.FromRope[x],
x: REF INT => SetBasics.HashIntI[x^],
ENDCASE => ERROR);
ENDLOOP;
RETURN};

SteplistCompare: PROC [data: REF ANY, v1, v2: Sets.Value] RETURNS [c: SetBasics.TotalComparison] ~ {
n1: SteppyName ~ VSn[v1];
n2: SteppyName ~ VSn[v2];
c _ NameStepListCompare[n1.steps, n2.steps];
RETURN};

SteppyNamesCompare: PROC [data: REF ANY, v1, v2: Sets.Value] RETURNS [c: SetBasics.TotalComparison] ~ {
n1: SteppyName ~ VSn[v1];
n2: SteppyName ~ VSn[v2];
IF (c _ SteppyNameGradeCompare[n1.grade, n2.grade])#equal THEN RETURN;
c _ NameStepListCompare[n1.steps, n2.steps];
RETURN};

SteppyNamesPrint: PROC [data: REF ANY, v: Sets.Value, to: IO.STREAM, depth, length: INT, verbose: BOOL] ~ {
name: SteppyName ~ VSn[v];
to.PutRope[UnparseSteppyName[name]];
RETURN};

TestGrade: PROC [val: Sets.Value, data: REF ANY _ NIL] RETURNS [BOOL] ~ {
sn: SteppyName ~ VSn[val];
SELECT data FROM
$gend => RETURN [sn.grade.gend];
$nonGlobal => RETURN [NOT sn.grade.global];
$long => RETURN [sn.grade.gend OR sn.grade.nonsubs>1];
$power => RETURN [sn.grade.power];
ENDCASE => ERROR};

ApplyLastRope: PROC [data: REF ANY, v: Sets.Value] RETURNS [mv: Sets.MaybeValue] ~ {
sn: SteppyName ~ VSn[v];
IF sn.grade.nonsubs = 0 THEN RETURN [Sets.noMaybe];
{lr: ROPE ~ LastRope[sn];
RETURN [[TRUE, AV[lr]]]}};

LastRope: PUBLIC PROC [sn: SteppyName] RETURNS [ROPE] ~ {
subj: ROPE _ NIL;
FOR nsl: NameStepList _ sn.steps, nsl.rest WHILE nsl#NIL DO
WITH nsl.first SELECT FROM
x: ROPE => subj _ x;
x: REF INT => NULL;
ENDCASE => ERROR;
ENDLOOP;
RETURN [subj]};

PreTails: PUBLIC PROC [tail: SteppyName] RETURNS [Set--of SteppyName--] ~ {
RETURN Sets.CreateFilter[[TestTail, steppyNameSpace, NEW [SteppyName _ tail]], constant];
};

TestTail: PROC [val: Sets.Value, data: REF ANY _ NIL] RETURNS [BOOL] ~ {
pre: SteppyName ~ VSn[val];
tail: SteppyName ~ NARROW[data, REF SteppyName]^;
IF tail.grade.subs>pre.grade.subs OR tail.grade.nonsubs>pre.grade.nonsubs THEN RETURN [FALSE];
{preSteps: NameStepList _ pre.steps;
tailSteps: NameStepList _ tail.steps;
THROUGH [0 .. (pre.grade.subs+pre.grade.nonsubs) - (tail.grade.subs+tail.grade.nonsubs) ) DO preSteps _ preSteps.rest ENDLOOP;
WHILE tailSteps#NIL DO
IF NOT nameStepSpace.SEqual[AV[tailSteps.first], AV[preSteps.first]] THEN RETURN [FALSE];
tailSteps _ tailSteps.rest;
preSteps _ preSteps.rest;
ENDLOOP;
IF preSteps#NIL THEN ERROR;
RETURN [TRUE]}};

CopyTill: PUBLIC PROC [first, afterlast: LORA] RETURNS [new: TList _ []] ~ {
FOR cur: LORA _ first, cur.rest WHILE cur#afterlast DO
this: LORA ~ LIST[cur.first];
IF new.tail=NIL THEN new.head _ this ELSE new.tail.rest _ this;
new.tail _ this;
ENDLOOP;
RETURN};

LTl: PUBLIC PROC [head: LORA] RETURNS [TList] ~ {
IF head=NIL THEN RETURN [[NIL, NIL]];
{tail: LORA _ head;
FOR tail _ tail, tail.rest WHILE tail.rest#NIL DO NULL ENDLOOP;
RETURN [[head, tail]]}};

NewInt: PUBLIC PROC [i: INT] RETURNS [REF INT] ~ {
IF i IN [0 .. 64] THEN RETURN [intRefs[i]];
RETURN [NEW [INT _ i]]};

AIName: PUBLIC PROC [act: CellType, ai: Int2] RETURNS [SteppyName] ~ {
IF act.asArray.size2[X]=1
THEN IF act.asArray.size2[Y]=1
THEN RETURN [noName]
ELSE RETURN OSn[NewInt[ai[Y]]]
ELSE IF act.asArray.size2[Y]=1
THEN RETURN OSn[NewInt[ai[X]]]
ELSE RETURN LSn[LIST[NewInt[ai[X]], NewInt[ai[Y]]]]};

ExtendName: PUBLIC PROC [fileName, defaultExtension: ROPE] RETURNS [fullFName: ROPE, cp: FS.ComponentPositions] ~ {
[fullFName, cp, ] _ FS.ExpandName[fileName];
IF defaultExtension.Length[]>0 AND cp.ext.start = cp.base.start+cp.base.length THEN {
fileName _ FS.ConstructFName[[
server: fullFName.Substr[cp.server.start, cp.server.length],
dir: fullFName.Substr[cp.dir.start, cp.dir.length],
subDirs: fullFName.Substr[cp.subDirs.start, cp.subDirs.length],
base: fullFName.Substr[cp.base.start, cp.base.length],
ext: defaultExtension,
ver: fullFName.Substr[cp.ver.start, cp.ver.length]
]];
[fullFName, cp, ] _ FS.ExpandName[fileName];
RETURN};
RETURN};

MatchingHasPair: PROC [br: BiRel, pair: BiRels.Pair] RETURNS [BOOL] ~ {
pat: SteppyNamePattern _ VSn[pair[left]];
subj: SteppyName _ VSn[pair[right]];
IF pat.grade.subs # subj.grade.subs OR pat.grade.nonsubs # subj.grade.nonsubs THEN RETURN [FALSE];
WHILE pat.steps#NIL DO
WITH pat.steps.first SELECT FROM
x: ROPE => WITH subj.steps.first SELECT FROM
y: ROPE => IF x#anyROPE AND NOT x.Equal[y] THEN RETURN [FALSE];
ENDCASE => RETURN [FALSE];
x: REF INT => WITH subj.steps.first SELECT FROM
y: REF INT => IF x#anyInt AND x^#y^ THEN RETURN [FALSE];
ENDCASE => RETURN [FALSE];
ENDCASE => ERROR;
pat.steps _ pat.steps.rest;
subj.steps _ subj.steps.rest;
ENDLOOP;
RETURN [TRUE]};

BothSNSpace: PROC [br: BiRel] RETURNS [BiRels.SpacePair]
~ {RETURN [ALL[steppyNameSpace]]};

OverlapHasPair: PROC [br: BiRel, pair: BiRels.Pair] RETURNS [BOOL] ~ {
pat1: SteppyNamePattern _ VSn[pair[left]];
pat2: SteppyNamePattern _ VSn[pair[right]];
dif: BOOL _ FALSE;
IF pat1.grade.subs # pat2.grade.subs OR pat1.grade.nonsubs # pat2.grade.nonsubs THEN RETURN [FALSE];
WHILE pat1.steps#NIL DO
WITH pat1.steps.first SELECT FROM
x: ROPE => WITH pat2.steps.first SELECT FROM
y: ROPE => 
IF x=anyROPE OR y=anyROPE THEN dif _ dif OR x#y
ELSE IF NOT x.Equal[y] THEN RETURN [FALSE];
ENDCASE => RETURN [FALSE];
x: REF INT => WITH pat2.steps.first SELECT FROM
y: REF INT =>
IF x=anyInt OR y=anyInt THEN dif _ dif OR x#y
ELSE IF x^#y^ THEN RETURN [FALSE];
ENDCASE => RETURN [FALSE];
ENDCASE => ERROR;
pat1.steps _ pat1.steps.rest;
pat2.steps _ pat2.steps.rest;
ENDLOOP;
RETURN [dif]};

PWRoot: PUBLIC PROC [d: Design, x: PW] RETURNS [PW] ~ {
DO
mv: Sets.MaybeValue ~ d.parent.ApplyA[x];
IF NOT mv.found THEN RETURN [x];
x _ mv.it.VA;
ENDLOOP;
};

CiCtr: PUBLIC PROC [ci: CellInstance, ict: CellType] RETURNS [Int2]
~ {RETURN TransOffPos[VXfm[ict.d.ciXfm.ApplyA[ci].Val], ci.offset, Range2Mid[ict.bbox]]};

Start: PROC ~ {
FOR i: INT IN [0 .. 64] DO intRefs[i] _ NEW [INT _ i] ENDLOOP;
RETURN};

Start[];

END.
\LichenDataImpl1B.Mesa
Last tweaked by Mike Spreitzer on July 15, 1988 4:29:07 pm PDT
Κ)–

"cedar" style˜
code™K™>—K˜KšΟk	œAœœm˜Ϊ
K˜šΟnœœ
˜Kšœ6œœl˜Ώ
Kšœ˜K˜
—K˜Kš
œ
œ
œœ&žœ˜SK˜Kšœœ
œœ
˜K˜Kšžœœ
œœœ
œœœ
˜MK˜Kšžœœ
œœœ
œœœ
˜JK˜š
ž
œœ
œœ
œ˜1K˜
K˜
K˜—K˜Kšœ	œ
œ˜%Kšœœ
œ
œœœœ
œ˜0K˜Kšžœœœ
œ˜/K˜šœœ˜7K˜Kšœ˜K˜—K˜Kšœœœ˜)šœœœ˜"Kšœœ˜"K˜—K˜šœœ˜8K˜šœ˜Kšœœ˜!Kšœ	œ˜K˜—K˜—K˜Kšœœœ˜3šœœœ˜'K˜Kš
œ ˜ K˜—K˜Kš
œ*˜*K˜šœœœ˜GKšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜K•StartOfExpansion5[key: 
REF ANY, val: 
REF ANY, aList: 
List.AList]š
œ˜Kš
œ˜—K˜šœœœ˜GKšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜Kš
œ˜—K˜šœœœ˜IKšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜Kš
œ˜—K˜Kšœœ+œ˜FKšœœ,˜BKšœœH˜UKšœœH˜YKšœœM˜_KšœœI˜[Kš	œ
œžœ;œœ˜ƒ
Kšœ
œ#œ	˜AKšœ
œ#œ	˜AKšœ
œ-˜=Kšœ
œ-˜=K˜Kšœœ
œ˜/K˜Kšœ
œœœ
œ
œ
˜/Kš	œ	œœœ
œ˜8K˜KšœAžœžœ&˜‡
Kšœ@žœžœ&˜…
Kšœ
œœ˜.Kšœœœ˜/K˜šžœœ
œœ
œœ
œœœœœ˜…
Kš
œP˜PKšœ˜—K˜šžœœ
œœ
œœ
œœœœ˜‘
Kšœœ
œ˜/šœœ
œœœ
œ	œ
˜S˜Kšœœœœ˜+šœœ
œ˜K˜4Kšœ
œœ
œ˜(—Kšœœ˜—˜Kšœ/œ%˜VKšœœ
˜š
œ
œ	œœœ˜0K˜4Kš
œ˜—Kšœ
œœ
œ
˜*Kšœ@˜F—˜K˜šœœ
˜šœœ˜!Kšœ
œœ
œ
˜)Kš
œN˜NKšœœ
œœ˜+Kšœ=˜C—Kšœœ
˜—Kšœ:œ˜MK˜Kšœ
œœQœ˜Kšœ=˜C—˜K˜šœœ
˜˜
Kšœ
œœ
œ
˜,Kš
œQ˜QKšœœ
œœ˜+Kšœ=˜C—Kšœœ
˜—Kšœ4œ˜JK˜Kšœ
œœRœ˜€
Kšœ=˜C—Kšœœ
˜—Kš
œ˜—K˜šžœœ
œœ
˜Kš	œœœœœ˜:Kšœœœ
˜Kšžœœœ
˜Kšœœ˜—K˜šžœœœ
œœœ˜IKšœœ˜K˜$K˜—K˜šž
œœœœ
œœœ˜WKšœœ˜šœ	œ
˜K˜/K˜AK˜3K˜9Kšœœ
˜—K˜-K˜—K˜šžœœœ
œœœ˜JKšœœ˜%Kšœ$œ4˜^Kš
œ œ
œ
œœ
œœ˜sKšœœœœ(˜^šœ˜#K˜šœœ	œ
˜3Kšœ
œ˜Kšœœ˜$Kšœœ˜Kšœ
œ˜Kšœœ˜—Kš
œ˜—Kšœ˜—K˜šžœœ
œœ ˜eKšœ	œ
œ	˜šœœ
œ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ˜KšœΟcœ˜&—K˜—K˜šžœœ
œœ#˜bšœ˜Kšœœ
œ
œ˜Kšœœ
œ
œ˜ šœ
œ
˜š
œœ
œœ
œ
˜(Kšœœ
œœ/œ
œ
˜LKšœœœ˜Kšœœ
˜—šœœœ
œ
˜%šœœ˜
Kš	œœœœœ˜<Kš	œœœœœ˜<Kšœœ
œœœœ
˜4Kšœ*œœ
œ
˜IKšœ*œœ
œ˜I—Kšœœ
œœ˜Kšœœ
˜—Kšœœ
˜—K˜
K˜
Kšœ
˜—Kšœ
˜—K˜šžœœ
œ5œœœ˜jšœ
œ
˜šœ
œ
˜šœœœ
œ
˜$Kš
œœœ
œœ
œœ˜1Kš	œœ
œœœ˜Kšœœ
˜—š
œœ
œœ
œ
˜'Kšœœœœ˜Kš
œœ
œœœ
œœ˜+Kšœœ
˜—Kšœœ
˜—K˜
K˜
Kšœ
˜—Kšœ˜"—K˜šžœœœ
œœœ˜Dšœœœ
˜Kšœœœ
˜Kšœœ
œœ
˜Kšœœ˜—K˜—šž	œœœ
œœœ˜Fšœœ
œ
˜šœœ
œœœ
œ
˜$Kšœœ
œœ˜Kšœœœœ˜Kšœœ
˜—š
œœœœ
œ
˜!Kš	œœ
œœœ˜Kšœœœ˜Kšœœ
˜—Kšœœ
˜—K˜—K˜šžœœœ
œœœ˜Dšœœ
œ
˜Kšœœ
œœ˜,K–q[rope: 
ROPE, case: 
BOOL _ TRUE, start: 
INT _ 0, len: 
INT _ 2147483647, seed: 
CARDINAL _ 75267B (31415)]šœœœ˜/Kšœœ
˜—K˜—K˜š
žœœœ
œœ ˜]šœœ
œ
˜šœœ
œœœ
œ
˜$Kšœœ
œœ!˜5Kšœœœ˜Kšœœ
˜—š
œœœœ
œ
˜!Kšœœ
œœ˜Kšœœœ&˜7Kšœœ
˜—Kšœœ
˜—K˜—K˜šž	œœœ
œœ
œœœ˜dšœœ
œ
˜Kšœœ˜Kšœœ
œ˜$Kšœœ
˜—Kšœ˜—K˜šžœœœ
œœœ˜Kšœœœ
˜Kšœœ
˜Kšœœ˜——K˜šž
œœœ
œœœ˜JKšœ(˜.—K˜šžœœœ
œœœ˜MKšœ+˜1—K˜šžœœœ
œœœ	˜UKš
œ˜šœ+œœ
˜@šœœ
œ
˜+Kšœœ˜ Kšœœ
œ˜%Kšœœ˜—Kšœ
˜—Kšœ˜—K˜š
žœœœ
œœ#˜dK˜K˜Kš
œ,˜,Kšœ˜—K˜š
žœœœ
œœ#˜gK˜K˜Kšœ8œ
œ
˜FKš
œ,˜,Kšœ˜—K˜šžœœœ
œœ
œœœ˜kJš
œ˜Jš
œ$˜$Kšœ˜—K˜šž	œœœ
œœœœ˜IK˜šœ˜Kšœ	œ˜ Kšœœœ˜+Kšœ	œœ˜6Kšœ
œ˜"Kšœœ˜——K˜š
ž
œœœ
œœ˜TK˜Kšœœ
œ˜3Kšœœ˜Kšœœœ	˜—K˜š
žœœ
œœœ˜9Kšœœœ
˜šœ(œœ
˜;šœœ
˜Kšœœ
˜Kšœœ
œœ
˜Kšœœ
˜—Kšœ
˜—Kšœ	˜—K˜š
žœœ
œœŸœ˜KKšœ/œ!˜YK˜—K˜šžœœœ
œœœœ˜HK˜Kšœœœ˜1Kš
œ œ&œ
œœ˜^K˜$K˜%KšœSœœ
˜~šœœ
˜Kšœ
œœœœ
œœ˜YKš
œ˜Kš
œ˜Kšœ
˜—Kšœ
œ
œ
œ
˜Kšœœ˜—K˜š
žœœ
œœœ˜Lšœœœ˜6Kšœœœ˜Kšœ
œ
œœ˜?K˜Kšœ
˜—Kšœ˜—K˜š
žœœ
œœœ˜1Kšœœ
œ
œœœ˜%Kšœœ˜Kšœœœ
œ
œ
œ
˜?Kšœ˜—K˜šžœœ
œœœœ
œ˜2Kšœœœ
œ˜+Kšœœœ˜—K˜šžœœ
œœ˜Fšœ˜šœ
œ˜Kšœ
œ	˜Kšœ
œ˜—šœ
œ˜Kšœ
œ˜Kšœ
œœ!˜5———K˜šž
œœ
œœœ
œœ˜sKšœœ˜,šœœ-œ˜Ušœœ˜Kš
œ<˜<Kš
œ3˜3Kš
œ?˜?Kš
œ6˜6Kš
œ˜Kš
œ2˜2Kš
œ˜—Kšœœ˜,Kšœ˜—Kšœ˜—K˜šžœœ œœ˜GK˜)K˜$Kš
œ"œ(œ
œœ˜bšœœ
˜šœœ
˜ šœœœœ
˜,Kšœœœœ
œœ
œœ˜?Kšœœœ˜—š
œœ
œœœ
˜/Kšœœ
œœ
œœ
œœ˜8Kšœœœ˜—Kšœœ
˜—K˜K˜Kšœ
˜—Kšœœ˜—K˜šžœœ
œ˜8Kšœœœ˜"—K˜šžœœ œœ˜FK˜*K˜+Kšœœœ
˜Kš
œ#œ)œ
œœ˜dšœœ
˜šœœ
˜!šœœœœ
˜,šœœ˜Kšœœœœ˜/Kšœ
œ
œœ
œœ˜+—Kšœœœ˜—š
œœ
œœœ
˜/šœœ
œ˜
Kšœ
œ
œœ˜-Kš
œ
œœ
œœ˜"—Kšœœœ˜—Kšœœ
˜—Kš
œ˜K˜Kšœ
˜—Kšœ˜—K˜šžœœ
œœœœ˜7š
˜Kš
œ)˜)Kšœ
œ
œ
œ˜ Kšœ
œ
˜
Kšœ
˜—K˜—K˜šžœœ#œ˜CKšœœP˜Y—K˜šžœœ˜Kšœœ
œœœœœ
˜>Kšœ˜—K˜K˜K˜Kšœ
˜—…—Bϊ\