DIRECTORY
Atom,
CD, CDBasics, CDCells, CDDirectory, CDEnvironment, CDInstances, CDIO, CDOps, CDProperties, 
Commander, 
Core, CoreClasses, CoreFlat, CoreIO, CoreOps, CoreProperties, 
CoreGeometry, 
GList, IO, 
PW, PWCore, 
RefTab, Rope, 
Sinix, SinixOps, Sisyph, TerminalIO;

PWCoreImpl: CEDAR PROGRAM
IMPORTS Atom, CD, CDBasics, CDCells, CDDirectory, CDEnvironment, CDInstances, CDIO, CDOps, CDProperties, CoreClasses, CoreIO, CoreOps, CoreProperties, CoreGeometry, GList, RefTab, IO, PW, PWCore, Rope, Sinix, SinixOps, Sisyph, TerminalIO
EXPORTS PWCore
SHARES CDCells, CDDirectory = 
BEGIN OPEN PWCore;
Signal: PUBLIC SIGNAL [cellType: CellType] = CODE;

Error: PUBLIC ERROR [type: ATOM, message: ROPE, cellType: CellType] = CODE;

PinsCorrespondingToSeveralPublics: PUBLIC SIGNAL [cellType: CellType, obj: Object, publics: Wires, geometry: CoreGeometry.Instances] = CODE;

NoPinsOnAtomicPublic: PUBLIC SIGNAL [cellType: CellType, obj: Object, public: Wire, message: ROPE _ NIL] = CODE;
layoutAtomsTable: RefTab.Ref _ RefTab.Create[];

LayoutAtomData: TYPE = REF LayoutAtomDataRec;
LayoutAtomDataRec: TYPE = RECORD [layoutProc: LayoutProc, decorateProc: DecorateProc, attributesProc: AttributesProc _ NIL];

RegisterLayoutAtom: PUBLIC PROC [layoutAtom: ATOM, layoutProc: LayoutProc, decorateProc: DecorateProc _ NIL, attributesProc: AttributesProc _ NIL] RETURNS [sameAtom: ATOM] = {
sameAtom _ layoutAtom;
IF ~RefTab.Store[layoutAtomsTable, layoutAtom, NEW [LayoutAtomDataRec _ [layoutProc: layoutProc, decorateProc: decorateProc, attributesProc: attributesProc]]] 
THEN TerminalIO.PutF["LayoutProc and DecorateProc for %g overwritten\n", IO.atom[layoutAtom]];
};

GetLayoutAtomData: PROC [layoutAtom: ATOM] RETURNS [layoutAtomData: LayoutAtomData] = {
layoutAtomData _ NARROW [RefTab.Fetch[layoutAtomsTable, layoutAtom].val];
IF layoutAtomData#NIL THEN RETURN;
CDEnvironment.ExecFileEntry[Atom.GetPName[layoutAtom], NIL, "PWCore"];
layoutAtomData _ NARROW [RefTab.Fetch[layoutAtomsTable, layoutAtom].val];
};

GetLayoutAtomRegistration: PUBLIC PROC [layoutAtom: ATOM] RETURNS [layoutProc: LayoutProc _ NIL, decorateProc: DecorateProc _ NIL, attributesProc: AttributesProc _ NIL] = {
layoutAtomData: LayoutAtomData _ GetLayoutAtomData[layoutAtom];
IF layoutAtomData=NIL THEN RETURN;
layoutProc _ layoutAtomData.layoutProc; 
decorateProc _ layoutAtomData.decorateProc; 
attributesProc _ layoutAtomData.attributesProc;
};
layoutAtomProp: PUBLIC ATOM _ CoreProperties.RegisterProperty[$Layout];

GetLayoutAtom: PUBLIC PROC [cellType: CellType] RETURNS [layoutAtom: ATOM _ NIL] = {
layoutAtom _ NARROW [CoreProperties.InheritCellTypeProp[cellType, layoutAtomProp]];
};

CopyDecorations: PROC [to, from: CellType, obj: Object] = {
CopyPins: PROC [toWire, fromWire: Wire] = {
IF NOT CoreGeometry.HasPins[extractMode.decoration, fromWire] 
THEN SIGNAL NoPinsOnAtomicPublic[from, obj, fromWire, CoreOps.GetFullWireName[from.public, fromWire]];
CoreGeometry.PutIndirectsLazyPins[extractMode.decoration, toWire, LIST [fromWire]]; -- replaced AddIndirectLazyPins by PutIndirectsLazyPins on August 15, 1988 12:14:12 pm PDT [BS]
};
CoreOps.VisitAtomicPairs[to.public, from.public, CopyPins];
};

CheckDecorations: PROC [ct: CellType, obj: Object] = {
CheckPins: PROC [wire: Wire] = {
IF NOT CoreGeometry.HasPins[extractMode.decoration, wire] THEN 
SIGNAL NoPinsOnAtomicPublic[ct, obj, wire, CoreOps.GetFullWireName[ct.public, wire]];
};
CoreOps.VisitRootAtomics[ct.public, CheckPins];
};

fromPWCoreProp: PRIVATE ATOM _ $FromPWCoreLayout; -- on CD.Objects
FromPWCoreRecord: TYPE = RECORD [int: INT];
SetFromPWCore: PRIVATE PROC [cellType: CellType] = {
obj: CD.Object _ CoreGeometry.GetObject[extractMode.decoration, cellType];
int: INT _ LOOPHOLE [cellType];
IF CDProperties.GetObjectProp[obj, fromPWCoreProp]#NIL THEN Signal[cellType]; -- same object is stuffed on two different cells!  That breaks the invariants, and Lichen will not work!
CDProperties.PutObjectProp[obj, fromPWCoreProp, NEW [FromPWCoreRecord _ [int]]];
};

Layout: PUBLIC PROC [cellType: CellType] RETURNS [obj: Object] = {
layoutAtom: ATOM;
layoutAtomData: LayoutAtomData;
obj _ CoreGeometry.GetObject[extractMode.decoration, cellType];
IF obj#NIL THEN RETURN;
layoutAtom _ NARROW [CoreProperties.GetCellTypeProp[cellType, layoutAtomProp]];
IF layoutAtom=NIL THEN 
layoutAtom _ NARROW [CoreProperties.GetCellClassProp[cellType.class, layoutAtomProp]];
IF layoutAtom=NIL AND cellType.class.recast=NIL THEN 
ERROR Error[$NoLayoutAtom, "Impossible to find a layoutAtom for this cellType", cellType]; 
layoutAtomData _ GetLayoutAtomData[IF layoutAtom=NIL THEN $Recast ELSE layoutAtom];
IF layoutAtomData=NIL THEN 
ERROR Error[$NoRegistration, IO.PutFR["LayoutAtom %g has not been registered", IO.atom[layoutAtom]], cellType];
IF layoutAtomData.attributesProc#NIL THEN layoutAtomData.attributesProc[cellType];
obj _ layoutAtomData.layoutProc[cellType];
PW.SetName[obj, CoreOps.GetCellTypeName[cellType]];
CoreGeometry.PutObject[extractMode.decoration, cellType, obj];
IF layoutAtomData.decorateProc#NIL THEN layoutAtomData.decorateProc[cellType, obj];
CheckDecorations[cellType, obj];
SetFromPWCore[cellType];
};

GetPWCoreExtractedCTKey: PUBLIC PROC [extractedCT: CellType] RETURNS [key: INT _ 0] = {
obj: CD.Object _ CoreGeometry.GetObject[extractMode.decoration, extractedCT];
ref: REF FromPWCoreRecord _ NARROW [CDProperties.GetObjectProp[obj, fromPWCoreProp]];
IF ref#NIL THEN key _ ref.int;
};

IsPWCoreGenerated: PUBLIC PROC [obj: Object] RETURNS [BOOL] = {
RETURN [CDProperties.GetObjectProp[obj, fromPWCoreProp]#NIL];
};

FromLayoutWithoutPublic: PUBLIC PROC [obj: Object] RETURNS [cellType: CellType] = {
cellType _ NARROW [Sinix.Extract[obj, extractMode].result];
IF IsPWCoreGenerated[obj] THEN RETURN; -- done twice!
SetLayoutAndDecoration[cellType, obj];
CheckDecorations[cellType, obj];
SetFromPWCore[cellType];
};
extractMode: PUBLIC Sinix.Mode _ SinixOps.GetExtractMode[$cmosB];
maskSuffix: PUBLIC ROPE _ ".mask";

GetAndAddSuffix: PROC [cellType: CellType] RETURNS [obj: Object] = {
source: CD.Design _ NARROW [CoreProperties.GetCellTypeProp[cellType, $PWCoreSourceDesign]];
obj _ PW.Get[source, IO.PutR[IO.rope[CoreOps.GetCellTypeName[cellType]], IO.rope[maskSuffix]]];
};

Get: LayoutProc = {
obj _ PW.CreateIndirect[GetAndAddSuffix[cellType]];
};

GetAndFlatten: LayoutProc = {
obj _ PW.Flatten[GetAndAddSuffix[cellType]];
};

Value: LayoutProc = {
obj _ NARROW [CoreProperties.GetCellTypeProp[cellType, $PWCoreValue]];
};

DecorateValue: PUBLIC DecorateProc = {
extractedCT: CellType _ NARROW [Sinix.Extract[obj, extractMode].result];
extractedToSource: RefTab.Ref _ RefTab.Create[extractedCT.public.size];
FindInExtractedPublic: CoreOps.EachWireProc = {
FOR names: LIST OF ROPE _ CoreOps.GetFullWireNames[cellType.public, wire], names.rest WHILE names#NIL DO
name: ROPE _ names.first;
extractedWire: Wire _ CoreOps.FindWire[extractedCT.public, name];
previousSourceWire: Wire _ NARROW [RefTab.Fetch[extractedToSource, extractedWire].val];
IF extractedWire=NIL OR extractedWire.size#0 THEN LOOP;
IF previousSourceWire#NIL AND previousSourceWire#wire THEN SIGNAL PinsCorrespondingToSeveralPublics[cellType, obj, LIST [previousSourceWire, wire], CoreGeometry.GetPins[extractMode.decoration, extractedWire]];
IF NOT CoreGeometry.HasPins[extractMode.decoration, extractedWire] 
THEN SIGNAL NoPinsOnAtomicPublic[cellType, obj, extractedWire, name];
CoreGeometry.AddIndirectLazyPins[extractMode.decoration, wire, extractedWire];
[] _ RefTab.Store[extractedToSource, extractedWire, wire];
ENDLOOP;
};
[] _ CoreOps.VisitWire[cellType.public, FindInExtractedPublic];
};
sisyphFudge: INT _ CD.FetchTechnology[$cmosB].lambda/2; -- Not very clean here!

AttributeAbutXorY: AttributesProc = {
ambiguous, inX: BOOL;
[ambiguous, inX] _ InstancesInXOrY[Sisyph.mode.decoration, cellType, sisyphFudge];
IF ambiguous THEN ERROR Error[$CallerBug, "*** Ambiguity for deciding between AbutX and AbutY.\n", cellType];
SortInstances[Sisyph.mode.decoration, cellType, IF inX THEN SortInX ELSE SortInY];
};

LayoutAbutXorY: LayoutProc = {
obj _ (IF InstancesInXOrY[Sisyph.mode.decoration, cellType, sisyphFudge].inX THEN AbutX ELSE AbutY)[cellType];
};

DecorateAbutXorY: DecorateProc = {
(IF InstancesInXOrY[Sisyph.mode.decoration, cellType, sisyphFudge].inX THEN DecorateAbutX ELSE DecorateAbutY)[cellType, obj];
};

AttributeX: AttributesProc = {SortInstances[Sisyph.mode.decoration, cellType, SortInX]};

AttributeY: AttributesProc = {SortInstances[Sisyph.mode.decoration, cellType, SortInY]};

AbutX: LayoutProc = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
subObjects: LIST OF Object _ NIL;
FOR i: NAT DECREASING IN [0 .. data.size) DO
subObjects _ CONS [Layout[data[i].type], subObjects];
ENDLOOP;
obj _ PW.AbutListX[subObjects];
};

AbutY: LayoutProc = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
subObjects: LIST OF Object _ NIL;
FOR i: NAT DECREASING IN [0 .. data.size) DO
subObjects _ CONS [Layout[data[i].type], subObjects];
ENDLOOP;
obj _ PW.AbutListY[subObjects];
};

AbutFlipXAndDecorate: LayoutProc = {obj _ AbutFlipAndDecorate[cellType, TRUE]};

AbutFlipYAndDecorate: LayoutProc = {obj _ AbutFlipAndDecorate[cellType, FALSE]};

AbutFlipAndDecorate: PROC [cellType: CellType, inX: BOOL] RETURNS [obj: Object] = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
flip: BOOL _ FALSE; -- indicates polarity of the coming flip
instances: CD.InstanceList _ NIL; -- instances for constructing the cell
layout0: CD.Object _ Layout[data[0].type];
isize0: CD.Position _ CD.InterestSize[layout0];
pos: CD.Position _ [0, 0]; -- position (in ir coordonnates) of the coming cell
FOR i: NAT IN [0 .. data.size) DO
orientation: CD.Orientation _ IF flip THEN IF inX THEN mirrorX ELSE rotate180X ELSE original;
layout: CD.Object _ Layout[data[i].type];
ir: CD.Rect = CDBasics.MapRect[CD.InterestRect[layout], [[0, 0], orientation]];
isize: CD.Position _ CDBasics.SizeOfRect[ir];
trans: CD.Transformation = [CDBasics.SubPoints[pos, CDBasics.BaseOfRect[ir]], orientation]; -- translation, in the CD coordonnate system
IF NOT (IF inX THEN isize.y=isize0.y ELSE isize.x=isize0.x) THEN ERROR; -- incompatible y dimension for an abutX
instances _ CONS [CDInstances.NewInst[layout, trans], instances];
CoreGeometry.PutTrans[extractMode.decoration, data[i], trans];
IF inX THEN pos.x _ pos.x + isize.x ELSE pos.y _ pos.y + isize.y;
flip _ NOT flip;
ENDLOOP;
obj _ PW.CreateCell[instances: instances]; 
CoreGeometry.PutRecordLazyPins[extractMode.decoration, cellType, CD.InterestRect[obj]];
};

ReverseAbutX: LayoutProc = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
subObjects: LIST OF Object _ NIL;
FOR i: NAT IN [0 .. data.size) DO
subObjects _ CONS [Layout[data[i].type], subObjects];
ENDLOOP;
obj _ PW.AbutListX[subObjects];
};

ReverseAbutY: LayoutProc = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
subObjects: LIST OF Object _ NIL;
FOR i: NAT IN [0 .. data.size) DO
subObjects _ CONS [Layout[data[i].type], subObjects];
ENDLOOP;
obj _ PW.AbutListY[subObjects];
};

ArrayX: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawAbutX]; obj _ PW.CreateIndirect[Layout[recasted]];
};

ArrayY: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawAbutY]; obj _ PW.CreateIndirect[Layout[recasted]];
};

ArrayFlipX: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawAbutFlipX]; obj _ PW.CreateIndirect[Layout[recasted]];
};

ArrayFlipY: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawAbutFlipY]; obj _ PW.CreateIndirect[Layout[recasted]];
};

ReverseArrayX: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawReverseAbutX]; obj _ PW.CreateIndirect[Layout[recasted]];
};

ReverseArrayY: LayoutProc = {
recasted: CellType _ CoreOps.Recast[cellType];
SetLayout[recasted, $RawReverseAbutY]; obj _ PW.CreateIndirect[Layout[recasted]];
};

Recast: LayoutProc = {
obj _ PW.CreateIndirect[Layout[CoreOps.Recast[cellType]]];
};

DecorateAbut: PUBLIC PROC [cellType: CellType, obj: Object, sort: SortProc] = {
InsertInst: CDCells.InstEnumerator = {
IF inst.trans.orient#original THEN ERROR Error[$CallerBug, "DecorateAbut is only applicable to objects expanding into cells without rotation", cellType];
sorted _ CONS [inst, sorted];
};
CompareInst: GList.CompareProc = {
inst1: CD.Instance = NARROW [ref1];
inst2: CD.Instance = NARROW [ref2];
RETURN [IF sort[ObjectBase[inst1.ob, inst1.trans], ObjectBase[inst2.ob, inst2.trans]] 
THEN less ELSE greater];
};
sorted: LIST OF CD.Instance;
recordData: CoreClasses.RecordCellType _ NARROW [cellType.data];
WHILE obj.class#CDCells.pCellClass DO obj _ CDDirectory.Expand1[obj].new ENDLOOP;
[] _ CDCells.EnumerateInstances[obj, InsertInst];
sorted _ NARROW [GList.Sort[sorted, CompareInst]];
FOR i: NAT IN [0 .. recordData.size) DO
CoreGeometry.PutTrans[extractMode.decoration, recordData[i], sorted.first.trans];
sorted _ sorted.rest;
ENDLOOP;
IF sorted#NIL THEN ERROR Error[$CallerBug, "DecorateAbut assumption not valid: CD cell has more instances than record CellType", cellType];
CoreGeometry.PutRecordLazyPins[extractMode.decoration, cellType, CD.InterestRect[obj]];
};

DecorateAbutX: PUBLIC DecorateProc = {
DecorateAbut[cellType, obj, SortInX];
};

DecorateAbutY: PUBLIC DecorateProc = {
DecorateAbut[cellType, obj, SortInY];
};

DecorateReverseAbutX: PUBLIC DecorateProc = {
DecorateAbut[cellType, obj, ReverseSortInX];
};

DecorateReverseAbutY: PUBLIC DecorateProc = {
DecorateAbut[cellType, obj, ReverseSortInY];
};

DecorateRecasted: PUBLIC DecorateProc = {
CopyDecorations[cellType, CoreOps.Recast[cellType], obj];
};
Rotated: PROC [cellType: CellType] RETURNS [rotatedCT: CellType] = {
rct: CoreClasses.RecordCellType;
IF cellType.class#CoreClasses.recordCellClass THEN ERROR Error[$CallerBug, "Rotation CellType expected [RecordCell with one instance]", cellType];
rct _ NARROW [cellType.data];
IF rct.size#1 THEN ERROR Error[$CallerBug, "Rotation CellType expected [RecordCell with one instance]", cellType];
rotatedCT _ rct[0].type;
};

LayoutRotated: LayoutProc = {
orientation: CD.Orientation _ SELECT GetLayoutAtom[cellType] FROM
$FlipX		=> mirrorX,
$FlipY		=> rotate180X,
$Rot90		=> rotate90,
$Rot90X		=> rotate90X,
$Rot180		=> rotate180,
$Rot180X		=> rotate180X,
$Rot270		=> rotate270,
$Rot270X		=> rotate270X,
ENDCASE		=> ERROR;
obj _ PW.CreateRotation[Layout[Rotated[cellType]], orientation];
};

DecorateRotated: PUBLIC DecorateProc = {
rotatedCT: CellType = Rotated[cellType];
trans: CoreGeometry.Transformation;
DecorateUniqueInst: CDCells.InstEnumerator = {trans _ inst.trans};
WHILE obj.class#CDCells.pCellClass DO obj _ CDDirectory.Expand1[obj].new ENDLOOP;
IF CDCells.CountInstances[obj]#1 THEN ERROR Error[$CallerBug, "DecorateRotated is not supposed to be called with an obj that does not expand into a one instance cell", cellType];
[] _ CDCells.EnumerateInstances[obj, DecorateUniqueInst];
CoreGeometry.PutTrans[extractMode.decoration, NARROW [cellType.data, CoreClasses.RecordCellType][0], trans];
CoreGeometry.PutRecordLazyPins[extractMode.decoration, cellType, CD.InterestRect[obj]];
};
SortInX: PUBLIC PROC [pos1, pos2: CD.Position] RETURNS [BOOL] = {RETURN [pos1.x<pos2.x]};
SortInY: PUBLIC PROC [pos1, pos2: CD.Position] RETURNS [BOOL] = {RETURN [pos1.y<pos2.y]};
ReverseSortInX: PUBLIC PROC [pos1, pos2: CD.Position] RETURNS [BOOL] = {RETURN [pos1.x>pos2.x]};
ReverseSortInY: PUBLIC PROC [pos1, pos2: CD.Position] RETURNS [BOOL] = {RETURN [pos1.y>pos2.y]};

ObjectBase: PROC [obj: CD.Object, trans: CoreGeometry.Transformation] RETURNS [pos: CD.Position] = {
pos _ CDBasics.BaseOfRect[CDBasics.MapRect[CD.InterestRect[obj], trans]];
};

InstanceBase: PROC [decoration: CoreGeometry.Decoration, cellType: CellType, trans: CoreGeometry.Transformation] RETURNS [pos: CD.Position] = {
pos _ ObjectBase[CoreGeometry.GetObject[decoration, cellType], trans];
};

InstancesInXOrY: PUBLIC PROC [decoration: CoreGeometry.Decoration, record: CellType, fudge: INT _ 0] RETURNS [ambiguous, inX: BOOL] = {
data: CoreClasses.RecordCellType _ NARROW [record.data];
overlappingInX, overlappingInY: BOOL _ FALSE;
FOR i: NAT IN [0 .. data.size-1) DO
rect1: CD.Rect _ CDBasics.MapRect[
CD.InterestRect[CoreGeometry.GetObject[decoration, data[i].type]], 
CoreGeometry.GetTrans[decoration, data[i]]
];
FOR j: NAT IN (i .. data.size) DO
rect2: CD.Rect _ CDBasics.MapRect[
CD.InterestRect[CoreGeometry.GetObject[decoration, data[j].type]], 
CoreGeometry.GetTrans[decoration, data[j]]
];
IF rect1.x1+fudge<rect2.x2 AND rect2.x1+fudge<rect1.x2 THEN overlappingInX _ TRUE;
IF rect1.y1+fudge<rect2.y2 AND rect2.y1+fudge<rect1.y2 THEN overlappingInY _ TRUE;
ENDLOOP;
ENDLOOP;
ambiguous _ overlappingInX=overlappingInY;
inX _ overlappingInY;
};

SortInstances: PUBLIC PROC [decoration: CoreGeometry.Decoration, cellType: CellType, sort: SortProc] = {
data: CoreClasses.RecordCellType _ NARROW [cellType.data];
FOR i: NAT IN [0 .. data.size-1) DO
FOR j: NAT IN (i .. data.size) DO
IF ~sort[
InstanceBase[decoration, data[i].type, CoreGeometry.GetTrans[decoration, data[i]]], 
InstanceBase[decoration, data[j].type, CoreGeometry.GetTrans[decoration, data[j]]]
] THEN {
w: CoreClasses.CellInstance _ data[i]; 
data[i] _ data[j]; data[j] _ w;
};
ENDLOOP;
ENDLOOP;
};
SetLayout: PUBLIC PROC [cellType: CellType, layoutAtom: ATOM, userDataProp: ATOM _ NIL, userData: REF _ NIL] = {
CoreProperties.PutCellTypeProp[cellType, layoutAtomProp, layoutAtom];
IF userDataProp#NIL THEN CoreProperties.PutCellTypeProp[cellType, userDataProp, userData];
};

RotateCellType: PUBLIC PROC [rotatedCellType: CellType, orientation: ATOM] RETURNS [cellType: CellType] = {
public: Wire = CoreOps.CreateWires[size: rotatedCellType.public.size];
internal: Wire = CoreOps.CreateWires[size: rotatedCellType.public.size];
FOR i: NAT IN [0 .. rotatedCellType.public.size) DO
new: Wire = CoreOps.CopyWire[rotatedCellType.public[i]];
public[i] _ internal[i] _ new;
ENDLOOP;
cellType _ CoreClasses.CreateRecordCell[public: public, internal: internal, instances: LIST [CoreClasses.CreateInstance[actual: internal, type: rotatedCellType]]];
SetLayout[cellType, orientation];
};
IncludeDescribedObjects: PROC [design: CD.Design, ob: CD.Object] = {
EachObject: CDDirectory.EachObjectProc = {
IF me.class.composed THEN {
name: Rope.ROPE _ CDDirectory.Name[me, design];
IF name#NIL THEN RETURN;
name _ NARROW [CDProperties.GetObjectProp[me, $Describe]];
IF name=NIL THEN RETURN;
IF CDProperties.GetObjectProp[me, $OwnerDesign]#NIL AND NOT me.immutable THEN RETURN;
[] _ CDDirectory.Include[design, me, name, TRUE];
}
};
[] _ CDDirectory.EnumerateObject[ob: ob, proc: EachObject]
};

Store: PUBLIC PROC [cellType: CellType, withCuteFonts: BOOL _ FALSE] = {
name: ROPE _ CoreOps.GetCellTypeName[cellType];
[] _ Layout[cellType]; -- necessary in order to generate layout
TerminalIO.PutF["Saving the Core for cell %g ...\n", IO.rope[name]];
[] _ CoreIO.ReportSaveCellType[cellType];
StoreShell[cellType, withCuteFonts];
StoreLayout[cellType];
TerminalIO.PutF["\nLayout checkpoint:\n %g.core\n %gLayout.dale\n %gShell.dale\n",
IO.rope[name], IO.rope[name], IO.rope[name]];
};

StoreShell: PUBLIC PROC [cellType: CellType, withCuteFonts: BOOL _ FALSE] = {
name: ROPE _ CoreOps.GetCellTypeName[cellType];
shellFileName: ROPE _ Rope.Cat[name, "Shell"];
shellDesign: CD.Design _ CDOps.CreateDesign[CD.FetchTechnology[$cmosB]];
shell: CD.Object;
TerminalIO.PutF["Saving the Shell for cell %g ...\n", IO.rope[name]];
shell _ CoreGeometry.CreateShell[extractMode.decoration, cellType, withCuteFonts];
shellDesign.name _ shellFileName;
[] _ CDDirectory.Include[shellDesign, shell, name];
[] _ CDOps.IncludeObjectI[shellDesign, shell];
[] _ CDIO.WriteDesign[shellDesign, shellFileName];
CDOps.SetMutability[shellDesign, inaccessible];
}; -- to avoid GCollected objects!

StoreLayout: PUBLIC PROC [cellType: CellType] = {
name: ROPE _ CoreOps.GetCellTypeName[cellType];
layoutFileName: ROPE _ Rope.Cat[name, "Layout"];
layoutDesign: CD.Design _ CDOps.CreateDesign[CD.FetchTechnology[$cmosB]];
layout: CD.Object _ Layout[cellType];
TerminalIO.PutF["Saving the Layout for cell %g ...\n", IO.rope[name]];
layoutDesign.name _ layoutFileName;
layout _ PW.CreateCell
[LIST [CDInstances.NewInst[layout]], CD.InterestRect[layout], name.Cat[".mask"]];
[] _ CDDirectory.Include[layoutDesign, layout, name.Cat[".mask"]];
[] _ CDOps.IncludeObjectI[layoutDesign, layout];
IncludeDescribedObjects[layoutDesign, layout];
[] _ CDIO.WriteDesign[layoutDesign, layoutFileName];
CDOps.SetMutability[layoutDesign, inaccessible];
}; -- to avoid GCollected objects!

Retrieve: PUBLIC PROC [name: ROPE, withLazyExtract: BOOL _ TRUE] RETURNS [cellType: CellType] = {
CopyPins: PROC [fromWire, toWire: Core.Wire] = {
IF NOT CoreGeometry.HasPins[PWCore.extractMode.decoration, fromWire] 
THEN SIGNAL PWCore.NoPinsOnAtomicPublic[cellType, layout, fromWire, CoreOps.GetFullWireName[cellType.public, fromWire]];
CoreGeometry.PutIndirectsLazyPins[PWCore.extractMode.decoration, toWire, LIST [fromWire]];
};
layout: CoreGeometry.Object;
public: Core.WireSeq;
TerminalIO.PutF["Retrieving %g.core\n", IO.rope[name]];
cellType _ CoreIO.RestoreCellType[name];
TerminalIO.PutF["%g.core Retrieved\n", IO.rope[name]];
SetFromPWCore[cellType];
IF NOT withLazyExtract THEN RETURN;
public _ CoreOps.CopyWire[cellType.public];
layout _ PWCore.Layout[cellType];
CoreOps.VisitAtomicPairs[cellType.public, public, CopyPins];
Sinix.DecorateObjectWithLazyExtract[public, layout, PWCore.extractMode];
};
LayoutInfo: PUBLIC PROC [sourceCT: CellType] RETURNS [layout: Object, extractedCT: CellType, extractedToSource: RefTab.Ref, key: INT] = {
layout _ PWCore.Layout[sourceCT];
extractedCT _ NARROW [Sinix.Extract[layout, extractMode].result];
key _ GetPWCoreExtractedCTKey[extractedCT];
extractedToSource _ Sinix.MapExtractedToSource[sourceCT.public, extractedCT.public, layout, PWCore.extractMode];
};
[] _ RegisterLayoutAtom[$Get, Get, DecorateValue];
[] _ RegisterLayoutAtom[$GetAndFlatten, GetAndFlatten, DecorateValue];
[] _ RegisterLayoutAtom[$Value, Value, DecorateValue];
[] _ RegisterLayoutAtom[$ValueNoDecorate, Value];
[] _ RegisterLayoutAtom[$AbutListXNoDecorate, AbutX];
[] _ RegisterLayoutAtom[$AbutListYNoDecorate, AbutY];
[] _ RegisterLayoutAtom[$RawAbutX, AbutX, DecorateAbutX];
[] _ RegisterLayoutAtom[$RawAbutY, AbutY, DecorateAbutY];
[] _ RegisterLayoutAtom[$RawAbutFlipX, AbutFlipXAndDecorate];
[] _ RegisterLayoutAtom[$RawAbutFlipY, AbutFlipYAndDecorate];
[] _ RegisterLayoutAtom[$AbutFlipX, AbutFlipXAndDecorate, NIL, AttributeX];
[] _ RegisterLayoutAtom[$AbutFlipY, AbutFlipYAndDecorate, NIL, AttributeY];
[] _ RegisterLayoutAtom[$RawReverseAbutX, ReverseAbutX, DecorateReverseAbutX];
[] _ RegisterLayoutAtom[$RawReverseAbutY, ReverseAbutY, DecorateReverseAbutY];
[] _ RegisterLayoutAtom[$AbutX, AbutX, DecorateAbutX, AttributeX];
[] _ RegisterLayoutAtom[$AbutY, AbutY, DecorateAbutY, AttributeY];
[] _ RegisterLayoutAtom[$Abut, LayoutAbutXorY, DecorateAbutXorY, AttributeAbutXorY];
[] _ RegisterLayoutAtom[$ReverseAbutX, ReverseAbutX, DecorateReverseAbutX, AttributeX];
[] _ RegisterLayoutAtom[$ReverseAbutY, ReverseAbutY, DecorateReverseAbutY, AttributeY];
[] _ RegisterLayoutAtom[$ArrayX, ArrayX, DecorateRecasted];
[] _ RegisterLayoutAtom[$ArrayY, ArrayY, DecorateRecasted];
[] _ RegisterLayoutAtom[$ArrayFlipX, ArrayFlipX, DecorateRecasted];
[] _ RegisterLayoutAtom[$ArrayFlipY, ArrayFlipY, DecorateRecasted];
[] _ RegisterLayoutAtom[$ReverseArrayX, ReverseArrayX, DecorateRecasted];
[] _ RegisterLayoutAtom[$ReverseArrayY, ReverseArrayY, DecorateRecasted];
[] _ RegisterLayoutAtom[$Recast, Recast, DecorateRecasted];
[] _ RegisterLayoutAtom[$FlipX, LayoutRotated, DecorateRotated];
[] _ RegisterLayoutAtom[$FlipY, LayoutRotated, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot90, LayoutRotated, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot90X, LayoutRotated, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot180, LayoutRotated, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot180X, LayoutRotated, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot270, LayoutRotated, DecorateRotated];
[] _ RegisterLayoutAtom[$Rot270X, LayoutRotated, DecorateRotated];

END.
τPWCoreImpl.mesa
Copyright Σ 1985, 1987 by Xerox Corporation.  All rights reserved.
Louis Monier May 17, 1986 1:35:25 pm PDT
Bertrand Serlet August 15, 1988 1:52:12 pm PDT
Barth, April 22, 1986 7:30:28 pm PST
Spreitzer, April 11, 1986 10:52:25 am PST
Last Edited by: Louis Monier July 26, 1988 7:14:55 pm PDT
Jean-Marc Frailong December 28, 1987 10:00:21 am PST
Last edited by: Christian Jacobi, January 9, 1987 12:16:44 pm PST
Exceptions
LayoutAtomsTable
Primitives
Copies decorations from from to to
We check that the public of the source and the public of the recasted layout are similar, and we copy properties from one to the other
Checks that's ct is properly decorated.
We compute the attributes (if any)
Now the layout
We decorate for lazy decorations
Now we decorate the source cellType
We check those decorations, and we decorate layoutCellType.  We need to do that in order to be able to return layoutCellType as the result of the extraction.
We mark obj as coming from Layout
Global Variable
$Get, $GetAndFlatten, $Value and $ValueNoDecorate
Here could be added the code for searching in a "Design" property if source=NIL?
Question for the reader: Why are we making an indirect here???
Answer: because two different cellTypes can have the exact same name, Layout: $Get and $PWCoreSourceDesign: design.  For example two icons extracted in different Sisyph contexts will yield two different (but identical!) cellTypes.
Abuts, Arrays and Recast
We decorate each instance with the appropriate trans, so that the Lazy GetPins can find the location
We decorate each instance with the appropriate trans, so that the Lazy GetPins can find the location
Rotations
This line is important since obj can be of the class "Rotation" itself.
Help for writing DecorateProcs
Short cut
Saving "Checkpoints"
Slight modification of CDDirectoryOps.IncludeDescribedObjects to avoid problems when dealing with objects inclkuded in 2 designs.
Hack, of course!
Backdoor for clients such as PWCoreLichen
Initialization and various registrations

Κ]˜™Icodeš
œB™BKšœ%Οk™(Kš
œ.™.Kšœ!™$Kšœ&™)Kšœ6™9Kšœ1™4Kšœ>™A—J˜š
	˜	Kš
œ˜Kšœ>œ˜[K˜Kš
œ>˜>K˜Kšœœ˜Kšœ
˜Kš
œ˜Kš
œ$˜$—K˜šΠbn
œœ
˜Kš
œœ>œbœœ3˜ν
Kšœ˜Kšœ˜Kšœ
œ˜—
head™
šΟnœœ
œœ
˜2J˜—šŸœœ
œœœœ
˜KJ˜—šŸ!œœ
œWœ
˜Œ
J˜—JšŸœœ
œ:œœœ
˜p—š
œ™Jš
œ/˜/J˜Kšœœœ˜-KšœœœWœ˜|K˜šŸœœ
œœ7œ#œœœ˜―
Kš
œ˜šœ-œm˜Ÿ
KšœEœ˜^—K˜K˜—šŸœœœœ%˜WKšœœ2˜IKšœœ
œ
œ
˜"Kšœ7œ˜FKšœœ2˜IK˜K˜—šŸœœ
œœœœœ#œ˜¬
Kš
œ?˜?Kšœœ
œ
œ
˜"Kš
œ(˜(Kš
œ,˜,Kš
œ/˜/K˜——š
œ
™
šœœ
œ,˜GJ˜—šŸ
œœ
œœœœ˜TKšœ
œ@˜SK˜K˜—Kš
œ"™"šŸœœ&˜;šŸœœ˜+šœ
œ8˜>Jšœ
œ[˜f—JšœBœΟc_˜³
K˜—Kš
Ϡ
™†
Kš
œ;˜;K˜K˜—Kš
œ'™'šŸœœ ˜6šŸ	œœ˜ šœ
œ4œ
˜?JšœO˜U—K˜—Kš
œ/˜/K˜K˜—JšœΠbkœ
œ ˜BJšœœœœ˜+šŸ
œœ
œ˜4KšœœC˜JKšœœœ˜Kšœ1œ
œ h˜Ά
Kšœ0œ˜PK˜J˜—šŸœœ
œœ˜BKšœœ
˜Kš
œ˜Kš
œ?˜?Kšœœ
œ
œ
˜Kšœ
œ<˜Ošœœ
œ
˜Kšœ
œC˜V—š
œœ
œœ
œ
˜5KšœV˜[—Kš	œ#œœ
œ	œ
˜Sšœœ
œ
˜Kšœœ0œ˜o—K™"Kšœœ
œ)˜RK™Kš
œ*˜*Kšœ1˜3K™ Kš
œ>˜>Kš
œ#™#Kšœœ
œ,˜SKš
œ
™
Kš
œ ˜ Kš
œ!™!Kš
œ˜Kš
œ˜—K˜š
Ÿœœ
œœœ	˜WKšœœF˜MKšœœœ3˜UKšœœ
œ˜J˜J˜—š
Ÿœœ
œœœ˜?Jšœ2œ˜=J˜J˜—šŸœœ
œœ˜SJšœœ*˜;Kšœœ
œ ˜5Kš
œ&˜&Kš
œ ˜ Kš
œ˜K˜——™Jšœ
œ.˜A—š
œ1™1šœœ
œ˜"J˜—šŸœœœ˜DKšœœ
œA˜[JšœLœ
™PJš	œœ
œœ*œ˜_J˜J˜—K™>K™ζ
šžœ˜Jšœœ+˜3K˜K˜—šŸ
œ˜Jšœœ$˜,K˜K˜—šŸœ˜Kšœœ:˜FK˜K˜—šŸ
œœ˜&Jšœœ*˜HJš
œG˜Gšžœ˜/š
œœ
œ
œ?œœ
˜hKšœœ˜Kš
œA˜AKšœœ6˜WKš
œœ
œœ
œ
˜7Kšœœ
œœ
œ2œZ˜Ρ
šœ
œ=˜CJšœ
œ:˜E—Jš
œN˜NKš
œ:˜:Kšœ
˜—J˜—Jš
œ?˜?Kš
œ˜——™šœ
œœ# ˜OK˜—šŸœ˜%Kšœœ
˜Kš
œR˜RKšœœ
œV˜mKšœ0œœ	œ
˜RKš
œ˜K˜—šŸœ˜KšœœDœœ˜nK˜K˜—šŸœ˜"Kšœ
œDœœ˜}K˜K˜—šŸ
œN˜XK˜—šŸ
œN˜XK˜—šŸœ˜Kšœ#œ˜:Kšœœ
œ
œ
˜!š	œœ

œ
œ˜,Kšœ
œ$˜5Kšœ
˜—Jšœœ˜K˜K˜—šŸœ˜Kšœ#œ˜:Kšœœ
œ
œ
˜!š	œœ

œ
œ˜,Kšœ
œ$˜5Kšœ
˜—Jšœœ˜K˜K˜—šŸœ4œ˜OK˜—šŸœ4œ˜PK˜—šŸœœœœ˜SKšœ#œ˜:Kšœœœ (˜<Kšœœœ &˜HKšœ	œ˜*Kšœœœ˜/Kšœœ 3˜Nšœœ
œ˜!Kšœ
œœœ
œœ	œœ
˜]Kšœœ˜)Kšœœœ.˜OKšœœ$˜-KšœœS ,˜ˆ
Jšœ
œœœœœ
œ (˜pKšœœ1˜AJš
œd™dJš
œ>˜>Jšœœœ˜AKšœœ˜Kšœ
˜—Jšœœ#˜+JšœAœ˜WK˜K˜—šŸœ˜Kšœ#œ˜:Kšœœ
œ
œ
˜!šœœ
œ˜!Kšœ
œ$˜5Kšœ
˜—Jšœœ˜K˜K˜—šŸœ˜Kšœ#œ˜:Kšœœ
œ
œ
˜!šœœ
œ˜!Kšœ
œ$˜5Kšœ
˜—Jšœœ˜K˜K˜—šžœ˜Kš
œ.˜.Kšœ&œ"˜JK˜K˜—šžœ˜Kš
œ.˜.Kšœ&œ"˜JK˜K˜—šž
œ˜Kš
œ.˜.Kšœ*œ"˜NK˜K˜—šž
œ˜Kš
œ.˜.Kšœ*œ"˜NK˜K˜—šž
œ˜Kš
œ.˜.Kšœ-œ"˜QK˜K˜—šž
œ˜Kš
œ.˜.Kšœ-œ"˜QK˜K˜—šžœ˜Kšœœ2˜:K˜K˜—šŸœœ
œ6˜OšŸ
œ˜&Kšœœ
œq˜™
Kšœ	œ˜K˜—šŸœ˜"Jšœœœ˜#Jšœœœ˜#šœœL˜VJšœœ
˜—J˜—Kšœœ
œ
œ
˜Jšœ)œ˜@Kšœœ$œ
˜QKš
œ1˜1Kšœ	œ#˜2Jš
œd™dšœœ
œ˜'Jš
œQ˜QJš
œ˜Jšœ
˜—Jšœœ
œ
œs˜‹
JšœAœ˜WK˜K˜—šŸ
œœ˜&Kš
œ%˜%Kš
œ˜K˜—šŸ
œœ˜&Kš
œ%˜%Kš
œ˜K˜—šŸœœ˜-Kš
œ,˜,Kš
œ˜K˜—šŸœœ˜-Kš
œ,˜,Kš
œ˜K˜—šžœœ˜)Kš
œ9˜9Kš
œ˜——™	šŸœœœ˜DJš
œ ˜ Jšœ,œ
œZ˜’
Jšœœ˜Jšœœ
œZ˜rJš
œ˜J˜K˜—šŸ
œ˜šœ
œœ˜AJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ
˜—Jšœœ8˜@Jš
œ˜K˜—šžœœ˜(Jš
œ(˜(Kš
œ#˜#KšŸœ0˜BKš
œG™GKšœœ$œ
˜QKšœœ
œ‡
˜²
Kš
œ9˜9Kšœ.œ8˜lKšœAœ˜WK˜——™KšŸœœ
œœœœœ˜YKšŸœœ
œœœœœ˜YKšŸœœ
œœœœœ˜`šŸœœ
œœœœœ˜`K˜—š
Ÿ
œœœ-œœ˜dKšœ+œ˜IK˜K˜—šŸœœ_œœ˜
Kš
œF˜FK˜K˜—šŸœœ
œ@œœœ˜‡
Kšœ#œ˜8Kšœ œœ
˜-šœœ
œ˜#šœœ˜"JšœA˜CJš
œ*˜*J˜—šœœ
œ˜!šœœ˜"JšœA˜CJš
œ*˜*J˜—Kšœœœœ
˜RKšœœœœ
˜RKšœ
˜—Kšœ
˜—Kš
œ*˜*Kš
œ˜K˜K˜—šŸ
œœ
œN˜hKšœ#œ˜:šœœ
œ˜#šœœ
œ˜!šœ˜	Kš
œT˜TKš
œR˜RKšœœ˜Kš
œ'˜'Kš
œ˜Kš
œ˜—Kšœ
˜—Kšœ
˜—K˜——™	šŸ	œœ
œ"œœœœœ˜pKš
œE˜EKšœœ
œB˜ZKš
œ˜K˜—š
Ÿœœ
œ*œœ˜kKš
œF˜FKš
œH˜Hšœœ
œ$˜3Kš
œ8˜8Kš
œ˜Kšœ
˜—K•StartOfExpansion`[actual: 
Core.Wire, type: 
Core.CellType, name: 
ROPE _ NIL, props: 
Core.Properties _ NIL]šœWœH˜£
Kš
œ!˜!K˜——™Kš
œ
™
šŸœœ
œ
œ˜DšŸ
œ ˜*šœœ˜Kšœœ ˜/Kšœœ
œ
œ
˜Kšœœ-˜:Kšœœ
œ
œ
˜Kš
œ™Kšœ.œ
œ
œœ
œ
˜UKšœ+œ˜1K˜
—K˜—Jš
œ:˜:Jš
œ˜J˜—š
Ÿœœ
œ%œœ˜HJšœœ%˜/Jšœ (˜?Jšœ5œ
˜DJš
œ)˜)Jš
œ$˜$Jš
œ˜š
œR˜RJšœ
œ
œ
˜-—Jš
œ˜—J˜š
Ÿ
œœ
œ%œœ˜MJšœœ%˜/Jšœœ˜.Jšœ
œœ˜HJšœœ˜Jšœ6œ
˜EJš
œR˜RJš
œ!˜!Jš
œ3˜3Jš
œ.˜.Jšœœ)˜2Jš
œ/˜/Jšœ ˜"J˜—šŸœœ
œ˜1Jšœœ%˜/Jšœœ˜0Jšœœœ˜IJšœœ˜%Jšœ7œ
˜FJš
œ#˜#šœ	œ˜Jšœ
œ œ*˜Q—Jš
œB˜BJš
œ0˜0Jš
œ.˜.Jšœœ+˜4Jš
œ0˜0Jšœ ˜"J˜—šŸœœ
œœœœœ˜ašŸœœ"˜0šœ
œ?˜EJšœ
œm˜x—JšœIœ
˜ZK˜—Kš
œ˜Kš
œ˜Kšœ(œ
˜7Jš
œ(˜(Kšœ'œ
˜6Kš
œ˜Kšœ
œœ
œ
˜#Kš
œ+˜+K˜!Kš
œ<˜<Kš
œH˜HKš
œ˜——™)š
Ÿ
œœ
œœMœ˜‰
Jš
œ!˜!Jšœœ-˜AJš
œ+˜+Jš
œp˜pJ˜——™(Jš
œ2˜2Jš
œF˜FJš
œ6˜6Jš
œ1˜1Jš
œ5˜5Jš
œ5˜5Jš
œ9˜9Jš
œ9˜9Jš
œ=˜=Jš
œ=˜=Jšœ:œ˜KJšœ:œ˜KJš
œN˜NJš
œN˜NJš
œB˜BJš
œB˜BJš
œT˜TJš
œW˜WJš
œW˜WJš
œ;˜;Jš
œ;˜;Jš
œC˜CJš
œC˜CJš
œI˜IJš
œI˜IJš
œ;˜;Jš
œ@˜@Jš
œ@˜@Jš
œ@˜@Jš
œA˜AJš
œA˜AJš
œB˜BJš
œA˜AJš
œB˜B—J˜Kšœ
˜K™—…—_~Q