[Pixel]<DATools7.0>Lichen2>LichenFlatGroup2.Mesa!3

LichenFlatGroup2.Mesa

Last tweaked by Mike Spreitzer on April 17, 1989 11:30:17 am PDT

DIRECTORY AbSets, BiRelBasics, BiRels, IntStuff, LichenArrayPrivate, LichenDataOps, LichenDataStructure, LichenFlatPrivate, LichenIntBasics, Rope, SetBasics;

LichenFlatGroup2: CEDAR PROGRAM

IMPORTS AbSets, BiRels, LichenDataOps, LichenDataStructure, LichenFlatPrivate, LichenIntBasics, Rope, SetBasics

EXPORTS LichenDataOps, LichenFlatPrivate

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

ExpandType: PUBLIC PROC [d: Design, ct: CellType] RETURNS [newCis: Set] ~ {

ExpInst: PROC [civ: Sets.Value] RETURNS [BOOL] ~ {

ci: CellInstance ~ NARROW[civ.VA];

ciWas, wireWas: OneToOne;

[ciWas, wireWas] ← ExpandInstance[d, ci];

[] ← newCis.AddSet[ciWas.SetOn[left]];

RETURN [FALSE]};

IF d.arrayElt.HasMapA[ct, rightToLeft] THEN ERROR;

newCis ← Sets.CreateHashSet[d.eSpace];

IF ct.asArray#NIL AND ct.asu=NIL THEN UnorganizeArray[ct];

IF d.ciType.ScanMapping[AV[ct], ExpInst, rightToLeft].found THEN ERROR;

RETURN};

ExpandDesign: PUBLIC PROC [d: Design, cts: Set--of CellType-- ← nilSet, except: CellType ← NIL] ~ {

DisorgCT: PROC [ctv: Sets.Value] RETURNS [BOOL] ~ {

ct: CellType ~ NARROW[ctv.VA];

IF ct#except AND ct.asArray#NIL AND ct.asu=NIL THEN UnorganizeArray[ct];

RETURN [FALSE]};

PerCT: PROC [ctv: Sets.Value] RETURNS [BOOL] ~ {

ct: CellType ~ NARROW[ctv.VA];

IF ct=d.root OR ct=except THEN RETURN [FALSE];

IF ct.asu#NIL OR ct.asArray#NIL THEN [] ← ExpandType[d, ct];

IF d.cellTypes.HasMember[ctv] AND ct.Unused[] THEN DeleteCellType[ct, FALSE, NIL];

RETURN [FALSE]};

IF cts=nilSet THEN cts ← d.cellTypes;

IF d.arrayElt.ScanImage[cts, DisorgCT, rightToLeft].found THEN ERROR;

status^ ← [];

IF cts.Scan[PerCT].found THEN ERROR;

RETURN};

RaiseGCs: PUBLIC PROC [d: Design, gcs: Set--of CellInstance--] RETURNS [newCis: Set--of CellInstance--] ~ {

from, to: CellType;

[from, to] ← SplitUnorganized[d, gcs];

RETURN ExpandType[d, to]};

LowerKidsOnce: PUBLIC PROC [d: Design, kids: Set--of CellInstance--, sib: CellInstance] RETURNS [loweredCis: Set--of CellInstance--] ~ {

intoT: CellType ~ d.CiT[sib];

tempT: CellType; tempI: CellInstance;

[tempT, tempI] ← GroupInstancesToNewCT[d, kids, "temp", emptyRopeSet];

{ciWas: OneToOne--kept é lost-- ~ MergeUnorganized[intoT, tempT, BiRels.CreateSingleton[[AV[sib], AV[tempI]], ALL[d.eSpace]]].ciWas;

loweredCis ← ciWas.SetOn[left];

RETURN}};

SplitUnorganized: PUBLIC PROC [d: Design, take: Set--of CellInstance--] RETURNS [from, to: CellType] ~ {

from ← NARROW[d.cct[i].Image[take].TheElt.VA];

IF NOT d.arrayElt.MappingEmpty[AV[from], rightToLeft] THEN ERROR nyet;

{takename: SteppyName ~ VSn[from.fullName[i].Image[take].First[].Val];

fix: OneToOne ~ BiRels.CreateRopeCat[Rope.Cat["-", takename.UnparseSteppyName], suffix];

to ← CreateCellType[d, unorganized, fix.Image[d.CTNames[from]]];

[] ← d.crossedCellTypes.AddA[from];

[] ← d.crossedCellTypes.AddA[to];

{allcis: Set ~ from.Subcells[];

keep: Set ~ allcis.Difference[take].CreateHashCopy[];

tw: Set ~ d.iwConns.Image[take];

kw: Set ~ d.iwConns.Image[keep];

twRoots: Set ~ d.toRoot.Image[tw].CreateHashCopy[];

kwRoots: Set ~ d.toRoot.Image[kw].CreateHashCopy[];

twForest: Set ~ d.toRoot.Image[twRoots, rightToLeft].CreateHashCopy[];

kwForest: Set ~ d.toRoot.Image[kwRoots, rightToLeft].CreateHashCopy[];

dwForest: Set ~ from.CTParts[w].Difference[kwForest].CreateHashCopy[];

bw: Set ~ tw.Intersection[kw];

bwRoots: Set ~ d.toRoot.Image[bw].CreateHashCopy[];

bwForest: Set ~ d.toRoot.Image[bwRoots, rightToLeft].CreateHashCopy[];

npbwForest: Set ~ bwForest .Difference[from.asu.publics] .CreateHashCopy[];

[] ← FullySfwdlyExportWires[from, npbwForest];

IF NOT npbwForest.Subset[from.asu.publics] THEN ERROR;

{tp: Set ~ from.asu.exports.Image[twForest, rightToLeft];

kp: Set ~ from.asu.exports.Image[kwForest, rightToLeft];

tpRoots: Set ~ d.toRoot.Image[tp].CreateHashCopy[];

kpRoots: Set ~ d.toRoot.Image[kp].CreateHashCopy[];

tpForest: Set ~ d.toRoot.Image[tpRoots, rightToLeft].CreateHashCopy[];

kpForest: Set ~ d.toRoot.Image[kpRoots, rightToLeft].CreateHashCopy[];

dpForest: Set ~ from.CTParts[p].Difference[kpForest].CreateHashCopy[];

portWas: OneToOne ~ CopyPWStructure[from, to, p, tpForest, nilSet];

wireWas: OneToOne ~ CopyPWStructure[from, to, w, twForest, nilSet];

ciWas: OneToOne ~ CopyInstStructure[from, to, take, nilSet, wireWas, [], ALL[0]];

FixInst: PROC [ociv: Sets.Value] RETURNS [BOOL] ~ {

oci: CellInstance ~ NARROW[ociv.VA];

cct: CellType ~ d.CiCct[oci];

nci: CellInstance ~ Instantiate[to, cct, FALSE, IF d.physd THEN VXfm[d.ciXfm.ApplyA[oci].Val] ELSE [], oci.offset, cct.INames[oci]];

ConnectPWs[d, portWas.Compose[oci.conns], nci];

RETURN [FALSE]};

ConnectPWs[d, portWas.Compose[from.asu.exports.Compose[wireWas.Invert]], to];

IF d.ciType.ScanMapping[AV[from], FixInst, rightToLeft].found THEN ERROR;

DeletePorts[from, dpForest, TRUE, FALSE];

DeleteWires[from, dwForest, TRUE];

DeleteInsts[d, take, TRUE, FALSE];

RETURN}}}};

MergeUnorganized: PUBLIC PROC [a, b: CellType, iAssoc: OneToOne--instance of a é instance of b--] RETURNS [kept, lost: CellType, ciWas: OneToOne--kept é lost--] ~ {

d: Design ~ a.d;

IF a=b OR a.d#b.d OR a.asu=NIL OR b.asu=NIL OR a.asArray#NIL OR b.asArray#NIL OR d.arrayElt.HasMapA[a, rightToLeft] OR d.arrayElt.HasMapA[b, rightToLeft] OR NOT (iAssoc.SetOn[left].Equal[a.CtInsts] AND iAssoc.SetOn[right].Equal[b.CtInsts]) THEN ERROR;

kept ← a;

lost ← b;

{wpk: BiRel--Wire ← Port-- ~ kept.asu.exports.Invert;

wpl: BiRel--Wire ← Port-- ~ lost.asu.exports.Invert;

wireReallyIs: InvFn--kept wire ← lost wire-- ~ BiRels.CreateHashReln[ALL[d.eSpace], [FALSE, TRUE]];

wireIs: BiRel--kept wire lost wire-- ← nilBiRel;

xfm: Transform ← [];

offset: Int2 ← [0, 0];

StartAssoc: PROC [pair: BiRels.Pair] RETURNS [BOOL] ~ {

ik: CellInstance ~ NARROW[pair[left].VA];

il: CellInstance ~ NARROW[pair[right].VA];

wk: BiRel ~ wpk.Compose[ik.conns];

wl: BiRel ~ il.conns.Invert.Compose[lost.asu.exports];

wkl: BiRel ~ wk.Compose[wl].CreateHashCopy[mappable: ALL[TRUE]];

IF d.physd THEN {

tk: Transform ~ VXfm[d.ciXfm.ApplyA[ik].Val];

tl: Transform ~ VXfm[d.ciXfm.ApplyA[il].Val];

tki: Transform ~ tk.Invert[];

xf: Transform ~ tl.Compose[tki];

of: Int2 ~ tki.TransformVector[LIB.Sub[il.offset, ik.offset]];

IF wireIs=nilBiRel THEN {xfm ← xf; offset ← of}

ELSE IF xfm#xf OR offset#of THEN ERROR;

};

IF wireIs=nilBiRel THEN wireIs ← wkl ELSE wireIs ← wireIs.Intersection[wkl].CreateHashCopy[];

IF wireIs=nilBiRel THEN ERROR; RETURN [FALSE]};

IF iAssoc.Empty THEN ERROR;

IF iAssoc.Scan[StartAssoc].found THEN ERROR;

IF wireIs=nilBiRel THEN ERROR;

[] ← wireReallyIs.AddSet[wireIs];

{lostWires: Set ~ lost.CTParts[w];

alreadyWires: Set ~ wireReallyIs.SetOn[right];

alreadyAncestors: Set ~ d.ancest.Image[alreadyWires].CreateHashCopy[];

neededWires: Set ~ lostWires.Difference[alreadyAncestors].CreateHashCopy[];

wireWas: OneToOne--kept é lost-- ~ CopyPWStructure[lost, kept, w, neededWires, nilSet];

neededPorts: Set ~ lost.asu.exports.Image[neededWires, rightToLeft];

portWas: OneToOne--kept é lost-- ~ CopyPWStructure[lost, kept, p, neededPorts, nilSet];

ageWire: InvFn--kept wire ← lost wire-- ~ wireReallyIs.Union[b: wireWas, disjoint: TRUE, functional: [FALSE, TRUE]];

lostCis: Set ~ lost.Subcells[];

FixPair: PROC [pair: BiRels.Pair] RETURNS [BOOL] ~ {

ik: CellInstance ~ NARROW[pair[left].VA];

il: CellInstance ~ NARROW[pair[right].VA];

ConnectPWs[d, portWas.Compose[il.conns], ik];

RETURN [FALSE]};

ciWas ← CopyInstStructure[lost, kept, lostCis, nilSet, ageWire, xfm, offset];

ConnectPWs[d, portWas.Compose[lost.asu.exports].Compose[wireWas.Invert], kept];

IF iAssoc.Scan[FixPair].found THEN ERROR;

[] ← d.crossedCellTypes.AddA[kept];

d.ctName.SubstituteA[lost, kept, left];

DeleteCellType[lost, FALSE, NIL];

RETURN}}};

END.