BrandyCIFter.mesa  A module to output CIF files from ChipNDale
Copyright © 1984, 1985 by Xerox Corporation. All rights reserved.
Last Edited by: Kimr, October 15, 1984 5:15:13 pm PDT
Last Edited by: Christian Jacobi, October 30, 1984 12:10:38 pm PST
Last Edited by: Christian Jacobi, August 5, 1986 4:30:27 pm PDT
Last Edited by McCreight, October 17, 1984 7:02:18 pm PDT
DIRECTORY
Atom USING [GetPName],
CD,
CDBasics,
CDCells,
CDCommandOps,
CDCurves,
CDDirectory,
CDExtras,
CDImports,
CDInstances USING [InstRectO],
CDIO,
CDMenus,
CDOps USING [DrawDesign],
CDOrient,
CDProperties,
CDSequencer USING [Command, ImplementCommand],
CDVArrow USING [RemoveArrow, ShowArrow],
CStitching,
FS USING [StreamOpen, Error],
IO USING [Close, CR, int, PutChar, PutF, PutFR, PutRope, PutText, refAny, rope, STREAM, time],
List USING [Append, Nconc],
Rope,
TerminalIO;
BrandyCIFter: CEDAR PROGRAM
IMPORTS Atom, CD, CDBasics, CDCells, CDCurves, CDCommandOps, CDDirectory, CDExtras, CDImports, CDInstances, CDIO, CDMenus, CDOps, CDOrient, CDProperties, CDSequencer, CDVArrow, CStitching, FS, IO, List, Rope, TerminalIO =
BEGIN
--TYPES
CIFUnits: TYPE = CD.Number;
CIFPos: TYPE = CD.Position -- in CIFUnits -- ;
CIFRect: TYPE = CD.Rect -- in CIFUnits -- ;
Rational: TYPE = RECORD [num, denom: INT ← 1];
CIFDest: TYPE = REF CIFDestRec ← NIL;
CIFDestRec: TYPE = RECORD [
cifDest: Rope.ROPE,
deltaRadius: INT -- nanometers, + means cif is bigger
];
CIFDirective: TYPE = REF CIFDirectiveRec ← NIL;
CIFDirectiveRec: TYPE = RECORD [
cdSource: CD.Layer,
cifDest: Rope.ROPE,
deltaRadius: INT -- nanometers, + means cif is bigger
];
MaskStateRef: TYPE = REF MaskState;
MaskState: TYPE = RECORD [
areas, unbloated: CStitching.Tesselation ← NIL,
partClip: CIFRect ← [0,0,0,0]
];
--Global Variables
cellIDKey: REF ATOM = NEW[ATOM ← $CellIDNo]; --not accessible
debugging: BOOLFALSE; -- used for printing out debugging messages
design: CD.Design ;
topLayerOb: CD.Object ← NEW[CD.ObjectRep];
stopFlag: REF BOOLNEW[BOOL];
clearIDsRec: CD.DrawRef;
cifMeasureR: CD.DrawRef;
cifDrawRec: CD.DrawRef; --for CIFOrArea
contextFilter: REF CD.ContextFilter ← NEW[CD.ContextFilter←ALL[FALSE]]; --used in cifDrawRec
infinity: CD.Number ← LAST[CD.Number]; --used to initialize sizes and positions
cellCount: INTEGER ← 0; -- used to assign consecutive CIF ID numbers
cifLayerAnnounced: BOOLFALSE;
--layer assumed to be unchanged until the next layer is announced
lambda: INT ← 0;
cifPerLambda: INT ← 100; -- CIF units per lambda
nmPerCIF: INT = 10; -- nanometers per CIF unit, given 0.01 microns per CIF unit
cifPerCD: INT; -- cifPerLambda/l, since l is defined in CD units per lambda
cifScaling: Rational;
--..output numbers*cifScaling = CIFUnits
--..CIFUnits/cifScaling = output numbers
cifFile: IO.STREAM; -- file where output will be stored
comment, base, name, lastCellName: Rope.ROPE;
mainRect: CD.Rect ← [x1: infinity, y1: infinity, x2: -infinity, y2: -infinity];
--set to design size in CIFMeasureArea, used to switch between ChipNDale and CIF coordinate systems
cifDirectives: LIST OF REF ANY -- CIFDirective --NIL;
currentDirective: CIFDirective;
partWidth: CIFUnits ← 800000; -- window for flat CIF
partHeight: CIFUnits ← 800000;
--Procedures
FreeStorage: PROC [] =
BEGIN
cifMeasureR ← clearIDsRec ← cifDrawRec ← NIL; --help the garbage collector
design ← NIL;
cifFile ← NIL;
END;
SimpleRect: PROC [ob: CD.Object] RETURNS [yes: BOOL] =
INLINE BEGIN
yes ← ob.class.wireTyped AND ob.class.objectType=$Rect
END;
--%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
specialProperties: CDProperties.PropRef ← CDProperties.InitPropRef[];
SetUpSpecialClasses: PROC [] =
BEGIN
x: REF ← CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFTechnology];
IF design.technology.key#x AND design.technology#x THEN {
IF x=NIL THEN TerminalIO.WriteRope["CIF commandfile not set up\n"]
ELSE TerminalIO.WriteRope["CIF commandfile set up for different technology\n"];
ERROR ABORTED
};
WITH CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFSpecials] SELECT FROM
pRef: CDProperties.PropRef => specialProperties ← pRef;
ENDCASE => specialProperties ← CDProperties.InitPropRef[];
END;
IsSpecialCase: PROC [ob: CD.Object] RETURNS [yes: BOOLFALSE] =
BEGIN
yes ← CDProperties.GetListProp[specialProperties^, ob.class.objectType]#NIL
END;
HandleSpecialCase: PROC [ob: CD.Object] =
BEGIN
WITH CDProperties.GetListProp[specialProperties^, ob.class.objectType] SELECT FROM
rp: REF PROC [ob: CD.Object] RETURNS [Rope.ROPE] => {
r: Rope.ROPE ← rp^[ob];
IO.PutRope[cifFile, r];
};
r: Rope.ROPE => {
IO.PutRope[cifFile, r];
};
rt: REF TEXT => {
IO.PutText[cifFile, rt];
};
ENDCASE => {
TerminalIO.WriteRope["object class handled specialy is inconsistent\n"];
ERROR
};
END;
--%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ClearCellIDs: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation, pr: REF CD.DrawInformation] -- CD.DrawProc -- =
--used to set all CellIDNo's to NIL at the start
BEGIN
CDProperties.PutObjectProp[onto: inst.ob, prop: cellIDKey, val: NIL];
IF inst.ob.class.inDirectory THEN
inst.ob.class.drawMe[inst: inst, pos: inst.location, orient: inst.orientation, pr: clearIDsRec];
END;
SymHeader: PROC [obj: CD.Object]=
--start outputting a new cell and assign its cellID
BEGIN
cellID: REF INTNEW[INT ← (cellCount ← cellCount + 1)];
cifFile.PutF["DS %d %d %d;\n",
IO.int[cellCount], IO.int[cifScaling.num], IO.int[cifScaling.denom]];
CDProperties.PutObjectProp[obj, cellIDKey, cellID];
END;
UnfinishedSymHeader: PROC [obj: CD.Object]=
--start outputting a new cell and assign its cellID
--but don't output the scaling
BEGIN
cellID: REF INTNEW[INT ← (cellCount ← cellCount + 1)];
cifFile.PutF["DS %d ",
IO.int[cellCount]];
CDProperties.PutObjectProp[obj, cellIDKey, cellID];
END;
SymTrailer: PROC =
--finish off cell description
BEGIN
cifFile.PutRope["DF;\n"];
END;
--logically local to GenerateCompositeOb
CallChildren: CD.DrawProc =
--PROC [inst: Instance, pos: Position, orient: Orientation, pr: REF DrawInformation]
BEGIN
IF ~SimpleRect[inst.ob] THEN {
cifPos: CIFPos ← CDPosToCIF[CDOrient.MapPoint[
pointInCell: [0, 0],
cellSize: inst.ob.size,
cellInstOrient: orient,
cellInstPos: pos
]];
CIFSymbolCall[inst.ob, orient, cifPos];
};
END;
--logically local to GenerateCompositeOb
DrawRectChilds: CD.DrawProc =
--PROC [inst: Instance, pos: Position, orient: Orientation, pr: REF DrawInformation]
BEGIN
IF SimpleRect[inst.ob] THEN {
inst.ob.class.drawMe[inst: inst, pos: pos, orient: orient, pr: pr];
};
END;
GenerateCompositeOb: PROC [obj: CD.Object] =
--output composite objects
--the children must be already defined
BEGIN
cf: REF CD.ContextFilter ← NEW[CD.ContextFilter←ALL[FALSE]];
pr: CD.DrawRef ← CD.CreateDrawRef[[
stopFlag: stopFlag,
design: design
]];
dummyInst: CD.Instance = NEW[CD.InstanceRep];
--match the type of drawMe parameter
dummyInst^.ob ← obj;
SymHeader[obj];
CIFDrawCellName[CDDirectory.Name[obj]];
--call the children
pr.contextFilter ← NIL;
pr.drawChild ← CallChildren;
pr.drawRect ← IgnoreRect;
obj.class.drawMe[dummyInst, [0, 0], CD.original, pr];
--draw the rectangles
pr.drawChild ← DrawRectChilds;
pr.contextFilter ← cf;
pr.drawRect ← CIFOrArea;
FOR directives: LIST OF REF ANY ← cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective ← NARROW[directives.first];
cifLayerAnnounced ← FALSE;
--IF currentDirective.deltaRadius>=0 THEN redundant but easier to understand
cf[currentDirective.cdSource] ← TRUE;
obj.class.drawMe[dummyInst, [0, 0], CD.original, pr];
cf[currentDirective.cdSource] ← FALSE;
ENDLOOP;
SymTrailer[];
END;
GenerateGeometricOb: PROC [obj: CD.Object] =
--output CIF for structures only identified as geometries
BEGIN
dummyInst: CD.Instance = NEW[CD.InstanceRep];
--match the type of drawMe parameter
dummyInst^.ob ← obj;
IF IsSpecialCase[obj] THEN {
UnfinishedSymHeader[obj];
HandleSpecialCase[obj]
}
ELSE {
SymHeader[obj];
FOR directives: LIST OF REF ANY ← cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective ← NARROW[directives.first];
cifLayerAnnounced ← FALSE;
--IF currentDirective.deltaRadius>=0 THEN redundant but easier to understand
cifDrawRec.contextFilter ← contextFilter;
contextFilter[currentDirective.cdSource] ← TRUE;
obj.class.drawMe[inst: dummyInst, pos: [0, 0], orient: 0, pr: cifDrawRec];
contextFilter[currentDirective.cdSource] ← FALSE;
ENDLOOP;
};
SymTrailer[];
END;
MustCompensate: PROC [layer: CD.Layer] RETURNS [BOOL] =
BEGIN
FOR dList: LIST OF REF ANY ← cifDirectives, dList.rest WHILE dList#NIL DO
cdir: CIFDirective ← NARROW[dList.first];
IF cdir.cdSource=layer AND cdir.deltaRadius#0 THEN RETURN [TRUE];
ENDLOOP;
RETURN [FALSE];
END;
GeneratePolygon: PROC [obj: CD.Object] =
--output CIF for structures for polygons
BEGIN
CifPolygonOut: PROC [points: LIST OF CD.Position] =
--points are in design coords, not yet CIF coords
BEGIN
IF NOT cifLayerAnnounced THEN {
cifFile.PutF["L %g;\n", IO.rope[currentDirective.cifDest]];
cifLayerAnnounced ← TRUE;
};
cifFile.PutRope["P"];
FOR p: LIST OF CD.Position ← points, p.rest WHILE p#NIL DO
cifPos: CD.Position = CDPosToCIF[p.first];
cifFile.PutRope[" "];
CIFOutPoint[cifPos.x, cifPos.y];
ENDLOOP;
cifFile.PutRope[";\n"];
END;
polygon: CDCurves.CurvePtr = NARROW[obj.specificRef];
bad: BOOLFALSE;
SymHeader[obj];
FOR directives: LIST OF REF ANY ← cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective ← NARROW[directives.first];
cifLayerAnnounced ← FALSE;
IF currentDirective.cdSource=obj.layer THEN {
IF currentDirective.deltaRadius#0 THEN bad ← TRUE;
CifPolygonOut[polygon.points];
}
ENDLOOP;
IF bad THEN {
TerminalIO.WriteRope["**polygon shrink or bloat failed\n"];
cifFile.PutRope["( polygon has incorrect sizing );\n"];
};
SymTrailer[];
END;
CIFDefineObject: PROC [obj: CD.Object] =
--Print out CIF pertaining to object starting with the furthest object from the top; After leaving procedure, object will have been assigned a CIF ID # in its properties field
BEGIN
CheckChildren: CDDirectory.EnumerateObjectsProc =
BEGIN
CIFDefineObject[me]
END;
IF debugging THEN TerminalIO.WriteRope["Entering CIFDefineObject\n"];
IF CDProperties.GetObjectProp[obj, cellIDKey]#NIL THEN RETURN;
--non-NIL value indicates that object has already been assigned an ID # and is therefore already defined
--We should also make a test here to decide whether any hierarchical geometry results from this object, and assign a special value to this object's attribute $CellIDNo if not.
IF obj.class.inDirectory THEN {
CDDirectory.EnumerateChildObjects[obj, CheckChildren, NIL];
};
WITH obj.specificRef SELECT FROM
refPtr: CDImports.ImportPtr => {
IF refPtr.boundInstance=NIL THEN ERROR;
CIFDefineObject[refPtr.boundInstance.ob];
SymHeader[obj];
CIFDrawCellName[Rope.Cat[refPtr.designName, ".", refPtr.objectName]];
CIFSymbolCall[refPtr.boundInstance.ob, CD.original, [0, 0]];
SymTrailer[];
};
cellptr: CD.CellPtr => {
SymHeader[obj];
CIFDrawCellName[cellptr.name];
--For each member of the instance list, determine whether obj is a cell. If so, determine transformations
FOR instList: CD.InstanceList ← cellptr.contents, instList.rest WHILE instList#NIL DO
IF ~SimpleRect[instList.first.ob] THEN {
cifPos: CIFPos ← CDPosToCIF[CDOrient.MapPoint[
pointInCell: [0, 0],
cellSize: instList.first.ob.size,
cellInstOrient: instList.first.orientation,
cellInstPos: instList.first.location
]];
CIFSymbolCall[instList.first.ob, instList.first.orientation, cifPos];
};
ENDLOOP;
--for each layer, pick out the rectangles belonging to that layer
--and output them
FOR directives: LIST OF REF ANY ← cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective ← NARROW[directives.first];
cifLayerAnnounced ← FALSE;
--IF currentDirective.deltaRadius>=0 THEN removed for simplicity
FOR instList: CD.InstanceList ← cellptr.contents, instList.rest WHILE instList#NIL DO
IF SimpleRect[instList.first.ob] THEN {
instList.first.ob.class.drawMe[inst: instList.first, pos: instList.first.location, orient: instList.first.orientation, pr: cifDrawRec];
};
ENDLOOP;
ENDLOOP;
--generate all signal names
FOR instList: CD.InstanceList ← cellptr.contents, instList.rest WHILE instList#NIL DO
value: REF = CDProperties.GetInstanceProp[instList.first, $SignalName];
IF value#NIL THEN
IF SimpleRect[instList.first.ob] THEN
CIFLabelTerminalIO[instList.first, NARROW[value], instList.first.ob.layer];
ENDLOOP;
SymTrailer[];
}; -- of cell
ENDCASE => -- crazy or transistors or geometry or rects
IF obj.class.inDirectory THEN GenerateCompositeOb[obj]
ELSE IF ~SimpleRect[obj] THEN {
IF CDCurves.IsPolygon[obj] AND ~MustCompensate[obj.layer] THEN GeneratePolygon[obj]
ELSE GenerateGeometricOb[obj];
};
IF debugging THEN TerminalIO.WriteRope["Leaving CIFDefineObject\n"];
END;
CIFSymbolCall: PROC[ob: CD.Object, orient: CD.Orientation�Orient.original, pos: CD.Position← [0,0]] =
--pos in CIFUnits
--indicate which cell is called using its ID number
BEGIN
WITH CDProperties.GetObjectProp[ob, cellIDKey] SELECT FROM
iDNo: REF INT => {
cifFile.PutF["C %d", IO.int[iDNo^]];
IF orient#CD.original THEN {
xrotation: CD.Orientation ← CDOrient.ConcentrateOnRotate90[orient];
IF xrotation#CD.original THEN {
cifFile.PutRope[" R "];
cifFile.PutRope[SELECT xrotation FROM
CDOrient.rotate90 => "0,1" ,
CDOrient.rotate180=> "-1,0",
CDOrient.rotate270=> "0,-1",
ENDCASE=> "1,0" -- never use this one
];
};
IF CDOrient.IncludesMirrorX[orient] THEN cifFile.PutRope[" M X "];
};
IF pos#[0, 0] THEN {
cifFile.PutRope[" T "];
CIFOutPoint[pos.x, pos.y];
};
cifFile.PutRope[";\n"];
};
ENDCASE => ERROR;
END;
--OUTPUT PROCEDURES
CIFMeasureArea: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
-- CD.DrawRectProc
-- Sets mainRect to be a large as is necessary to contain design.
BEGIN
r ← CDBasics.NormalizeRect[r];
IF CDBasics.NonEmpty[r] THEN mainRect ← CDBasics.Surround[mainRect, r];
END;
IgnoreRect: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
BEGIN
END;
CIFOrArea: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
BEGIN
IF l=currentDirective.cdSource AND CDBasics.NonEmpty[r] THEN {
rd: CIFRect ← CDBasics.Extend[CDRectToCIF[CDBasics.NormalizeRect[r]], currentDirective.deltaRadius/nmPerCIF];
IF CDBasics.NonEmpty[rd] THEN CIFRectOut[rd];
}
END;
CIFRectOut: PROC [r: CIFRect] =
BEGIN
IF NOT CDBasics.NonEmpty[r] THEN RETURN;
IF NOT cifLayerAnnounced THEN {
cifFile.PutF["L %g;\n", IO.rope[currentDirective.cifDest]];
cifLayerAnnounced ← TRUE;
};
cifFile.PutF["B %d %d %d %d;\n",-- BOX command, in prescaled CIF units
IO.int[PrescaleCIF[[r.x2-r.x1, 1]]] -- length -- ,
IO.int[PrescaleCIF[[r.y2-r.y1, 1]]] -- width -- ,
IO.int[PrescaleCIF[[r.x1+r.x2, 2]]] -- center x-coord -- ,
IO.int[PrescaleCIF[[r.y1+r.y2, 2]]] -- center y-coord -- ];
END;
CIFOutPoint: PROC[x, y: CIFUnits] =
BEGIN
cifFile.PutF["%d,%d", IO.int[PrescaleCIF[[x,1]]], IO.int[PrescaleCIF[[y,1]]]]
END;
CIFLabelTerminalIO: PROC [ap: CD.Instance, s: Rope.ROPE, lev: CD.Layer] =
BEGIN
pt: CD.Position ← CDBasics.Center[CDRectToCIF[CDInstances.InstRectO[ap]]];
cifFile.PutF["94 %s ", IO.rope[s]];
CIFOutPoint[pt.x, pt.y];
cifFile.PutChar[' ];
FOR directives: LIST OF REF ANY ← cifDirectives, directives.rest WHILE directives#NIL DO
d: CIFDirective = NARROW[directives.first];
IF d.cdSource = lev THEN {cifFile.PutRope[d.cifDest]; EXIT};
ENDLOOP;
cifFile.PutRope[";\n"];
END;
CIFDrawCellName: PROC[s: Rope.ROPE] =
BEGIN
lastCellName ← s;
IF ~Rope.IsEmpty[s] THEN cifFile.PutF["9 %s;\n", IO.rope[s]];
END;
RopeNeeded: SIGNAL [ ref: REF REF ] = CODE;
ToRope: PROC [ ref: REF ] RETURNS [ rope: Rope.ROPE ] =
BEGIN
WITH ref SELECT FROM
r: Rope.ROPE => rope ← r;
rt: REF TEXT => rope ← Rope.FromRefText[rt];
a: ATOM => rope ← Atom.GetPName[a];
ri: REF INT => rope ← IO.PutFR[format: "%d", v1: IO.int[ri^]];
ENDCASE =>
IF ref=NIL THEN rope ← NIL
ELSE {
refRef: REF REF = NEW[REF ← ref];
SIGNAL RopeNeeded[refRef];
rope ← ToRope[refRef^ ! RopeNeeded => GOTO NoHelp];
EXITS NoHelp => ERROR;
};
END;
CantRepresentExactly: ERROR = CODE;
SetCIFScaling: PROC =
BEGIN
cifScaling ← ReduceTerms[[num: cifPerLambda, denom: 2*lambda]]; -- the "2" allows for box centers
FOR directives: LIST OF REF ANY ← cifDirectives, directives.rest WHILE directives#NIL DO
d: CIFDirective = NARROW[directives.first];
cif: CIFUnits;
IF ABS[d.deltaRadius] MOD nmPerCIF # 0 THEN
ERROR CantRepresentExactly;
cif ← ABS[d.deltaRadius]/nmPerCIF;
cifScaling ← ReduceTerms[[
num: cifScaling.num,
denom: (cifScaling.num*cifScaling.denom)/GCD[cif*cifScaling.denom, cifScaling.num]]];
--.. adds the condition that cif/cifScaling is guaranteed to be an integer, so cif*cifScaling.denom MOD cifScaling.num = 0
ENDLOOP;
END;
CollectDirectives: PROC =
BEGIN
GetDirectives: PROC [p: REF, lev: CD.Layer] RETURNS [l: LIST OF REF ANYNIL] =
BEGIN
IF p#NIL THEN {
WITH p SELECT FROM
d: CIFDest => l ← LIST[NEW[CIFDirectiveRec ← [lev, d.cifDest, d.deltaRadius]]];
list: LIST OF REF ANY => l ← List.Append[GetDirectives[list.first, lev], GetDirectives[list.rest, lev]];
ENDCASE => l ← LIST[NEW[CIFDirectiveRec ← [lev, ToRope[p], 0]]];
};
END;
cifDirectives ← NIL;
FOR layers: LIST OF CD.Layer ← design.technology.usedLayers, layers.rest WHILE layers#NIL DO
cifDirectives ← List.Append[GetDirectives[CDProperties.GetLayerProp[layers.first, $CDxCIFRegistrations], layers.first ], cifDirectives];
ENDLOOP;
END;
GetCifPerLambda: PROC [] =
BEGIN
WITH CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFUnitsPerLambda] SELECT FROM
ri: REF INT => cifPerLambda ← ri^;
ENDCASE => cifPerLambda ← 0;
TerminalIO.WriteF["using %g cif units per lambda; (1 CIF unit = 0.01 microns)\n", IO.int[cifPerLambda]] ;
IF cifPerLambda<2 THEN {
TerminalIO.WriteRope["cif units per lambda not reasonable\n"];
ERROR ABORTED
};
END;
WriteCIF: PROC[ comm: CDSequencer.Command] =
BEGIN
ENABLE BEGIN
ABORTED => {TerminalIO.WriteRope[" CIF generation aborted\n"]; GOTO Exit};
RopeNeeded => {
explanation: Rope.ROPE = IO.PutFR[format: "Please enter a string corresponding to the value %g: ", v1: IO.refAny[ref^]];
ref^ ← TerminalIO.RequestRope[explanation];
RESUME;
};
UNWIND => NULL;
END; --enable
--assign world variable from sequencer
mainOb: CD.Object;
cifKey: Rope.ROPE;
design ← comm.design;
lambda ← design.technology.lambda;
SetUpSpecialClasses[];
cifKey ← ToRope[CDProperties.GetProp[$CDxCIFRegistrations, $CDxCIFName]];
IF Rope.IsEmpty[cifKey] THEN {
TerminalIO.WriteRope["The CIF layers for this technology are not yet defined\n"];
RETURN
};
TerminalIO.WriteRopes["Use CIF layer definitions [", cifKey, "]\n"];
--initialize main object, layer names, resolution, cellCount, and draw records
mainOb ← CDExtras.CreateDummyObject[design];
cellCount ← 0;
stopFlag^ ← FALSE;
cifMeasureR ← CD.CreateDrawRef[[
interestClip: CDBasics.universe,
drawRect: CIFMeasureArea,
stopFlag: stopFlag,
design: design
]];
clearIDsRec ← CD.CreateDrawRef[[
interestClip: CDBasics.universe,
drawChild: ClearCellIDs,
stopFlag: stopFlag,
design: design
]];
cifDrawRec ← CD.CreateDrawRef[[
interestClip: CDBasics.universe,
drawRect: CIFOrArea,
stopFlag: stopFlag,
design: design
]];
--Search world data structure: normalize coordinates,
--set mainRect to design size, mark used layers
CDOps.DrawDesign[design, cifMeasureR];
GetCifPerLambda[];
--get file name
TerminalIO.WriteRopes["Input name of CIF file (", CDIO.GetWorkingDirectory[design], ") "];
base ← TerminalIO.RequestRope[">> "];
IF Rope.IsEmpty[base] THEN base ← design.name;
IF Rope.IsEmpty[base] THEN base ← "foo";
name ← CDIO.MakeName[base: base, ext: ".cif", wDir: CDIO.GetWorkingDirectory[design]];
cifFile ← FS.StreamOpen[name, create !
FS.Error =>
IF error.group#bug THEN {
TerminalIO.WriteRope[error.explanation];
GOTO FileIOOpenFailed;  
}
];
cifPerCD ← cifPerLambda/lambda; need not be integer..
--output header
cifFile.PutF["( %s );\n", IO.rope[design.name]];
cifFile.PutF["( generated %g by Xerox PARC ChipNDale and BrandyCIFter);\n", IO.time[]];
cifFile.PutF["( with lambda = %d CIF units );\n", IO.int[cifPerLambda]];
cifFile.PutF["( origin = [x: 0, y: 0], size = [x: %d, y: %d] CIF units );\n", IO.int[CDCIFUp[mainRect.x2-mainRect.x1]], IO.int[CDCIFUp[mainRect.y2-mainRect.y1]]];
cifFile.PutF["( CIF KEY: %s );\n", IO.rope[cifKey]];
--ask for comment lines
TerminalIO.WriteRope["Comment line: \n"];
comment ← TerminalIO.RequestRope["(parens must balance, CR for no comment)\n>> "];
WHILE NOT Rope.IsEmpty[comment] DO
cifFile.PutF["( %s );\n", IO.rope[comment]];
comment ← NIL;
TerminalIO.WriteRope["Another comment line:\n"];
comment←TerminalIO.RequestRope[
"(parens must balance, CR for no further comments)\n>> "];
ENDLOOP;
IO.PutChar[cifFile, IO.CR];
CollectDirectives[];
SetCIFScaling[];
ClearCellIDs[design.actual.first.dummyCell, [0,0], 0, NIL];
CIFDefineObject[mainOb];
--define hybrid top layer object
SymHeader[topLayerOb];
CIFSymbolCall[mainOb];
FOR directives: LIST OF REF ANY ← cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective ← NARROW[directives.first];
IF currentDirective.deltaRadius<0 THEN {
cifLayerAnnounced ← FALSE;
MakeFlatCIF[rectProc: CIFRectOut];
};
ENDLOOP;
SymTrailer[];
CIFSymbolCall[topLayerOb, CDOrient.original, [x: -cifPerLambda*mainRect.x1/lambda, y: -cifPerLambda*mainRect.y2/lambda]];
cifFile.PutRope[";\nEnd ... \n"];
cifFile.Close[];
TerminalIO.WriteF["\nCIF file on %g\n", IO.rope[name]];
FreeStorage[]
EXITS
Exit => FreeStorage[];
FileIOOpenFailed => {
TerminalIO.WriteRope["Open Failed\n"];
FreeStorage[]
};
END; -- of WriteCIF
--Flat CIF code
MakeFlatCIF: PROC [rectProc: PROC[rect: CIFRect]] =
BEGIN
AnalyzeTesselation: PROC [ms: MaskStateRef] =
BEGIN
--the tesselation is in cif coordinates
active: CD.Rect = ms.areas.BBox[];
IF CDBasics.NonEmpty[active] THEN {
IF currentDirective.deltaRadius#0 THEN {
t: CStitching.Tesselation = ms.unbloated;
ms.unbloated ← ms.areas;
ms.areas ← t;
CStitching.ChangeRect[plane: ms.areas, rect: CDBasics.universe, new: NIL];
IF currentDirective.deltaRadius>0 THEN
CStitching.EnumerateArea[plane: ms.unbloated, rect: CDBasics.universe, eachTile: BloatTile, data: ms]
ELSE {
CStitching.ChangeRect[plane: ms.areas, rect: active, new: $covered];
CStitching.EnumerateArea[plane: ms.unbloated, rect: CDBasics.universe, eachTile: BloatTile, data: ms,
skip: $covered];
};
};
CStitching.EnumerateArea[plane: ms.areas, rect: CDBasics.universe,
eachTile: OutputTile, data: ms];
TerminalIO.WriteRope["."];
};
END;
OutputTile: PROCEDURE [tile: CStitching.Tile, data: REF ANY] =
-- CStitching.PerTileProc
BEGIN -- only called on tiles with non-NIL values
ms: MaskStateRef = NARROW[data];
cr: CIFRect = CDBasics.Intersection[tile.Area, ms.partClip];
rectProc[cr];
END;
designClip: CD.Rect;
cifClip: CD.Rect;
nRows, nCols: NAT;
ms: MaskStateRef = NEW[MaskState ← [
areas: CStitching.NewTesselation[],
unbloated: CStitching.NewTesselation[]
]];
dr: CD.DrawRef ← CD.CreateDrawRef[[
drawRect: NoteBoundingBox,
devicePrivate: NEW[CD.Rect ← CDBasics.empty],
interestClip: CDBasics.universe,
stopFlag: stopFlag,
design: design
]];
CDOps.DrawDesign[design, dr]; -- measure design
designClip ← NARROW[dr.devicePrivate, REF CD.Rect]^;
cifClip ← Bloat[CDRectToCIF[designClip], ABS[currentDirective.deltaRadius]/nmPerCIF];
nRows ← Ceiling[num: cifClip.y2-cifClip.y1, denom: partHeight];
nCols ← Ceiling[num: cifClip.x2-cifClip.x1, denom: partWidth];
TerminalIO.WriteF[".. in %d rows and %d columns..", IO.int[nRows], IO.int[nCols]];
dr.drawRect ← NoteRectangle;
dr.devicePrivate ← ms;
TerminalIO.WriteF["%s -> %s", IO.rope[ToRope[CD.LayerKey[currentDirective.cdSource]]], IO.rope[currentDirective.cifDest]];
FOR col: NAT IN [0..nCols) DO
FOR row: NAT IN [0..nRows) DO
ms.areas.ChangeRect[rect: CDBasics.universe, new: NIL];
ms.partClip ← [ -- in cif space
x1: cifClip.x1+col*partWidth,
y1: cifClip.y1+row*partHeight,
x2: cifClip.x1+col*partWidth+MIN[partWidth, cifClip.x2-cifClip.x1-partWidth*col],
y2: cifClip.y1+row*partHeight+MIN[partHeight, cifClip.y2-cifClip.y1-partHeight*row]
];
dr.interestClip ← CIFRectToCD[CDBasics.Extend[ms.partClip, 1+ABS[currentDirective.deltaRadius]/nmPerCIF]];
CDVArrow.ShowArrow[design: design,
pos: [x: (dr.interestClip.x1+dr.interestClip.x2)/2, y: (dr.interestClip.y1+dr.interestClip.y2)/2]]; -- keep user happy
CDOps.DrawDesign[design, dr]; -- build tesselation of the relevant design rectangle
AnalyzeTesselation[ms]; -- sends the current part to s
ENDLOOP;
ENDLOOP;
TerminalIO.WriteRope["+"];
CDVArrow.RemoveArrow[design: design];
dr ← NIL;
END;
NoteBoundingBox: PROC [ r: CD.Rect, l: CD.Layer, pr: CD.DrawRef ] =
BEGIN
bb: REF CD.Rect = NARROW[pr.devicePrivate];
bb^ ← CDBasics.Surround[bb^, r];
END;
NoteRectangle: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
BEGIN
ms: MaskStateRef = NARROW[pr.devicePrivate];
IF l=currentDirective.cdSource AND CDBasics.NonEmpty[r] THEN
ms.areas.ChangeRect[rect: CDRectToCIF[r], new: $covered];
END;
BloatTile: PROCEDURE [tile: CStitching.Tile, data: REF ANY] =
-- CStitching.PerTileProc --
BEGIN
ms: MaskStateRef = NARROW[data];
cr: CD.Rect = CDBasics.Intersection[CDBasics.universe, Bloat[tile.Area, ABS[currentDirective.deltaRadius/nmPerCIF]]];
IF CDBasics.NonEmpty[cr] THEN
ms.areas.ChangeRect[rect: cr, new: tile.value];
END;
Bloat: PROC [r: CD.Rect, delta: CD.Number] RETURNS [br: CD.Rect] = INLINE
BEGIN
--Be careful not to exceed the limits of a CD.Number, even temporarily
br ← [x1: MAX[FIRST[CD.Number]+delta, r.x1]-delta,
y1: MAX[FIRST[CD.Number]+delta, r.y1]-delta,
x2: MIN[LAST[CD.Number]-delta, r.x2]+delta,
y2: MIN[LAST[CD.Number]-delta, r.y2]+delta]
END;
CDRectToCIF: PROC [ cdr: CD.Rect ] RETURNS [ cifr: CIFRect ] =
BEGIN
cifr ← CDBasics.NormalizeRect[[
x1: cifPerLambda*cdr.x1/lambda,
y1: cifPerLambda*cdr.y1/lambda,
x2: cifPerLambda*cdr.x2/lambda,
y2: cifPerLambda*cdr.y2/lambda
]]
END;
CDPosToCIF: PROC [ cdp: CD.Position ] RETURNS [ cifp: CIFPos ] =
BEGIN
cifp ← [x: cifPerLambda*cdp.x/lambda, y: cifPerLambda*cdp.y/lambda]
END;
CDCIFUp: PROC [ n: CD.Number ] RETURNS [ cif: CIFUnits ] =
BEGIN
cif ← (cifPerLambda*n+lambda-1)/lambda
END;
CIFRectToCD: PROC [ cifr: CIFRect ] RETURNS [ cdr: CD.Rect ] =
--rounds to rect beeing bigger
BEGIN
cdr ← CDBasics.NormalizeRect[[
x1: lambda*cifr.x1/cifPerLambda,
y1: lambda*cifr.y1/cifPerLambda,
x2: (lambda*cifr.x2+cifPerLambda-1)/cifPerLambda,
y2: (lambda*cifr.y2+cifPerLambda-1)/cifPerLambda
]]
END;
PrescaleCIF: PROC [ cif: Rational ] RETURNS [ INT ] =
BEGIN
n: INT = cif.num*cifScaling.denom;
d: INT = cif.denom*cifScaling.num;
IF ABS[n] MOD ABS[d] # 0 THEN ERROR CantRepresentExactly;
RETURN[n/d];
END;
Ceiling: PROC [num, denom: CD.Number] RETURNS [ c: INT ] =
BEGIN
c ← (num+denom-1)/denom
END;
ReduceTerms: PROC [ r: Rational ] RETURNS [ Rational ] =
BEGIN
gcd: INT = GCD[r.num, r.denom];
RETURN[[num: r.num/gcd, denom: r.denom/gcd]];
END;
GCD: PROC [ m, n: INT ] RETURNS [ INT ] =
BEGIN
r: INT;
SELECT m FROM
<0 => m ← -m;
ENDCASE => NULL;
SELECT n FROM
<0 => n ← -n;
>0 => NULL;
ENDCASE => RETURN[m];
r ← m MOD n;
WHILE r>0 DO m ← n; n ← r; r ← m MOD n; ENDLOOP;
RETURN[n];
END;
WriteCIFComm: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Hierarchical CIF output\n"];
TerminalIO.WriteRope["Version of December 6, 1985 11:17:55 am PST\n"];
TerminalIO.WriteRope["better read back the cif file and look at it\n"];
IF CDCells.IsPushedIn[comm.design] THEN {
TerminalIO.WriteRope["**Design is pushed in\n"];
RETURN
};
IF CDImports.HasUnloadedImports[comm.design] THEN {
TerminalIO.WriteRope["**Design has non bound imports\n"];
RETURN
};
[] ← CDCommandOps.CallWithResource[WriteCIF, comm, $CIF, stopFlag];
END;
RegisterRegistration: PROC [] =
TRUSTED BEGIN
new: LIST OF REF ANY
LIST[$CDxCIFName, $CDxCIFTechnology, $CDxCIFSpecials, $CDxCIFUnitsPerLambda];
list: LIST OF REF ANYWITH CDProperties.GetAtomProp[$RegistrationRoot, $CDxCIFRegistrations] SELECT FROM
lora: LIST OF REF ANY => lora,
loa: LIST OF ATOM => LOOPHOLE[loa],
a: ATOM=> LIST[a],
ENDCASE => NIL;
list ← List.Nconc[list, new];
CDProperties.PutAtomProp[onto: $RegistrationRoot, prop: $CDxCIFRegistrations, val: list];
END;
RegisterRegistration[];
CDSequencer.ImplementCommand[key: $WriteCif, proc: WriteCIFComm, queue: doQueue];
CDMenus.CreateEntry[menu: $ProgramMenu, entry: "Hierarchical CIF", key: $WriteCif];
END.