DIRECTORY
TerminalIO USING [RequestRope, RequestInt, WriteRope, WriteInt],
CDOrient,
CD USING [Level, LevelKey, Rect, FetchLevel, lambda, ObPtr, CellPtr, Number, Position, DesignNumber, DesignPosition, DesignRect, Application, ApplicationPtr, ApplicationList, CellRecord, Orientation, ObjectDefinition, Properties, Design, CreateDrawRef, DrawRectProc, DrawRef, DrawProc, DrawInformation],
CDIO,
CDMenus,
CornerStitching USING [ Tesselation, TilePtr, NewTesselation, ContentsBound, ChangeRect, EnumerateArea, Area, Value],
IO USING [ STREAM, time, PutRope, PutChar, CR, PutF, PutFR, int, rope, refAny, Close],
List USING [Append],
FS USING [StreamOpen, Error],
Rope USING [ROPE, IsEmpty, FromRefText],
Atom USING [GetPropFromList, PutPropOnList, GetPName],
CDApplications USING [ARectO],
CDBasics USING [empty, universe, Extend, NormalizeRect, NonEmpty, Intersection, Surround, Center],
CDCommandOps,
CDOps USING [DrawDesign],
CDProperties USING [GetPropFromLevel, PutPropOnObject],
CDSequencer USING [Command, ImplementCommand],
CDViewer USING [ShowArrow, RemoveArrow];
  
 
BrandyCIFter: CEDAR PROGRAM
IMPORTS
List, CornerStitching, TerminalIO, CDIO, CDMenus, CDCommandOps, CDOrient, CD, CDBasics, IO, FS, Rope, Atom, CDApplications, CDOps, CDProperties, CDSequencer, CDViewer =
  
BEGIN

CIFUnits: TYPE = CD.Number;
CIFRect: TYPE = CD.Rect -- in CIFUnits -- ;
Rational: TYPE = RECORD [num, denom: INT _ 1];
CoordRect: TYPE = RECORD [ x1, y1, x2, y2: CD.DesignNumber ];
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.Level,
cifDest: Rope.ROPE,
deltaRadius: INT -- nanometers, + means cif is bigger
];
MaskStateRef: TYPE = REF MaskState;
MaskState: TYPE = RECORD [
areas, unbloated: REF CornerStitching.Tesselation _ NIL, 
partClip: CIFRect _ [0,0,0,0]
];


debugging: BOOLEAN _ FALSE;  -- used for printing out debugging messages

design: CD.Design ; -- Chipndale data structure for which CIF will be written
mainOb: CD.ObPtr _ NEW[CD.ObjectDefinition];
topLevelOb: CD.ObPtr _ NEW[CD.ObjectDefinition];
mainCellPtr: CD.CellPtr _ NEW[CD.CellRecord];
stopFlag: REF BOOLEAN _ NEW[BOOLEAN];
clearIDsRec: CD.DrawRef;  
cifMeasureR: CD.DrawRef;
cifDrawRec:  CD.DrawRef; --for cifOrArea

infinity: CD.DesignNumber _  LAST[CD.DesignNumber];  --used to initialize sizes and positions
  
cellCount: INTEGER _ 0;   -- used to assign consecutive CIF ID numbers

cifLayerAnnounced: BOOLEAN _ FALSE;

lambda: INT _ CD.lambda;
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;

cifFile:  IO.STREAM;-- file where output will be stored
comment, base, name, lastCellName: Rope.ROPE;

mainRect: CoordRect _ [x1: infinity, y1: infinity, x2:-infinity, y2:-infinity];
cifDirectives: LIST OF REF ANY -- CIFDirective --  _ NIL;
currentDirective: CIFDirective;

partWidth: CIFUnits _ 800000; -- window for flat CIF
partHeight: CIFUnits _ 800000;

  

ClearCellIDs: PROC [ aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation, pr: REF CD.DrawInformation ] -- CD.DrawProc -- =
BEGIN
zeroID: REF INTEGER  _ NIL;
CDProperties.PutPropOnObject[onto: aptr.ob, prop: $CellIDNo, val: zeroID];
IF aptr.ob.p.inDirectory THEN
aptr.ob.p.drawMe[aptr: aptr, pos: aptr.location, orient: aptr.orientation, pr: clearIDsRec]; 
END;


ValueOf: PROC[ prop: CD.Properties, key: ATOM] RETURNS [REF ANY] =
{ RETURN [Atom.GetPropFromList[prop, key]]};

SymHeader: PROC [obj: CD.ObPtr]=
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]];
obj.properties _ Atom.PutPropOnList[ obj.properties, $CellIDNo, cellID];
END;

SymTrailer: PROC =
BEGIN
cifFile.PutRope["DF;\n"];
END;

GenerateGeometricOb: PROC [obj: CD.ObPtr, ap: CD.ApplicationPtr, dr: CD.DrawRef] =
BEGIN
SymHeader[obj];
FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
BEGIN
currentDirective _ NARROW[directives.first];
cifLayerAnnounced _ FALSE;
IF currentDirective.deltaRadius>=0 THEN
ap.ob.p.drawMe[aptr: ap,  pos: [x: 0, y: 0], orient: 0, pr: dr];
END;
ENDLOOP;
SymTrailer[];
END;  -- of GenerateGeometricOb

CIFDefineObject: PROC [obj: CD.ObPtr] =
BEGIN
ap: CD.ApplicationPtr;-- used as an abbrev. for "aplist.first"
dummyApPtr: CD.ApplicationPtr _ NEW[CD.Application]; -- used to match the type a drawMe parameter requires
value: Rope.ROPE;-- used to determine signal names

IF debugging THEN TerminalIO.WriteRope["Entering CIFDefineObject\n"];
  
IF ValueOf[obj.properties, $CellIDNo] # NIL THEN RETURN;   
  

WITH obj.specificRef SELECT   FROM
cellptr: CD.CellPtr =>
BEGIN
aplist: CD.ApplicationList;
FOR aplist _ cellptr.contents, aplist.rest WHILE aplist # NIL DO
CIFDefineObject[aplist.first.ob]
ENDLOOP;

SymHeader[obj];

CIFDrawCellName[cellptr.name];

FOR aplist _ cellptr.contents, aplist.rest WHILE aplist # NIL DO
SELECT aplist.first.ob.specificRef  FROM
NIL => NULL;-- NIL indicates Rect
ENDCASE =>
BEGIN
cifRect: CIFRect;
IF debugging THEN TerminalIO.WriteRope["  Transformations\n"];
ap _ aplist.first;
cifRect  _ CDRectToCIF[CDOrient.MapRect[
itemInCell: [0, 0, 0, 0], 
cellSize: [x: ap.ob.size.x, y: ap.ob.size.y],
cellInstOrient: ap.orientation,
cellInstPos: [x: ap.location.x, y: ap.location.y]]];
CIFSymbolCall[ap.ob, ap.orientation, [cifRect.x1, cifRect.y1]];
END;
ENDLOOP;

FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
BEGIN
currentDirective _ NARROW[directives.first];
cifLayerAnnounced _ FALSE;
FOR aplist _ cellptr.contents, aplist.rest WHILE aplist # NIL DO
BEGIN
ap _ aplist.first;
SELECT ap.ob.specificRef  FROM
NIL => -- indicates Rect
IF currentDirective.deltaRadius>=0 THEN
ap.ob.p.drawMe[ aptr: ap, pos: ap.location, orient: ap.orientation, pr: cifDrawRec];
ENDCASE => NULL;
END;
ENDLOOP;
END;
ENDLOOP;

FOR aplist _ cellptr.contents, aplist.rest WHILE aplist # NIL DO
BEGIN
value _NARROW[
Atom.GetPropFromList[aplist.first.ob.properties,$signalName]];
IF ValueOf[aplist.first.ob.properties, $signalName] # NIL THEN
SELECT aplist.first.ob.specificRef FROM
NIL => CIFLabelTerminalIO[aplist.first, value, aplist.first.ob.level];
ENDCASE => NULL;
END;
ENDLOOP;

 
SymTrailer[];
END; -- of cell

ENDCASE => -- transistors or geometry or rects
IF obj.specificRef = NIL THEN NULL
ELSE
BEGIN
dummyApPtr^.ob _ obj;  -- drawMe requires an ApplicationPtr
GenerateGeometricOb[obj: obj, ap: dummyApPtr , dr: cifDrawRec];
END;
 
IF debugging THEN TerminalIO.WriteRope["Leaving CIFDefineObject\n"];

END; -- of CIFDefineObject


CIFSymbolCall: PROC[ob: CD.ObPtr, orient: CD.Orientation _ CDOrient.original, pos: CD.Position -- CIFUnits -- _ [0,0]] =
BEGIN
v: REF = ValueOf[ob.properties, $CellIDNo];
IF v = NIL THEN ERROR;
WITH v SELECT FROM
IDNo: REF INT =>
BEGIN
cifFile.PutF["C %d", IO.int[IDNo^]];
IF orient # 0 THEN
BEGIN
xrotation: CD.Orientation _ CDOrient.ConcentrateOnRotate90[orient];
IF  xrotation # 0 THEN
BEGIN
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
END;
IF CDOrient.IncludesMirrorX[orient] THEN
cifFile.PutRope[" M X "];
END;
IF (pos.x # 0) OR (pos.y # 0) THEN
BEGIN
cifFile.PutRope[" T "];
CIFOutPoint[pos.x, pos.y];
END;
cifFile.PutRope[";\n"];
END;
ENDCASE => NULL;
END;
  

  
cifMeasureArea: PROC [ r: CD.DesignRect,  l: CD.Level, pr: CD.DrawRef] -- CD.DrawRectProc -- =
BEGIN
r _ CDBasics.NormalizeRect[r];
IF NOT CDBasics.NonEmpty[r] THEN  RETURN;
mainRect _
[x1: MIN[r.x1, mainRect.x1], y1: MIN[r.y1, mainRect.y1], 
x2: MAX[r.x2, mainRect.x2], y2: MAX[r.y2, mainRect.y2]];
END; -- of cifMeasureArea
  
cifOrArea: PROC [r: CD.DesignRect, l: CD.Level, pr: CD.DrawRef]  =
BEGIN
rd: CD.DesignRect;
IF (l # currentDirective.cdSource) OR NOT CDBasics.NonEmpty[r] THEN RETURN;
rd _ CDBasics.NormalizeRect[r];
CIFRectOut[CDBasics.Extend[r: CDRectToCIF[CDBasics.NormalizeRect[r]], ext: currentDirective.deltaRadius/nmPerCIF]];
END; 

   
CIFRectOut: PROC [r: CIFRect] =
BEGIN
IF NOT CDBasics.NonEmpty[r] THEN RETURN;
IF NOT cifLayerAnnounced THEN
BEGIN
cifFile.PutF["L %g;\n", IO.rope[currentDirective.cifDest]];
cifLayerAnnounced _ TRUE;
END;
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] =
{cifFile.PutF["%d,%d", IO.int[PrescaleCIF[[x,1]]], IO.int[PrescaleCIF[[y,1]]]]};

CIFLabelTerminalIO: PROC [ ap: CD.ApplicationPtr, s: Rope.ROPE, lev: CD.Level] =
BEGIN
pt: CD.Position _ CDBasics.Center[CDRectToCIF[CDApplications.ARectO[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;
cifFile.PutF["9 %s;\n", IO.rope[IF Rope.IsEmpty[s] THEN "unnamed cell" ELSE s]];
END;
 

RopeNeeded: SIGNAL [ ref: REF REF ] = CODE;

ToRope: PROC [ ref: REF ] RETURNS [ rope: Rope.ROPE ] =
BEGIN
IF ref = NIL THEN rope _ NIL
ELSE 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 =>
BEGIN
refRef: REF REF = NEW[REF _ ref];
SIGNAL RopeNeeded[refRef];
rope _ ToRope[refRef^ ! RopeNeeded => GOTO NoHelp];
EXITS
NoHelp => ERROR;
END;
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]]];
ENDLOOP;
END;


CollectDirectives: PROC =
BEGIN

GetDirectives: PROC [p: REF, lev: CD.Level] RETURNS [l: LIST OF REF ANY _ NIL] =
BEGIN
IF p#NIL THEN
BEGIN
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;
END;

cifDirectives _ NIL;
FOR levels: LIST OF CD.Level _ design.technology.usedLevels, levels.rest WHILE levels # NIL DO
cifDirectives _ List.Append[GetDirectives[CDProperties.GetPropFromLevel[levels.first, $CDxCIFName], levels.first ], cifDirectives];
ENDLOOP;
END;

  
WriteCIF: PROC[ comm: CDSequencer.Command] =
BEGIN ENABLE
BEGIN
ABORTED => {TerminalIO.WriteRope["  CIF generation aborted\n"]; GOTO Exit};
RopeNeeded =>
BEGIN
explanation: Rope.ROPE = IO.PutFR[format: "Please enter a string corresponding to the value %g: ", v1: IO.refAny[ref^]];
ref^ _ TerminalIO.RequestRope[explanation];
RESUME;
END;
UNWIND => NULL;
END;
 
design _ comm.design;
 
mainCellPtr _ design.actual.first.specific;
 
mainOb^_ [
p:  NIL,
size:  [x: infinity,  y: infinity],
level: CD.FetchLevel[t: design.technology, uniqueKey: $NOcOL],
specificRef:  mainCellPtr
];

cellCount _ 0;
stopFlag^ _ FALSE;
 
cifMeasureR _ CD.CreateDrawRef[design];
cifMeasureR.interestClip _ CDBasics.universe;
cifMeasureR.drawRect _ cifMeasureArea;

clearIDsRec _ CD.CreateDrawRef[design];
clearIDsRec.interestClip _ CDBasics.universe;
clearIDsRec.drawChild _ ClearCellIDs;
clearIDsRec.stopFlag _ stopFlag;
 
cifDrawRec  _ CD.CreateDrawRef[design: design];
cifDrawRec.interestClip _ CDBasics.universe;
cifDrawRec.drawRect _ cifOrArea;
 
 
CDOps.DrawDesign[design,  cifMeasureR];  
 
TerminalIO.WriteRope["Please input name of CIF file ("];
TerminalIO.WriteRope[CDIO.GetWorkingDirectory[design]];
TerminalIO.WriteRope[") "];
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]];
TerminalIO.WriteRope["Output file will be "];
TerminalIO.WriteRope[name];
TerminalIO.WriteRope["\n"];
cifFile _ FS.StreamOpen[name,  create ! 
FS.Error => 
IF error.group#bug THEN { 
TerminalIO.WriteRope[error.explanation]; 
GOTO FileIOOpenFailed; }
];
 
TerminalIO.WriteRope["How many CIF units per lambda?\n"];
cifPerLambda _ TerminalIO.RequestInt[" (1 CIF unit = 0.01 microns) \n", ">> "];
IF cifPerLambda<2 THEN {
TerminalIO.WriteRope["cif Per Lambda value not reasonable\n"];
RETURN
};
IF debugging THEN { 
TerminalIO.WriteRope["cif Per Lambda = "];
TerminalIO.WriteInt[cifPerLambda];
TerminalIO.WriteRope["\n"];
};
cifPerCD _ cifPerLambda/lambda;

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[cifPerCD*(mainRect.x2-mainRect.x1)], IO.int[cifPerCD*(mainRect.y2-mainRect.y1)]];

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];

SymHeader[topLevelOb];
CIFSymbolCall[mainOb];
FOR directives: LIST OF REF ANY _ cifDirectives, directives.rest WHILE directives#NIL DO
currentDirective _ NARROW[directives.first];
IF currentDirective.deltaRadius<0 THEN
BEGIN
cifLayerAnnounced _ FALSE;
MakeFlatCIF[RectProc: CIFRectOut];
END;
ENDLOOP;
SymTrailer[];

CIFSymbolCall[topLevelOb, CDOrient.mirrorY, [x: -cifPerCD*mainRect.x1, y: cifPerCD*mainRect.y2]];
cifFile.PutRope[";\nEnd ... \n"];  
cifFile.Close[];

IF debugging THEN TerminalIO.WriteRope[" End of WriteCIF\n"];
TerminalIO.WriteRope["CIF file completed\n"];

EXITS
Exit => NULL;
FileIOOpenFailed => {TerminalIO.WriteRope["Open Failed\n"]};
END; -- of WriteCIF



MakeFlatCIF: PROC [RectProc: PROC[rect: CIFRect]] =
BEGIN

AnalyzeTesselation: PROC [ms: MaskStateRef] =
BEGIN
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;
ms.areas.ChangeRect[rect: CDBasics.universe, newValue: NIL];
IF currentDirective.deltaRadius>0 THEN
[] _ ms.unbloated.EnumerateArea[rect: CDBasics.universe, perTile: BloatTile, data: ms]
ELSE {
ms.areas.ChangeRect[rect: active, newValue: $covered];
[] _ ms.unbloated.EnumerateArea[rect: CDBasics.universe, perTile: BloatTile, data: ms,
backgroundValue: $covered];
};
};
[] _ ms.areas.EnumerateArea[rect: CDBasics.universe,
perTile: OutputTile, data: ms, backgroundValue: NIL];
TerminalIO.WriteRope["."]; -- end of window
};
END;

OutputTile: PROCEDURE [tile: CornerStitching.TilePtr, 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.DesignRect;
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 _ dr.saveRect _ NoteLevel;
dr.devicePrivate _ NEW[CD.DesignRect _ CDBasics.empty];
dr.interestClip _ CDBasics.universe;

CDOps.DrawDesign[design, dr]; -- measure design

designClip _ NARROW[dr.devicePrivate, REF CD.DesignRect]^;

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.WriteRope[IO.PutFR[format: ".. in %d rows and %d columns..", v1: IO.int[nRows], v2: IO.int[nCols]]];
dr.drawRect _ dr.saveRect _ NoteRectangle;
dr.devicePrivate _ ms;

TerminalIO.WriteRope[IO.PutFR["%s -> %s", IO.rope[ToRope[CD.LevelKey[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];
EXITS
END;

NoteLevel: PROC [ r: CD.DesignRect, l: CD.Level, pr: CD.DrawRef ] =
BEGIN
bb: REF CD.DesignRect = NARROW[pr.devicePrivate];
bb^ _ CDBasics.Surround[bb^, r];
END;

NoteRectangle: PROC [r: CD.DesignRect, l: CD.Level, 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: CornerStitching.TilePtr, 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
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.DesignRect ] RETURNS [ cifr: CIFRect ] =
{cifr _ CDBasics.NormalizeRect[
[x1: cifPerCD*cdr.x1,
y1: cifPerCD*cdr.y1,
x2: cifPerCD*cdr.x2,
y2: cifPerCD*cdr.y2]]
};

CIFRectToCD: PROC [ cifr: CIFRect ] RETURNS [ cdr: CD.DesignRect ] =
{cdr _ CDBasics.NormalizeRect[
[x1: cifr.x1/cifPerCD,
y1: cifr.y1/cifPerCD,
x2: cifr.x2/cifPerCD,
y2: cifr.y2/cifPerCD]]
};

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 ] =
{c _ (num+denom-1)/denom};

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"]; 
[] _ CDCommandOps.CallWithResource[WriteCIF, comm, $CIF, stopFlag];
END;

CDSequencer.ImplementCommand[a: $WriteCif, p: WriteCIFComm, queue: doQueue];
CDMenus.CreateEntry[menu: $ProgramMenu, entry: "Hierarchical CIF", key: $WriteCif];
END.  
	φBrandyCIFter.mesa  	A module to output CIF files from Chipndale
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Last Edited by: Kimr, October 15, 1984 5:15:13 pm PDT
Last Edited by: Jacobi, October 30, 1984 12:10:38 pm PST
Last Edited by McCreight, October 17, 1984 7:02:18 pm PDT
Last Edited by Jacobi, February 4, 1985 10:19:47 am PST
--TYPES


--Global Variables
--level assumed to be unchanged until the next level is announced
--..output numbers*cifScaling = CIFUnits
--..CIFUnits/cifScaling = output numbers
--set to design size in cifMeasureArea, used to switch between Chipndale and CIF coordinate systems

--Procedures
--used to set all CellIDNo's to NIL at the start
--Returns valueptr given key from object's property field
--start outputting a new cell and assign its cellID
--finish off cell description
--output CIF for structures only identified as geometries
--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
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.
--trace each member of the list to the bottom before any output is made
--write out the name of the cell
--For each member of the application list, determine whether obj is a cell. If so, determine transformations

--for each level, pick out the rectangles belonging to that level 
--and output them

--generate all signal names
--spit out properties other than signal names as comments
--spit out complaints about shorting contact
--indicate which cell is called using its ID number
OUTPUT PROCEDURES
--Sets mainRect to be a large as is necessary to contain design.
--.. adds the condition that cif/cifScaling is guaranteed to be an integer, so cif*cifScaling.denom MOD cifScaling.num = 0
--assign world variable from sequencer
--initialize main object, layer names, resolution,  cellCount, and draw records

--used as a parameter to drawMe in order to call cifOrArea
--Search world data structure: normalize coordinates, 
--set mainRect to design size, mark used levels  

--get file name
--output header
--ask for comment lines
--define hybrid top level object
--Flat CIF code

--the tesselation is in cif coordinates

--Be careful not to exceed the limits of a CD.Number, even temporarily
Κ‹˜š
œ?™?Jšœ
Οm
œ7™BJš
œ5™5Jš
œ8™8J™9Jš
œ7™7—J˜Jš
Οk	˜	Iitemšœžœ0˜@Kš
œ	˜	Kšžœ
žœ§˜―Kš
œ˜Kš
œ˜Kšœžœ`˜uKšžœ
žœžœžœ)˜VKšœžœ
˜Kšžœ
žœ˜Kšœžœžœ˜(Kšœžœ,˜6Kšœžœ
˜Kšœ	žœT˜bKš
œ
˜
Kšœžœ˜Kšœ
žœ%˜7Kšœžœ˜.Kšœ	žœ˜(Kš
œ˜Jš
œ
˜
šΠblœžœ
ž˜Jš
ž˜JšœJžœžœžœJ˜¨
—Jš
œ˜Jš
ž˜J˜Jš
Οb™™Jšœ
žœžœ˜Jšœ	žœžœΟcœ˜+Jšœ
žœžœžœ˜.Jšœžœžœžœ˜=Jšœ	žœžœžœ
˜%šœžœžœ˜Jšœžœ
˜Jšœ
žœ
‘$˜5Jš
œ˜—Jšœžœžœžœ
˜/šœžœžœ˜ Jšœ
žœ˜Jšœžœ
˜Jšœ
žœ
‘$˜5J˜—Jšœžœžœ˜#šœžœžœ˜Jšœžœžœ˜9Jš
œ˜Jš
œ˜J˜——J™Jš
 ™˜Jšœžœžœ‘+˜HJ˜Jšœžœ
‘9˜MJšœžœ	žœ
žœ˜,Jšœžœ	žœ
žœ˜0Jšœ
žœžœ
žœ
˜-Jš	œ
žœ
žœžœ
žœ˜%Jšœ
žœ˜Jšœ
žœ	˜Jšœ
žœ
‘˜(J˜Jšœ
žœžœ
žœ‘(˜]Jš
œ˜Jšœžœ‘,˜FJ˜šœžœžœ
˜#Jš
œA™A—J˜Jšœžœžœ˜Jšœžœ	‘˜1Jšœ
žœ‘;˜OJšœ
žœ‘Πcg
‘’
‘"˜LJ˜š
œ˜Jš
œ(™(Jš
œ(™(—J˜Jšœ
žœ
žœ
‘#˜7Jšœ(žœ
˜-J˜š
œO˜OJš
œc™c—J™Jšœžœ
žœ
žœ
ž‘œžœ
˜9Jš
œ˜J˜Jšœ‘˜4Jš
œ˜J˜—Jš
œ˜Jš
Οn™˜š£œžœ	žœžœžœžœ
žœ‘œ˜Ž
Jš
œ0™0Jš
ž˜Jšœžœ
žœžœ
˜Jš
œJ˜Jšžœž˜Jš
œ]˜]—Jšžœ
˜—J˜J˜š£œžœžœžœžœžœ
žœ˜BJš
œ9™9Jšœžœ$˜,—J˜š£	œžœžœ˜ Jš
œ3™3Jš
ž˜Jš	œžœ
žœžœ
žœ ˜9š
œ˜Jšžœžœžœ˜E—Jš
œH˜HJšžœ
˜J˜—š£
œžœ˜Jš
œ™Jš
ž˜Jš
œ˜Jšžœ
˜J˜—š
£œžœžœžœžœ˜RJš
œ9™9Jš
ž˜Jš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XJš
ž˜Jšœžœ˜,Jšœžœ
˜šžœ!ž˜'Jš
œ@˜@—Jšžœ
˜Jšžœ
˜—Jš
œ
˜
Jšžœ‘˜—J˜š£œžœžœ	˜'Jš
ϡ
™°
Jš
ž˜Jšœžœ‘(˜>Jšœžœžœ
žœ‘5˜jJšœžœ
‘!˜2J˜Jšžœžœ4˜EJš
œ˜šžœ&žœ
žœ
žœ˜;Jš
œf™f—Jš
œ˜Jš
œ―
™―
J˜Jšžœžœž˜"šœ	žœ˜Jš
ž˜Jšœžœ˜Jš
œG™Gšžœ(žœ
žœ
ž˜@Jš
œ ˜ —Jšžœ
˜J˜Jš
œ˜J˜Jš
œ ™ Jš
œ˜J˜Jš
œl™lJ™šžœ(žœ
žœ
ž˜@šžœž˜(Jšžœžœ
‘˜!šžœ˜
Jš
ž˜Jš
œ˜Jšžœžœ-˜>Jš
œ˜š
œ(˜(Jš
œ˜Jš
œ-˜-Jš
œ˜Jš
œ4˜4—Jš
œ?˜?Jšžœ
˜——Jšžœ
˜—J˜Jš
œB™BJš
œ™J™šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XJš
ž˜Jšœžœ˜,Jšœžœ
˜šžœ(žœ
žœ
ž˜@Jš
ž˜Jš
œ˜šžœž˜šžœ‘˜šžœ!ž˜'Jš
œT˜T——Jšžœžœ
˜—Jšžœ
˜Jšžœ
˜—Jšžœ
˜Jšžœ
˜—J˜Jš
œ™šžœ(žœ
žœ
ž˜@Jš
ž˜Jšœžœ
˜Jš
œ>˜>šžœ4žœ
ž˜>šžœž˜'JšžœC˜FJšžœžœ
˜——Jšžœ
˜Jšžœ
˜—J˜Jš
œ9™9Jš
œ,™,Jš
œ
˜
Jš
œ
˜
Jšžœ‘
˜—J˜šžœ‘#˜.Jšžœžœ
žœ
ž˜"š
ž˜Jš
ž˜Jšœ‘$˜;Jš
œ?˜?Jšžœ
˜——Jš
œ
˜
Jšžœžœ3˜DJ˜Jšžœ‘˜—J˜J˜š£
œžœžœžœ'žœ
‘œ˜xJš
œ3™3Jš
ž˜Jšœžœ%˜+Jšžœžœ
žœ
žœ
˜šžœžœ
ž˜šœžœ
žœ˜Jš
ž˜Jšœžœ
˜$šžœž˜Jš
ž˜Jšœžœ6˜Cšžœž˜Jš
ž˜Jš
œ˜Jš
œ˜šžœž˜Jš
œ˜Jš
œ˜Jš
œ˜Jšžœ‘˜(—Jšžœ
˜—šžœ"ž˜(Jš
œ˜—Jšžœ
˜—šžœ
žœ
ž˜"Jš
ž˜Jš
œ˜Jš
œ˜Jšžœ
˜—Jš
œ˜Jšžœ
˜—Jšžœžœ
˜—Jšžœ
˜—Jš
œ˜Jš
 ™J˜Jš
œ˜š œžœžœžœžœ
‘œ˜^Jš
œ@™@Jš
ž˜Jš
œ˜Jšžœ
žœžœžœ
˜)š
œ
˜
Jšœžœžœ˜9Jšœžœžœ˜8—Jšžœ‘˜—Jš
œ˜š
 	œžœžœžœžœ˜BJš
ž˜Jšœžœ˜Jš
žœ!žœ
žœžœ
žœ
˜KJš
œ˜Jš
œs˜sJšžœ˜J˜—Jš
œ˜š£
œžœ˜Jš
ž˜Jšžœ
žœžœ
žœ
˜(šžœ
žœž˜Jš
ž˜Jšœžœ!˜;Jšœžœ
˜Jšžœ
˜—šœ ‘&˜FJšžœ"‘œ˜2Jšžœ"‘œ˜1Jšžœ"‘œ˜:Jšžœ"‘œ˜;—Jšžœ
˜J˜J˜—š£œžœ˜#Jšœžœžœ˜PJ˜—š
£œžœžœžœžœ	˜PJš
ž˜Jš
œJ˜JJšœžœ
˜#Jš
œ˜Jš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XJšœžœ˜+Jšžœžœžœ˜<Jšžœ
˜—Jš
œ˜Jšžœ
˜—J˜š£œžœ	žœ˜%Jš
ž˜Jš
œ˜Jš	œžœžœžœžœ˜PJšžœ
˜—Jš
œ
˜
J˜Jš	œžœžœ
žœžœ
˜+J˜š
£œžœžœžœžœ˜7Jš
ž˜Jšžœžœ
žœž˜šžœ
žœžœ
ž˜Jšœžœ
˜Jšœžœ
žœ ˜,Jšœžœ˜#Jš	œžœ
žœžœžœ˜>šžœ˜
Jš
ž˜Jš	œžœ
žœžœ
žœ˜!Jšžœ˜Jšœ&žœ	˜3š
ž˜Jšœ
žœ
˜—Jšžœ
˜——Jšžœ
˜J˜—J˜Jšœžœžœ
˜#J˜š£
œžœ˜Jš
ž˜Jšœ@‘!˜ašžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XJšœžœ˜+Jš
œ˜šžœ
žœžœž˜+Jšžœ˜—Jšœžœ˜"š
œ˜Jš
œ˜Jšœ)žœ)˜UJš
œz™z—Jšžœ
˜—Jšžœ
˜J˜J˜—š£œžœ˜Jš
ž˜J˜š£
œžœžœžœžœžœ
žœ
žœ
žœžœ˜PJš
ž˜šžœžœ
ž˜
Jš
ž˜šžœžœ
ž˜Jšœžœ
žœ5˜PJš	œžœ
žœ
žœ
žœS˜hJšžœžœ
žœ)˜@—Jšžœ
˜—Jšžœ
˜J˜—Jšœžœ
˜š
žœ	žœ
žœ
žœ3žœ
žœ
ž˜^Jš
œƒ
˜ƒ
Jšžœ
˜—Jšžœ
˜J˜Jš
œ˜—š£œžœ˜,šžœ
ž˜Jš
ž˜Jšžœ9žœ˜Kš
œ
˜
Jš
ž˜JšœžœžœLžœ˜xJš
œ+˜+Jšžœ
˜Jšžœ
˜—Jšžœžœ
˜Jšžœ
˜—Jš
œ
˜
Jš
œ&™&Jš
œ˜Jš
œ
˜
Jš
œO™OJ™Jš
œ+˜+Jš
œ
˜
š
œ
˜
Jšœžœ
˜Jš
œ#˜#Jšœžœ5˜>Jš
œ˜Jš
œ˜—J˜Jš
œ˜Jšœžœ
˜Jš
œ
˜
Jšœžœ˜'Jš
œ-˜-Jš
œ&˜&J˜Jšœžœ˜'Jš
œ-˜-J˜%J˜ Jš
œ
˜
šœžœ˜/Jš
œ:™:—Jš
œ,˜,Jš
œ ˜ Jš
œ
˜
Jš
œ
˜
Jš
œ6™6Jš
œ1™1J™Jš
œ)˜)Jš
œ
˜
Jš
œ™Jš
œ8˜8Jšœžœ˜7Jš
œ˜Jš
œ%˜%Jšžœžœ˜.Jšžœžœ˜(Jšœžœ)žœ˜VJš
œ-˜-Jš
œ˜Jš
œ˜šœ
žœ˜(šžœ
˜Jšžœžœ˜Jš
œ)˜)Jšžœ˜Jš
œ˜Jš
œ
˜
——Jš
œ9˜9Jš
œO˜Ošžœžœ˜Jš
œ>˜>Jš
ž˜J˜—šžœžœ˜Jš
œ*˜*Jš
œ"˜"Jš
œ˜Jš
œ˜—Jš
œ˜J˜Jš
œ™Jšœžœ˜0JšœMžœ	˜XJšœ3žœ˜IJšœNžœ*žœ*˜¦
J˜Jš
œ™Jš
œ)˜)Jš
œV˜Všžœ
žœž˜"Jš
œ+˜+Jšœ
žœ
˜Jš
œ0˜0š
œ˜Jš
œ>˜>—Jšžœ
˜—šžœžœ
žœ˜Jš
œ
˜
J˜—Jš
œ˜Jš
œ˜Jšœ6žœ˜;Jš
œ˜J˜Jš
œ ™ J˜Jš
œ˜šžœ
žœ
žœ
žœ
žœ"žœžœ
ž˜XJšœžœ˜,šžœ ž˜&Jš
ž˜Jšœžœ
˜Jš
œ"˜"Jšžœ
˜—Jšžœ
˜—J˜
J˜Jš
œa˜aJš
œ#˜#Jš
œ˜J˜Jšžœžœ,˜=š
œ-˜-J˜—š
ž˜Jšœžœ
˜
Jš
œ<˜<—Jšžœ‘˜J˜—J˜—š
Ρbls™J˜—™š£œžœ£œžœ˜3Jš
ž˜J˜š£œžœ˜-Jš
ž˜Jš
œ'™'Jšœžœ8˜Bšžœžœ˜#šžœ"žœ˜*Jšœžœ,˜2Jš
œ˜Jš
œ
˜
Jšœ7žœ˜<šžœ ž˜&Jš
œV˜V—šžœ˜Jš
œ6˜6Jš
œr˜rJš
œ˜—Jš
œ˜—Jšœežœ˜jJšœ‘˜+Jš
œ˜—Jšžœ
˜J˜—š£
œž	œ'žœ
žœ
žœ
‘˜fJšžœ
‘+˜1Jšœžœ˜ Jš
œ<˜<Jš
œ
˜
Jšžœ
˜J˜—Jšœžœ˜Jšœ	žœ˜Jšœžœ
˜šœžœ˜%Jš
œ(˜(Jš
œ+˜+Jš
œ˜—J˜Jšœžœžœ˜*Jš
œ˜Jš
œ&˜&Jšœžœ
žœ˜7Jš
œ$˜$J˜Jšœ‘˜/J˜Jšœ
žœžœ
žœ˜:J˜Jšœ)žœ)˜UJ˜Jš
œ?˜?J˜>J˜Jšœžœ5žœžœ˜oJ™Jš
œ*˜*J˜J˜Jš	œžœžœ
žœ(žœ"˜‡
šžœžœ
žœž˜šžœžœ
žœž˜Jšœ7žœ˜<šœ‘˜Jš
œ˜Jš
œ˜Jšœžœ1˜QJšœžœ2˜SJš
œ˜—Jšœ=žœ*˜jš
œ"˜"Jšœd‘˜v—Jšœ‘5˜SJšœ‘˜6Jšžœ
˜—Jšžœ
˜—Jš
œ˜J˜%Jš
ž˜Jšžœ
˜J˜—š
£	œžœžœžœžœ˜CJš
ž˜Jšœžœ
žœžœ˜1Jš
œ ˜ Jšžœ
˜J˜—š
£
œžœžœžœžœ˜EJš
ž˜Jšœžœ˜,šžœžœž˜<š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜——Jšžœ
˜J˜—š£	œž	œ'žœ
žœ
žœ
‘!œ
˜hJš
ž˜Jšœžœ˜ JšœžœBžœ*˜ušžœž˜Jš
œ4˜4—Jšžœ
˜J˜—š
£œžœžœžœ	žœžœ	ž˜IJš
ž˜Jš
œF™FJšœ
žœ
žœ
žœ!žœ
žœ
žœ!žœ
žœ
žœ!žœ
žœ
žœ˜·
Jšžœ
˜—J˜š£œžœžœžœ˜Dš
œ˜Jš
œU˜U—Jš
œ˜J˜—š£œžœžœžœ˜Dš
œ˜Jš
œY˜Y—Jš
œ˜—J˜š£œžœžœžœ˜5Jš
ž˜Jšœžœ˜"Jšœžœ˜"Jšžœ
žœžœ
žœžœ
žœ˜9Jšžœ˜šžœ
˜J˜——š
£œžœžœ	žœžœ˜:Jš
œ˜J˜—š£œžœžœ˜8Jš
ž˜Jšœžœžœ˜Jšžœ'˜-Jšžœ
˜J˜—š
Πbkœžœ	žœžœžœ˜)Jš
ž˜Jšœžœ
˜šžœž˜
Jš
œ
˜
Jšžœžœ
˜—šžœž˜
Jš
œ
˜
Jšœžœ
˜Jšžœžœ˜—Jšœžœ˜Jšžœžœžœžœ
˜0Jšžœ˜
Jšžœ
˜——J˜š œžœ˜0Jšžœ
˜Jš
œ3˜3Jš
œC˜CJšžœ
˜J˜—Jš
œL˜LJš
œS˜SJšžœ˜—…—P u‘