DIRECTORY
Atom USING [GetPName],
CD,
CDBasics,
CDCells,
CDCommandOps,
CDDirectory,
CDExtras,
CDImports,
CDInstances USING [InstRectO],
CDIO,
CDMenus,
CDOps USING [DrawDesign],
CDOrient,
CDPolygons,
CDProperties,
CDSequencer USING [Command, ImplementCommand],
CDViewer USING [RemoveArrow, ShowArrow],
CornerStitching,
FS USING [StreamOpen, Error],
Imager USING [black],
IO USING [Close, CR, int, PutChar, PutF, PutFR, PutRope, PutText, refAny, rope, STREAM, time],
List USING [Append, Nconc],
Rope,
TerminalIO;
cellIDKey: REF ATOM = NEW[ATOM ← $CellIDNo]; --not accessible
debugging: BOOLEAN ← FALSE; -- used for printing out debugging messages
design: CD.Design ;
topLayerOb: CD.Object ← NEW[CD.ObjectRep];
stopFlag: REF BOOLEAN ← NEW[BOOLEAN];
clearIDsRec: CD.DrawRef;
cifMeasureR: CD.DrawRef;
cifDrawRec:
CD.DrawRef;
--for CIFOrArea
contextFilter: REF CD.ContextFilter ← NEW[CD.ContextFilter←ALL[NIL]]; --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:
BOOLEAN ←
FALSE;
--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;
--%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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:
BOOL←
FALSE] =
BEGIN
yes ← CDProperties.GetPropFromList[specialProperties^, ob.class.objectType]#NIL
END;
HandleSpecialCase:
PROC [ob:
CD.Object] =
BEGIN
WITH CDProperties.GetPropFromList[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.PutPropOnObject[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 INT ← NEW[INT ← (cellCount ← cellCount + 1)];
cifFile.PutF["DS %d %d %d;\n",
IO.int[cellCount], IO.int[cifScaling.num], IO.int[cifScaling.denom]];
CDProperties.PutPropOnObject[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 INT ← NEW[INT ← (cellCount ← cellCount + 1)];
cifFile.PutF["DS %d ",
IO.int[cellCount]];
CDProperties.PutPropOnObject[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[NIL]];
pr: CD.DrawRef ← CD.CreateDrawRef[design];
dummyApPtr:
CD.Instance =
NEW[
CD.InstanceRep];
--match the type of drawMe parameter
dummyApPtr^.ob ← obj;
pr.stopFlag ← stopFlag;
SymHeader[obj];
CIFDrawCellName[CDDirectory.Name[obj]];
--call the children
pr.contextFilter ← NIL;
pr.drawChild ← CallChildren;
pr.drawRect ← IgnoreRect;
obj.class.drawMe[dummyApPtr, [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] ← Imager.black;
obj.class.drawMe[dummyApPtr, [0, 0], CD.original, pr];
cf[currentDirective.cdSource] ← NIL;
ENDLOOP;
SymTrailer[];
END;
GenerateGeometricOb:
PROC [obj:
CD.Object] =
--output CIF for structures only identified as geometries
BEGIN
dummyApPtr:
CD.Instance =
NEW[
CD.InstanceRep];
--match the type of drawMe parameter
dummyApPtr^.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] ← Imager.black;
obj.class.drawMe[inst: dummyApPtr, pos: [0, 0], orient: 0, pr: cifDrawRec];
contextFilter[currentDirective.cdSource] ← NIL;
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: CDPolygons.PolygonPtr = NARROW[obj.specificRef];
bad: BOOL ← FALSE;
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.GetPropFromObject[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.GetPropFromInstance[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 ISTYPE[obj.specificRef, CDPolygons.PolygonPtr] 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.GetPropFromObject[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
ANY ←
NIL] =
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.GetPropFromLayer[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[design];
cifMeasureR.interestClip ← CDBasics.universe;
cifMeasureR.drawRect ← CIFMeasureArea;
cifMeasureR.stopFlag ← stopFlag;
clearIDsRec ← CD.CreateDrawRef[design];
clearIDsRec.interestClip ← CDBasics.universe;
clearIDsRec.drawChild ← ClearCellIDs;
clearIDsRec.stopFlag ← stopFlag;
cifDrawRec ← CD.CreateDrawRef[design];
cifDrawRec.interestClip ← CDBasics.universe;
cifDrawRec.drawRect ← CIFOrArea;
cifDrawRec.stopFlag ← stopFlag;
--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
MakeFlatCIF:
PROC [rectProc:
PROC[rect: CIFRect]] =
BEGIN
AnalyzeTesselation:
PROC [ms: MaskStateRef] =
BEGIN
--the tesselation is in cif coordinates
active: CD.Rect = ms.areas.ContentsBound[rect: CDBasics.universe];
IF CDBasics.NonEmpty[active]
THEN {
IF currentDirective.deltaRadius#0
THEN {
t: REF CornerStitching.Tesselation = ms.unbloated;
ms.unbloated ← ms.areas;
ms.areas ← t;
CornerStitching.ChangeRect[plane: ms.areas, rect: CDBasics.universe, newValue: NIL];
IF currentDirective.deltaRadius>0
THEN
CornerStitching.EnumerateArea[plane: ms.unbloated, rect: CDBasics.universe, perTile: BloatTile, data: ms]
ELSE {
CornerStitching.ChangeRect[plane: ms.areas, rect: active, newValue: $covered];
CornerStitching.EnumerateArea[plane: ms.unbloated, rect: CDBasics.universe, perTile: BloatTile, data: ms,
skipValue: $covered];
};
};
CornerStitching.EnumerateArea[plane: ms.areas, rect: CDBasics.universe,
perTile: OutputTile, data: ms];
TerminalIO.WriteRope["."];
};
END;
OutputTile:
PROCEDURE [tile: REF CornerStitching.Tile, data:
REF
ANY]
=
-- CornerStitching.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: CornerStitching.NewTesselation[],
unbloated: CornerStitching.NewTesselation[]
]];
dr: CD.DrawRef ← CD.CreateDrawRef[design];
dr.minimalSize ← 0;
dr.drawRect ← NoteBoundingBox;
dr.devicePrivate ← NEW[CD.Rect ← CDBasics.empty];
dr.interestClip ← CDBasics.universe;
dr.stopFlag ← stopFlag;
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, newValue: 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]];
CDViewer.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["+"];
CDViewer.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],
newValue: $covered
];
END;
BloatTile:
PROCEDURE [tile: REF CornerStitching.Tile, data:
REF
ANY]
=
-- CornerStitching.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, newValue: 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];
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;
CDMenus.CreateEntry[menu: $ProgramMenu, entry: "Hierarchical CIF", key: $WriteCif];