DIRECTORY AbSets, AMBridge, AMTypes, BasicTime, BiRelBasics, BiRels, IntStuff, IO, LichenDataOps, LichenDataStructure, LichenIntBasics, PrintTV, Rope, SetBasics;

LichenWireMunging: CEDAR PROGRAM
IMPORTS AbSets, BiRelBasics, BiRels, IntStuff, LichenDataOps, LichenDataStructure, SetBasics
EXPORTS LichenDataOps
=

BEGIN OPEN IS:IntStuff, LIB:LichenIntBasics, LIB, LichenDataStructure, LichenDataOps, Sets:AbSets;

steppyNameFunctions: Sets.Space ~ BiRelBasics.CreateBiRelSpace[ALL[steppyNameSpace]];

FixInterleavingsOfArray: PUBLIC PROC [act: CellType] ~ {
a: Array ~ act.asArray;
d: Design ~ act.d;
ect: CellType ~ act.EltType[];
wire2ap: InvFn --DumbWire _ array Port-- ~ a.dumrep.apToWire.Invert;
CheckEltPort: PROC [epv: Sets.Value] RETURNS [BOOL] ~ {
ep: Port ~ NARROW[epv.VA];
cai2dw: Fn--composite array index _ DumbWire-- ~ BiRels.VB[a.dumrep.epToWire.Apply[epv].Val];
cais: Set--of composite array index-- ~ cai2dw.SetOn[left];
IF cais.Size[IS.two].Compare[IS.two]<equal THEN RETURN [FALSE];
{cai0: CompositeArrayIndex ~ cais.First[].MI;
cai1: CompositeArrayIndex ~ cais.Next[IV[cai0]].MI;
cainm1: CompositeArrayIndex ~ cais.Last[].MI;
caid: CompositeArrayIndex ~ cai1 - cai0;
estCais: Set--of int-- ~ Sets.Mods[[cai0, cainm1], caid, cai0];
IF NOT cais.Equal[estCais] THEN RETURN [FALSE];
{n: NATURAL ~ (cainm1 - cai0) / caid + 1;
cai2ap: Fn--cai _ array port-- ~ CreateVector[bounds: cais.GetIntBounds, oneToOne: TRUE, rightSpace: d.eSpace];
hads: BiRels.HadSetPair ~ cai2ap.AddSet[ cai2dw.Compose[wire2ap] ];
IF hads # ALL[[same: FALSE, different: FALSE, none: TRUE]] THEN RETURN [FALSE];
IF cai2ap.Size.EN # n THEN RETURN [FALSE];
{cPorts: Set ~ cai2ap.SetOn[right];
pPorts: Set ~ d.parent.Image[cPorts].CreateHashCopy[];
IF pPorts.Size[IS.two].Compare[IS.two] < equal THEN RETURN [FALSE];
IF NOT d.parent.Image[pPorts, rightToLeft].Equal[cPorts] THEN RETURN [FALSE];
{apKids: Seq ~ cai2ap .Shift[IS.IE[-INT[cai0]]] .CreateVectorCopy[];
[] _ RestructurePorts[act, pPorts, apKids];
RETURN [FALSE]}}}}};
IF d.cct[p].ScanMapping[AV[ect], CheckEltPort, rightToLeft].found THEN ERROR;
RETURN};

RestructurePorts: PROC [ct: CellType, ports: Set--of Port--, newKids: Seq--of Port--] RETURNS [new: Port] ~ {
d: Design ~ ct.d;
nPorts: LNAT ~ ports.Size[].EN;
FixWire: PROC [wv: Sets.Value] RETURNS [BOOL] ~ {
w: Wire ~ NARROW[wv.VA];
[] _ w.conns.DeleteSet[ports];
RETURN [FALSE]};
FixInst: PROC [civ: Sets.Value] RETURNS [BOOL] ~ {
ci: CellInstance ~ NARROW[civ.VA];
cct: CellType ~ d.CiCct[ci];
wires: Set--of Wire-- ~ Sets.CreateHashSet[d.eSpace];
someBad: BOOL _ FALSE;
ProjectPort: PROC [pv: Sets.Value] RETURNS [BOOL] ~ {
wmv: Sets.MaybeValue ~ ci.conns.Apply[pv];
IF NOT wmv.found THEN RETURN [FALSE];
[] _ wires.AddElt[wmv.it];
{w: Wire ~ NARROW[wmv.it.VA];
someBad _ someBad OR NOT d.Top[w];
IF d.Atomic[w] THEN ERROR --atomic wire connected to composite port--;
RETURN [FALSE]}};
IF ports.Scan[ProjectPort].found THEN ERROR;
IF wires.Size[].EN=nPorts AND NOT someBad THEN {
kidWires: Seq ~ newKids.Compose[ci.conns, [TRUE, FALSE]];
[] _ RestructureWires[cct, wires, kidWires];
ct _ ct}
ELSE {
IF wires.Scan[FixWire].found THEN ERROR;
[] _ ci.conns.DeleteSet[ports]};
RETURN [FALSE]};
IF NOT newKids.SetOn[right].Equal[d.parent.Image[ports, rightToLeft]] THEN ERROR;
IF NOT ports.Intersection[d.isntTop].Empty THEN ERROR;
IF NOT ports.Intersection[d.isAtomic].Empty THEN ERROR;
IF NOT ct.CtArrays.Empty THEN ERROR--not implemented case--;
{parentNames: Set ~ FixNames[ct, p, ports, newKids];
DeletePorts[ct, ports, FALSE, FALSE];
new _ CreatePort[ct, parentNames, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, newKids];
IF d.ciType.ScanMapping[AV[ct], FixInst, rightToLeft].found THEN ERROR;
RETURN}};

RestructureWires: PROC [ct: CellType, wires: Set, newKids: Seq] RETURNS [new: Wire] ~ {
d: Design ~ ct.d;
nParents: LNAT ~ wires.Size[].EN;
nKids: LNAT ~ newKids.Size[].EN;
IF NOT newKids.SetOn[right].Equal[d.parent.Image[wires, rightToLeft]] THEN ERROR;
IF NOT wires.Intersection[d.isntTop].Empty THEN ERROR;
IF NOT wires.Intersection[d.isAtomic].Empty THEN ERROR;
IF ct.asArray#NIL THEN ERROR;
IF ct.asu=NIL THEN ERROR;
{ports: Set--of Wire-- ~ ct.asu.exports.Image[wires, rightToLeft].CreateHashCopy[];
parentNames: Set ~ FixNames[ct, w, wires, newKids];
DeleteWires[ct, wires, TRUE];
new _ CreateWire[ct, parentNames, TRUE, TRUE, TRUE, newKids];
IF ports.Size[].EN=nParents AND ports.Intersection[d.isntTop].Empty THEN {
rawKids: BiRel ~ newKids.Compose[ct.asu.exports.Invert];
kidPorts: Seq ~ CreateSeq[len: rawKids.Size.EN, oneToOne: TRUE, rightSpace: d.eSpace];
had: BiRels.HadSetPair ~ kidPorts.AddSet[rawKids];
IF had=ALL[[same: FALSE, different: FALSE, none: TRUE]] AND kidPorts.Size.EN = nKids THEN {
[] _ RestructurePorts[ct, ports, kidPorts];
ct _ ct;
}
ELSE new _ new;
ct _ ct}
ELSE new _ new;
RETURN}};

FixNames: PROC [ct: CellType, class: PWClass, olds: Set--of PW--, newKids: Seq] RETURNS [parentNames: Set--of SteppyName--] ~ {
n: NATURAL ~ newKids.Size.EN;
p2r: Fn--pattern _ OTO(old name f new)-- ~ BiRels.CreateHashFn[spaces: [steppyNameSpace, steppyNameFunctions], invable: FALSE];
p2n: Fn--pattern _ parent name-- ~ BiRels.CreateHashFn[ALL[steppyNameSpace], FALSE];
pats: Set--of SteppyNamePattern-- ~ p2r.SetOn[left];
k0: PW ~ newKids.ApplyI[0].MA;
k1: PW ~ newKids.ApplyI[1].MA;
ns0: Set ~ ct.PartNames[class, k0];
ns1: Set ~ ct.PartNames[class, k1];
Start0: PROC [v0: Sets.Value] RETURNS [BOOL] ~ {
n0: SteppyName ~ VSn[v0];
len: NATURAL ~ n0.grade.nonsubs+n0.grade.subs;
IF n0.grade.nonsubs < 1 OR n0.grade.subs < 1 OR len < 3 THEN RETURN [FALSE];
{tail0: NameStepList ~ n0.SNthTail[len-1].steps;
last0: REF INT ~ WITH tail0.first SELECT FROM
x: REF INT => x, ENDCASE => NIL;
Start1: PROC [v1: Sets.Value] RETURNS [BOOL] ~ {
n1: SteppyName ~ VSn[v1];
IF n1.grade # n0.grade THEN RETURN [FALSE];
{tail1: NameStepList ~ n1.SNthTail[len-1].steps;
last1: REF INT ~ WITH tail1.first SELECT FROM
x: REF INT => x, ENDCASE => NIL;
IF last1=NIL THEN RETURN [FALSE];
{sameLast: BOOL ~ last0^ = last1^;
d0: NameStepList _ n0.steps;
d1: NameStepList _ n1.steps;
WHILE d0 # tail0 AND nameStepSpace.SEqual[AV[d0.first], AV[d1.first]] DO
d0 _ d0.rest; d1 _ d1.rest; ENDLOOP;
IF d0#tail0 THEN {
IF NOT NameStepListEqual[d0.rest, d1.rest, tail0, tail1] THEN RETURN [FALSE];
ConsiderPattern[CopyTill[n0.steps, d0], CopyTill[d0.rest, tail0]];
}
ELSE IF NOT sameLast THEN {ct _ ct;
FOR l0: NameStepList _ n0.steps, l0.rest WHILE l0 # tail0 DO
ConsiderPattern[CopyTill[n0.steps, l0], CopyTill[l0.rest, tail0]];
ENDLOOP;
ct _ ct}
ELSE ct _ ct;
RETURN [FALSE]}}};
IF last0=NIL THEN RETURN [FALSE];
IF ns1.Scan[Start1].found THEN ERROR;
RETURN [FALSE]}};
ConsiderPattern: PROC [pre, post: TList] ~ {
base: SteppyName ~ LSn[CopyTill[pre.head, NIL].Cat[CopyTill[post.head, NIL]].head];
pat: SteppyNamePattern ~ LSn[Cat[Append[pre, anyROPE], Append[post, anyInt]].head];
r: OneToOne--old name f new-- ~ BiRels.CreateHashOTO[ALL[steppyNameSpace]];
pms: Set ~ matching.Mapping[SnV[pat]];
FOR i: NATURAL IN [0 .. n) DO
ki: PW ~ newKids.ApplyI[i].MA;
matchingNames: Set ~ pms.Intersection[ct.PartNames[class, ki]];
old: SteppyName ~ VSn[matchingNames.TheElt[!SetBasics.Error => IF msg=Sets.notASingleton THEN GOTO Bad]];
new: SteppyName ~ base.SNAppend[NewInt[i]];
had: BiRels.HadPair ~ r.AddPair[[SnV[old], SnV[new]]];
IF had # ALL[none] THEN GOTO Bad;
ENDLOOP;
{had: BiRels.Had ~ p2r.AddPair[[SnV[pat], r.BV[]], BiRels.addIfNew] [leftToRight];
IF had = different THEN ERROR--if it's the same pattern, it's got to have the same r--;
IF p2n.AddPair[[SnV[pat], SnV[base]]][leftToRight] = different THEN ERROR;
};RETURN;
EXITS Bad => ct _ ct};
RemoveInferiors: PROC [pv: Sets.Value] RETURNS [BOOL] ~ {
IF pats.HasMember[pv] THEN {
losers: Set ~ difoverlap.Mapping[pv].Intersection[pats].CreateHashCopy[];
[] _ p2r.DeleteSet[losers];
[] _ p2n.DeleteSet[losers]};
RETURN [FALSE]};
IF ns0.Scan[Start0].found THEN ERROR;
IF pats.Size.EN > 1 THEN nontrivs _ nontrivs + 1;
IF pats.Scan[RemoveInferiors, patorder].found THEN ERROR;
IF pats.Empty THEN {SIGNAL Hard; nhards _ nhards + 1}
ELSE FOR i: NAT IN [0 .. n) DO
ki: PW ~ newKids.ApplyI[i].MA;
ri: REF INT ~ NewInt[i];
PerRepl: PROC [pair: BiRels.Pair] RETURNS [BOOL] ~ {
pat: SteppyName ~ VSn[pair[left]];
r: OneToOne--old name f new-- ~ BiRels.VB[pair[right]];
parentName: SteppyName ~ VSn[p2n.Apply[pair[left]].Val];
new: SteppyName ~ SNAppend[parentName, ri];
old: SteppyName ~ VSn[r.Apply[SnV[new], rightToLeft].Val];
ReplaceDescendantsName[ct, ki, old, new];
RETURN [FALSE]};
IF p2r.Scan[PerRepl].found THEN ERROR;
ENDLOOP;
RETURN [p2n.SetOn[right]]};
sighard: BOOL _ TRUE;
nhards, nontrivs: INT _ 0;
Hard: SIGNAL ~ CODE;

patorder: Sets.Order ~ [ComparePats, TRUE, FALSE, NIL];

ComparePats: PROC [data: REF ANY, v1, v2: Sets.Value] RETURNS [SetBasics.PartialComparison] ~ {
l1: NameStepList _ VSn[v1].steps;
l2: NameStepList _ VSn[v2].steps;
WHILE l1#NIL AND l2#NIL DO
e1: BOOL ~ l1.first=anyROPE;
e2: BOOL ~ l2.first=anyROPE;
IF e1#e2 THEN RETURN [IF e2 THEN less ELSE greater];
IF e1 THEN RETURN [equal];
l1 _ l1.rest;
l2 _ l2.rest;
ENDLOOP;
ERROR};

END.
^LichenWireMunging.Mesa
Last tweaked by Mike Spreitzer on August 3, 1988 3:29:04 pm PDT
Κ[–

"cedar" style˜
code™Kš
œ?™?—K˜KšΟk	œFœP˜‘
K˜šΟnœœ
˜ KšœU˜\Kšœ˜K˜
—K˜Kšœ
œ
œœœ&žœ˜bK˜Kšœ?œ˜UK˜šžœœ
œ˜8K˜K˜Kš
œ˜KšœΟcœ˜Dšžœœœœ˜7Kšœœœ˜Kšœ
ŸΠcm
Ÿœ
œ#˜]Kšœ	Ÿœ˜;Kšœœœœ
œœ˜?Kšœ*œ
˜-Kšœ&œœ
˜3Kšœ*œ
˜-KšœΟg
œ$˜(KšœŸ
œ ‘
œ˜?Kš
œ
œœ
œœ˜/Kšœœ‘
œ˜)Kšœ
Ÿ 
Ÿ
œ5œ˜oKš
œC˜CKšœœœ
œœœ
œœ˜OKš
œ
œœ
œœ˜*Kš
œ#˜#Kš
œ6˜6Kšœ
œœœ
œœ˜CKš
œ
œ3œ
œœ˜MKšœœ
œœ˜DKš
œ+˜+Kšœœ˜—Kšœœ(œ
œ
˜MKšœ˜—K˜š
žœœŸœŸœœ˜mK˜Kšœœœ
˜šžœœœœ˜1Kšœ
œœ˜Kš
œ˜Kšœœ˜—šžœœœœ˜2Kšœœœ˜"K˜Kšœ
Ÿœ ˜5Kšœ	œœ
˜šžœœœœ˜5K˜*Kš
œ
œœ
œœ˜%K˜Kšœœœ˜Kšœœ
œ
˜"Kšœ
œ
œ
Ÿ+œ
˜FKšœœ˜—Kšœœ
œ
˜,š
œœœ
œ	œ˜0Kšœ+œœ˜9Kš
œ,˜,K˜—šœ˜Kšœœ
œ
˜(Kš
œ ˜ —Kšœœ˜—Kšœ
œ@œ
œ
˜QKšœ
œ%œ
œ
˜6Kšœ
œ&œ
œ
˜7Kš	œ
œœ
Ÿœ
˜<Kš
œ4˜4Kšœœœ˜%Kšœ"œœœœœœœ˜YKšœœ"œ
œ
˜GKšœ˜	—K˜šžœœ*œ˜WK˜Kšœ
œœ
˜!Kšœœœ
˜ Kšœ
œ@œ
œ
˜QKšœ
œ%œ
œ
˜6Kšœ
œ&œ
œ
˜7Kšœœ
œ
œ
˜Kšœœ
œ
œ
˜KšœŸœ=˜SKš
œ3˜3Kšœœ˜Kšœ"œœœ˜=šœœ
œ%œ˜JKš
œ8˜8Kšœ,œœ˜VKš
œ2˜2šœœœ
œœœœ	œ˜[Kš
œ+˜+K˜K˜
—Kšœ˜K˜—Kšœ˜Kšœ˜	—K˜š
žœœ)Ÿ	œœŸœ˜Kšœœœ
˜Kš	œŸ
 
Ÿ 
ŸœPœ˜Kš	œŸ
 
Ÿœœœ˜TKšœ	Ÿœ˜4Kšœœœ
˜Kšœœœ
˜K˜#K˜#šžœœœœ˜0K˜Kšœœ"˜.Kšœœœ	œ
œœ˜LKš
œ0˜0š
œœ
œœ
œ
˜-Kš	œœ
œœœ
˜ —šžœœœœ˜0K˜Kšœœ
œœ˜+Kš
œ0˜0š
œœ
œœ
œ
˜-Kš	œœ
œœœ
˜ —Kš
œœ
œ
œœ˜!Kšœœ˜"K˜K˜š	œœœœ˜HKšœœ
˜$—šœ
œ˜Kš
œ
œ3œ
œœ˜MK˜BK˜
—šœ
œ
œ
œ
˜#šœ&œ˜<Kš
œB˜BKšœ
˜—K˜—Kšœ	˜
Kšœœ˜—Kš
œœ
œ
œœ˜!Kšœœ
œ
˜%Kšœœ˜—šžœœ˜,Kšœ*œœ	˜SKš
œS˜SKšœŸ 
Ÿœœ˜KK˜&šœœ
œ
˜Kšœœœ
˜K˜?Kšœ?œœ
œ˜iK˜+K˜6Kšœœœ
œ˜!Kšœ
˜—Kšœ,œ$˜RKšœœ
Ÿ9œ
˜WKšœ=œ
œ
˜JKšœœ
˜	Kšœ˜—šžœœœœ˜9šœœ˜Kš
œI˜IKš
œ˜K˜—Kšœœ˜—Kšœœ
œ
˜%Kšœœœ˜1Kšœ,œ
œ
˜9Kšœœœ˜5š	œ
œœ
œ
˜Kšœœœ
˜Kšœœ
œ
˜šžœœœœ˜4K˜"KšœŸ 
Ÿœ
œ˜7K˜8K˜+K˜:Kš
œ)˜)Kšœœ˜—Kšœœ
œ
˜&Kšœ
˜—Kšœ˜Kšœ	œœ
˜Kšœœ˜Kšžœœœ
˜—K˜Kšœ%œœœ˜7K˜š
žœœœ
œœ"˜_K˜!K˜!š	œœ
œœ
˜Kšœœ˜Kšœœ˜Kšœœ
œœœœ
˜4Kšœœ
œ	˜K˜
K˜
Kšœ
˜—Kšœ˜—K˜Kšœ
˜—…—#¦/_