DIRECTORY
AMBridge, AMTypes, Ascii, Atom, Basics, BasicTime, CD, CDBasics, CDCells, CDCommandOps, CDImports, CDMEBES, CDOps, CDProperties, CDSequencer, CDVArrow, CStitching, FS, IO, PrintTV, Process, Rope, TerminalIO;

CDMEBESMainImpl: CEDAR PROGRAM
IMPORTS AMBridge, Ascii, Atom, Basics, BasicTime, CD, CDBasics, CDCells, CDCommandOps, CDImports, CDMEBES, CDOps, CDProperties, CDSequencer, CDVArrow, CStitching, FS, IO, PrintTV, Process, Rope, TerminalIO
EXPORTS CDMEBES =
BEGIN OPEN CDMEBES;



stripesPerClump: PUBLIC INT _ 10;
defaultTadsPerNm: PUBLIC INT _ 1;
wDir: PUBLIC ROPE _ "///MEBES";
findBBoxByEnumeration: BOOL _ FALSE;
abortFlag: PUBLIC REF BOOL _ NEW[BOOL];
foundErrorLayer: BOOL _ FALSE;
today: Date;

Init: PROC ~ {
CDSequencer.ImplementCommand[key~$MEBESMask , proc~StartMEBESMask, queue~doQueue];
CDCommandOps.RegisterWithMenu[menu~$ProgramMenu, entry~"MEBES mask generation", key~$MEBESMask, proc~StartMEBESMask];
TerminalIO.PutRope["ChipNDale MEBES mask generator loaded\n"];
};


StartMEBESMask: PUBLIC PROC [comm: CDSequencer.Command] =
TRUSTED BEGIN
TerminalIO.PutRope["MEBES-mask generation\n"];
IF CDCells.IsPushedIn[comm.design] THEN {
TerminalIO.PutRope["**Design is pushed in; not done\n"]; 
RETURN
};
IF CDImports.HasUnloadedImports[comm.design].yes THEN {
TerminalIO.PutRope["**Design has non bound imports; not done\n"]; 
RETURN
};
TerminalIO.PutRope["Releases lock of design, but design MUST NOT be changed\n"];
abortFlag^ _ FALSE;
[] _ CDCommandOps.DoWithResource[proc: MEBESMask, comm: comm, resource: $MEBESMask]; 
END;


MEBESMask: PROC [ comm: CDSequencer.Command ] =
BEGIN

NotePunt: PROC = {TerminalIO.PutF["\n*** MEBES mask generation aborted at %g\n", IO.time[]]};

BEGIN ENABLE
BEGIN
ABORTED => GOTO Punt;
TerminalIO.UserAbort => GOTO Punt;
UNWIND => NotePunt[];
END;
MakeMasks[comm: comm, streamGen: SimpleStreamGen];
IF abortFlag^ THEN NotePunt[];
EXITS Punt => NotePunt[];
END;
END;


StreamGenProc: TYPE = PROC [ ms: MaskState ] RETURNS [ dest: IO.STREAM ];

SimpleStreamGen: PROC [ ms: MaskState ] RETURNS [ dest: IO.STREAM ] -- StreamGenProc -- =
BEGIN
dest _ FS.StreamOpen[
fileName: IO.PutFR[format: "%g%g/%g", 
v1: IO.rope[wDir], v2: IO.rope[ms.maskSetName], v3: IO.rope[ms.patternFileNames.first]
], 
accessOptions: create
];
END;


Prop: PROC [ms: MaskState, prop: REF, default: REF _ $Error] RETURNS [value: REF] = {
value _ CDProperties.GetDesignProp[ms.design, prop];
IF value = NIL THEN value _ CDProperties.GetTechnologyProp[ms.design.technology, prop];
IF value = NIL THEN value _ CDProperties.GetAtomProp[$CDMEBES, prop];
IF value = NIL THEN value _ default;
IF value = $Error THEN
BEGIN
TerminalIO.PutF[" .. no value for property %g.. ", IO.rope[ToRope[prop]]];
ERROR TerminalIO.UserAbort;
END;
};

NumericProp: PROC [ms: MaskState, prop: REF, default: REF _ NIL] RETURNS [value: INT] = {
value _ NARROW[Prop[ms, prop, default], REF INT]^;
};


MakeMasks: PROC [comm: CDSequencer.Command, streamGen: StreamGenProc ] =

BEGIN

ms: MaskState = NEW[ MaskStateRec _ [
design: comm.design,
drawCommand: NEW[DrawRectangle]]];

TRUSTED {Process.SetPriority[Process.priorityBackground]};

TerminalIO.PutF["\nMEBES Mask Generation\nPreliminary analysis begun at %g.\n", IO.time[]];

IF NOT abortFlag^ THEN
BEGIN ENABLE -- for ERRORs
BEGIN
UNWIND => ms.s _ AbortFile[ms.s];
END;

ComputeReticleClip: PROC [cdToNm: Rational] RETURNS [clip: NmRect] =
BEGIN

AdjustReticleSize: PROC [coord: ROPE, z1, z2: Nm, zSizeProp: ATOM, zOffset: Nm _ 0] RETURNS [newZ1, newZ2: Nm] =
BEGIN
zSize: Nm = NumericProp[ms, zSizeProp, NEW[Nm _ z2-z1]];
IF z2-z1 > zSize THEN
{TerminalIO.PutF[" .. design %g size of %d nanometers is larger than allowed die size of %d nanometers ..", IO.rope[coord], IO.int[z2-z1], IO.int[zSize]];
ERROR TerminalIO.UserAbort};
newZ1 _ (z1+z2-zSize)/2-zOffset;
newZ2 _ newZ1+zSize;
END;

smallestScribedDesignNm: NmRect _ Bloat[
r: ScaleRect[ms.designClip^, cdToNm],
deltaDiameter: 2*(maxBloat+activeToScribeCenter)];
[clip.x1, clip.x2] _ AdjustReticleSize["x", smallestScribedDesignNm.x1, smallestScribedDesignNm.x2, $CDMEBESNmDieSizeX, ms.dieOffset.x];
[clip.y1, clip.y2] _ AdjustReticleSize["y", smallestScribedDesignNm.y1, smallestScribedDesignNm.y2, $CDMEBESNmDieSizeY, ms.dieOffset.y];
END; -- of ComputeReticleClip

maxBloat: Nm _ NumericProp[ms, $CDMEBESNmMaxBloat, NEW[Nm _ 10000]];
activeToScribeCenter: Nm _ NumericProp[ms, $CDMEBESActiveToScribeCenter];
maskCount, otherCount: INT _ 0;
cf: REF CD.ContextFilter _ NEW[CD.ContextFilter _ ALL[TRUE]];
commentLayer: CD.Layer = CD.FetchLayer[t: comm.design.technology, uniqueKey: $comment];

today _ Today[];
ms.maskSetName _ (IF Prop[ms, $CDMEBESMaskSetName, $default] = $default THEN
TerminalIO.RequestRope["Project name? (9 chars, alphanum) "] ELSE ToRope[Prop[ms, $CDMEBESMaskSetName]]);
ms.toolingSpec _ NARROW[Prop[ms, $CDMEBESToolingSpec]];
ms.derivationSpec _ NARROW[Prop[ms, $CDMEBESDerivationSpec]];
ms.nmPerLambda _ NumericProp[ms, $CDMEBESNmPerLambda];
ComputeTadsPerNm[ms];

ms.dieOffset _ [x: NumericProp[ms, $CDMEBESNmDieOffsetX, NEW[Nm _ 0]],
y: NumericProp[ms, $CDMEBESNmDieOffsetY, NEW[Nm _ 0]]];

ms.dropInList _ NARROW[Prop[ms, $CDMEBESDropInList, NIL], LIST OF REF ANY];

ms.designClip _ NEW[CD.Rect _ [0, 0, 0, 0]];

FOR d: LIST OF REF ANY _ ms.derivationSpec, d.rest WHILE d#NIL DO
WITH d.first SELECT FROM
derivation: DerivationMaskSpec =>
MarkInterestingLayers[ms, derivation.cover];
ENDCASE => NULL;
ENDLOOP; -- d
IF commentLayer # CD.errorLayer THEN
cf[commentLayer] _ ms.interestingLayers[commentLayer];
foundErrorLayer _ FALSE;

IF CDCells.IsPushedIn[ms.design] AND
NOT TerminalIO.Confirm[IO.PutFR["WARNING: CDMEBES working on pushed cell %g in design %g.  This probably isn't what you want.  Confirm to continue...\n", IO.rope[ms.design.actual.first.desc], IO.rope[ms.design.name]]] THEN GOTO AbortMask;

ms.designClip^ _ CDOps.BoundingBox[ms.design];

IF findBBoxByEnumeration THEN {
ms.designClip^ _ [0, 0, 0, 0];
CDOps.DrawDesign[ms.design, CD.CreateDrawRef[[
interestClip~CDBasics.universe,
drawRect~NoteLayer,
stopFlag~abortFlag,
devicePrivate~ms,
contextFilter~cf,
symbolics~FALSE,
showErrors~FALSE,
design~ms.design
]]];
};

IF NOT CDBasics.NonEmpty[ms.designClip^] THEN ms.designClip^ _ [0, 0, 0, 0];

ms.nmReticleClip _ ComputeReticleClip[
cdToNm: ReduceRational[
[num: ms.nmPerLambda, denom: ms.design.technology.lambda]
]];

FOR d: LIST OF REF ANY _ ms.derivationSpec, d.rest WHILE d # NIL DO
WITH d.first SELECT FROM
derivation: DerivationMaskSpec => maskCount _ maskCount+1
ENDCASE => otherCount _ otherCount+1;
ENDLOOP;

TerminalIO.PutF["Preliminary analysis finished at %g.  Making %d real masks and %d other things at %d (x) x %d (y) nm.\n",
IO.time[],
IO.int[maskCount],
IO.int[otherCount],
IO.int[CDBasics.SizeOfRect[ms.nmReticleClip].x],
IO.int[CDBasics.SizeOfRect[ms.nmReticleClip].y]
];
IF foundErrorLayer THEN 
TerminalIO.PutRope["  WARNING: CDMEBES found geometry on error layer\n"];

FOR d: LIST OF REF ANY _ ms.derivationSpec, d.rest WHILE d#NIL DO
ms.data _ NIL;
WITH d.first SELECT FROM
derivation: DerivationMaskSpec => {
tooling: ToolingMaskSpec = NARROW[ms.toolingSpec.GetPropFromList[derivation.maskId]];
ms.curMask _ derivation;
IF tooling#NIL
THEN MakeMEBESMask[ms, derivation, tooling, streamGen
! TadTooLarge => {
ComputeTadsPerNm[ms, 2*ms.tadsPerNm];
RETRY
} ] -- a real mask
ELSE TerminalIO.PutF["Mask %g, a part of the derivation spec, is not part of the tooling spec.\n", IO.atom[derivation.maskId]];
};
spec: CoverSpec => -- we're doing analysis, probably
DoAnalysisPass[ms, spec];
ENDCASE => NULL;

IF abortFlag^ THEN GOTO AbortMask;

IF ms.data # NIL THEN
BEGIN
tv: AMTypes.TV;
rs: IO.STREAM = IO.ROS[];
rs.Put[IO.rope["\nAnalysis result .. "]];
TRUSTED {tv _ AMBridge.TVForReferent[ms.data]};
PrintTV.Print[tv: tv, put: rs, depth: 10, width: 1000];
rs.Put[IO.rope["\n"]];
TerminalIO.PutRope[IO.RopeFromROS[rs]];
END;
ENDLOOP; -- d

TerminalIO.PutF["\nMEBES mask generation finished at %g\n", IO.time[]];
EXITS
AbortMask => {ms.s _ AbortFile[ms.s]};
END;
END;


MarkInterestingLayers: PROC [ ms: MaskState, cover: CoverSpec ] = {
WITH cover SELECT FROM
lora: LIST OF REF ANY =>
FOR l: LIST OF REF ANY _ lora, l.rest WHILE l # NIL DO
MarkInterestingLayers[ms, l.first];
ENDLOOP;
layer: CDLayer => ms.interestingLayers[layer.source] _ TRUE;
ENDCASE => NULL;
};

NoteLayer: PROC [ pr: CD.DrawRef, r: CD.Rect, l: CD.Layer ] =
BEGIN
ms: MaskState = NARROW[pr.devicePrivate];
IF abortFlag^ THEN ERROR TerminalIO.UserAbort;
ms.designClip^ _ IF CDBasics.NonEmpty[ms.designClip^] THEN CDBasics.Surround[ms.designClip^, r] ELSE r;
IF l=CD.errorLayer THEN {
foundErrorLayer _ TRUE;
pr.contextFilter[CD.errorLayer] _ FALSE; -- found one, don't need more
}; 
END;



MakeMEBESMask: PROC [ms: MaskState, derivation: DerivationMaskSpec, tooling: ToolingMaskSpec, streamGen: StreamGenProc] =
BEGIN

RestateAddrUnit: PROC [ nm: Nm -- 10^-3 micrometer -- ] RETURNS [ extModeAddrUnits: INT -- 2^-28 micrometer -- ] = {
extModeAddrUnits _ nm/1000;
nm _ nm MOD 1000;
FOR i: INT IN [0..28) DO -- manual high-precision binary divide, (nm/1000) 
extModeAddrUnits _ extModeAddrUnits+extModeAddrUnits;
nm _ nm+nm;
IF nm > 1000 THEN {
extModeAddrUnits _ extModeAddrUnits+1;
nm _ nm-1000;
};
ENDLOOP;
};

blockCountFileIndex: INT;

mebesReticleClip: MEBESRect = ScaleRect[ms.nmReticleClip,
[num: 1, denom: tooling.addrUnit -- nm/MEBES pixel --]];
nRows: NAT = Ceiling[[
num: CDBasics.SizeOfRect[mebesReticleClip].y -- MEBES pixels -- ,
denom: maskHeight -- MEBES pixels --
]];
nCols: NAT = Ceiling[[
num: CDBasics.SizeOfRect[mebesReticleClip].x -- MEBES pixels -- ,
denom: maskWidth -- MEBES pixels --]];

extModeAddrUnits: INT = RestateAddrUnit[tooling.addrUnit];

ms.mebesPixelPitch _ tooling.addrUnit;
ms.mode _ tooling.mode;

ms.scale _ ReduceRational[[num: ms.nmPerLambda*ms.tadsPerNm, denom: ms.design.technology.lambda]];

FOR col: NAT IN [0..nCols) DO
left: MEBESPixels = mebesReticleClip.x1+col*maskWidth;

FOR row: NAT IN [0..nRows) DO
bottom: MEBESPixels = mebesReticleClip.y1+row*maskHeight;

topmostStripe: INT = MIN[maxStripes, Ceiling[[num: CDBasics.SizeOfRect[mebesReticleClip].y-maskHeight*row, denom: stripeHeight]]];

IF ms.mode # reticle OR (row = 0 AND col = 0) THEN {
ms.patternFileNames _ CONS[
GenPatternFileName[mode: ms.mode, maskSetName: ms.maskSetName,
maskName: tooling.maskNo, row: row, col: col],
ms.patternFileNames];
ms.s _ EBESOpen[streamGen[ms]];
TerminalIO.PutF["\nStarting mask %g at %g ", IO.rope[ms.patternFileNames.first], IO.time[]];

SendCommand[s: ms.s, comm: (SELECT tooling.mode FROM
oneTwo => NEW[Mode12StartDrawing _ [
addressCode: (SELECT tooling.addrUnit FROM
500 => Nm500,
250 => Nm250,
ENDCASE => ERROR),
cx: MIN[maskWidth, CDBasics.SizeOfRect[mebesReticleClip].x-col*maskWidth],
cy: MIN[maskHeight, CDBasics.SizeOfRect[mebesReticleClip].y-row*maskHeight],
moDayYr: today,
patternFileName: RopeToPatternFileName[ms.patternFileNames.first]
]],
extended => NEW[ExtAddrModeStartDrawing _ [
addrUnitHigh: Basics.HighHalf[extModeAddrUnits],
addrUnitLow: Basics.LowHalf[extModeAddrUnits],
cxLow: MIN[maskWidth, CDBasics.SizeOfRect[mebesReticleClip].x-col*maskWidth],
cyLow: MIN[maskHeight, CDBasics.SizeOfRect[mebesReticleClip].y-row*maskHeight],
moDayYr: today,
patternFileName: RopeToPatternFileName[ms.patternFileNames.first]
]],
reticle => NEW[ExtAddrModeStartDrawing _ [
addrUnitHigh: Basics.HighHalf[extModeAddrUnits],
addrUnitLow: Basics.LowHalf[extModeAddrUnits],
cxHigh: Basics.HighHalf[CDBasics.SizeOfRect[mebesReticleClip].x],
cxLow: Basics.LowHalf[CDBasics.SizeOfRect[mebesReticleClip].x],
cyHigh: Basics.HighHalf[CDBasics.SizeOfRect[mebesReticleClip].y],
cyLow: Basics.LowHalf[CDBasics.SizeOfRect[mebesReticleClip].y],
moDayYr: today,
patternFileName: RopeToPatternFileName[ms.patternFileNames.first],
field2Size: (SIZE[CARDINAL]+SIZE[SegDirectoryEntry]*nCols)*Basics.bytesPerWord/bytesPerMebesWord
]],
ENDCASE => ERROR)];

IF ms.mode # oneTwo THEN {
blockCountFileIndex _ ms.s.GetIndex[];
SendCommand[s: ms.s, comm: NEW[CARDINAL _ 0]];
IF ms.mode = reticle THEN {
de: REF SegDirectoryEntry = NEW[SegDirectoryEntry];
FOR segment: INT IN [0..nCols) DO
SendCommand[s: ms.s, comm: de];
ENDLOOP;
};
};
};

IF ms.mode = reticle AND row = 0 THEN { -- fill in segment directory for new column
oldIndex: INT = ms.s.GetIndex[];
ms.s.SetIndex[blockCountFileIndex+(Basics.bytesPerWord*(SIZE[CARDINAL]+SIZE[SegDirectoryEntry]*col))];
SendCommand[s: ms.s, comm: NEW[SegDirectoryEntry _ [
firstBlock: 1+(oldIndex/mebesBlockSize),
firstWordWithinBlock: 1+(oldIndex MOD mebesBlockSize)/bytesPerMebesWord
]]];
ms.s.SetIndex[oldIndex];
SendCommand[s: ms.s, comm: NEW[StartSegment _ [segmentNumber: segmentOrigin+col]]];
};

FOR stripeBase: INT -- [0..maxStripes) -- _ 0, stripeBase+stripesPerClump WHILE stripeBase < topmostStripe DO

rects: Tesselation _ NIL;

IF abortFlag^ THEN RETURN;

ms.tadStripeClip _ ScaleRect[
CDBasics.Intersection[mebesReticleClip, [
x1: left,
y1: bottom+stripeBase*stripeHeight,
x2: left+maskWidth,
y2: bottom+(stripeBase+stripesPerClump)*stripeHeight
]],
[num: ms.mebesPixelPitch*ms.tadsPerNm, denom: 1]];

ms.designStripeClip _ ScaleTadToCD[ms,
CDBasics.Extend[ms.tadStripeClip, ms.mebesPixelPitch*ms.tadsPerNm]];

ms.viewerArrow _ CDBasics.Center[ms.designStripeClip];
CDVArrow.ShowArrow[design: ms.design, pos: ms.viewerArrow];

rects _ GenerateCover[ms, LIST[$Enlarge, NEW[Nm _ 2*tooling.skewPerSide], derivation.cover]];
AddScribe[ms, rects];

FOR stripe: INT IN [stripeBase..MIN[stripeBase+stripesPerClump, topmostStripe]) DO
ms.tadStripeClip _ ScaleRect[
CDBasics.Intersection[mebesReticleClip, [
x1: left,
y1: bottom+stripe*stripeHeight,
x2: left+maskWidth,
y2: bottom+(stripe+1)*stripeHeight
]],
[num: ms.mebesPixelPitch*ms.tadsPerNm, denom: 1]];
ms.stripeRectCount _ 0;
SendCommand[s: ms.s, comm: (SELECT ms.mode FROM
oneTwo => NEW[Mode12StartStripe _ [stripeNumber: stripe+stripeOrigin]],
extended => NEW[ExtAddrModeStartStripe _ [stripeNumber: stripe+stripeOrigin]],
reticle => NEW[ExtAddrModeStartStripe _
[stripeNumber: row*maxStripes+stripe+stripeOrigin]],
ENDCASE => ERROR)];
FOR dil: LIST OF REF ANY _ ms.dropInList, dil.rest WHILE dil # NIL DO
di: DropIn = NARROW[dil.first];
ddi: Atom.PropList = NARROW[derivation.props.GetPropFromList[$DropIns]];
val: REF ANY _ InsertDropIn[ms: ms, rects: rects, di: di,
data: ddi.GetPropFromList[di.name]];
derivation.props _ derivation.props.PutPropOnList[
prop: $DropIns,
val: ddi.PutPropOnList[prop: di.name, val: val]
];
ENDLOOP;
[] _ rects.EnumerateArea[rect: ms.tadStripeClip,
eachTile: OutputTile, data: ms];
SendCommand[s: ms.s, comm: NEW[BasicCommand _ endStripe]];
TerminalIO.PutF[".%d", IO.int[ms.stripeRectCount]]; -- end of stripe
ENDLOOP; -- stripe

rects _ DisposeTesselation[rects];
ENDLOOP; -- stripeBase

IF ms.mode # reticle THEN {
SendCommand[s: ms.s, comm: NEW[BasicCommand _ endDrawing]];
ms.s.Flush[];
IF ms.mode # oneTwo THEN {
oldIndex: INT = ms.s.GetIndex[];
ms.s.SetIndex[blockCountFileIndex];
SendCommand[s: ms.s, comm: NEW[CARDINAL _ oldIndex/mebesBlockSize]];
ms.s.SetIndex[oldIndex];
};
ms.s.Close[];
ms.s _ NIL;
};

ENDLOOP; -- row
ENDLOOP; -- col

IF ms.mode = reticle THEN {
oldIndex: INT;
SendCommand[s: ms.s, comm: NEW[BasicCommand _ endDrawing]];
ms.s.Flush[];
oldIndex _ ms.s.GetIndex[];
ms.s.SetIndex[blockCountFileIndex];
SendCommand[s: ms.s, comm: NEW[CARDINAL _ oldIndex/mebesBlockSize]];
ms.s.SetIndex[oldIndex];
ms.s.Close[];
ms.s _ NIL;
};

END;


DoAnalysisPass: PROC [ ms: MaskState, spec: CoverSpec ] =
BEGIN
END;


GenerateCover: PUBLIC PROC [ ms: MaskState, spec: CoverSpec, extInfluenceDiameter: Tad _ 0 ] RETURNS [ rects: Tesselation ] =
BEGIN
WITH spec SELECT FROM
list: LIST OF REF ANY =>
BEGIN
ref: REF ANY = Atom.GetProp[$CDMEBESCoverProcs, list.first];
rects _ NARROW[ref, REF CoverProc]^[ms, list.rest, extInfluenceDiameter];
END;

layer: CDLayer =>
SELECT layer.deltaDiameter FROM
>=0 =>
BEGIN
rects _ NewTesselation[NIL];
DrawLayersWithPosDeltas[ms: ms, rects: rects, layers: LIST[layer], extInfluenceDiameter: extInfluenceDiameter];
END;

ENDCASE => rects _ GenerateCover[
ms,
LIST[$Enlarge,
NEW[Nm _ layer.deltaDiameter],
NEW[CDLayerRec _ [source: layer.source, deltaDiameter: 0]]],
extInfluenceDiameter];

ENDCASE => IF spec = NIL THEN rects _ NewTesselation[NIL] ELSE ERROR;
END;


AddScribe: PROC [ms: MaskState, rects: Tesselation] =
BEGIN
IF NARROW[Prop[ms, $CDMEBESAddScribe, NEW[BOOL _ FALSE]], REF BOOL]^ THEN { -- insert the scribe line
scaleFactor: Rational = [num: ms.tadsPerNm, denom: 1]; -- from Nm to Tads
r: NmRect = ms.nmReticleClip;
rSize: NmPosition = CDBasics.SizeOfRect[r];
tooling: ToolingMaskSpec = NARROW[ms.toolingSpec.GetPropFromList[ms.curMask.maskId]];
outer: Nm = tooling.scribeOffset;
inner: Nm = tooling.scribeOffset+tooling.scribeWidth;
IF inner > outer THEN { -- nontrivial scribe structure

ChRect: PROC [b: NmRect] = {
FOR xRepeat: INT IN [-1..1] DO
FOR yRepeat: INT IN [-1..1] DO
offsetRect: NmRect = CDBasics.MoveRect[r: b,
offset: CDBasics.AddPoints[p: ms.dieOffset,
s: [x: xRepeat*rSize.x, y: yRepeat*rSize.y]]
];
clippedMebesRect: MEBESRect = ScaleRect[CDBasics.Intersection[offsetRect, r], scaleFactor];
IF CDBasics.NonEmpty[clippedMebesRect] THEN
rects.ChangeRect[clippedMebesRect, $covered];
ENDLOOP;
ENDLOOP;
};

ChRect[[x1: r.x1+outer, y1: r.y1+outer, x2: r.x1+inner, y2: r.y2-outer]]; -- left side
ChRect[[x1: r.x2-inner, y1: r.y1+outer, x2: r.x2-outer, y2: r.y2-outer]]; -- right side
ChRect[[x1: r.x1+outer, y1: r.y1+outer, x2: r.x2-outer, y2: r.y1+inner]]; -- bottom
ChRect[[x1: r.x1+outer, y1: r.y2-inner, x2: r.x2-outer, y2: r.y2-outer]]; -- top
};
};
END;


DrawInfo: TYPE = REF DrawInfoRec;
DrawInfoRec: TYPE = RECORD [ 
layers: ARRAY CD.Layer OF RECORD [ used: BOOL _ FALSE, deltaDiameter: Tad _ 0 ],
rects: Tesselation _ NIL,
ms: MaskState _ NIL ];

DrawLayersWithPosDeltas: PUBLIC PROC [ms: MaskState, rects: Tesselation, layers: LIST OF CDLayer, extInfluenceDiameter: Nm _ 0] =
BEGIN
IF layers # NIL THEN
BEGIN
biggestDelta: Nm _ 0;
di: DrawInfo;
cf: REF CD.ContextFilter _ NEW[CD.ContextFilter _ ALL[FALSE]];
dr: CD.DrawRef_ CD.CreateDrawRef[[
stopFlag~abortFlag,
interestClip~Bloat[ms.designStripeClip, MIN[(ms.design.technology.lambda*(extInfluenceDiameter+biggestDelta))/ms.nmPerLambda, 0]],
drawRect~IncludeRectangle,
devicePrivate~(di _ NEW[DrawInfoRec _ [rects: rects, ms: ms]]),
contextFilter~cf,
symbolics~FALSE,
showErrors~FALSE,
design~ms.design
]];

FOR list: LIST OF CDLayer _ layers, list.rest WHILE list # NIL DO
layer: CDLayer _ list.first;
cf[layer.source] _ TRUE;
di.layers[layer.source] _ [used: TRUE, deltaDiameter: layer.deltaDiameter*ms.tadsPerNm];
IF di.layers[layer.source].deltaDiameter < 0 THEN ERROR;
biggestDelta _ MAX[biggestDelta, layer.deltaDiameter];
ENDLOOP;

CDOps.DrawDesign[ms.design, dr]; -- enumerate design rectangles into rects
END;
END;

IncludeRectangle: PROC [ pr: CD.DrawRef, r: CD.Rect, l: CD.Layer ] =
BEGIN
di: DrawInfo = NARROW[pr.devicePrivate];
IF di.layers[l].used AND CDBasics.NonEmpty[r] THEN
BEGIN
tr: TadRect _ ScaleCDToTad[ms: di.ms, cdr: r];
IF di.layers[l].deltaDiameter # 0 THEN
tr _ Bloat[tr, di.layers[l].deltaDiameter];
di.rects.ChangeRect[rect: tr, new: $covered];
END;
END;


OutputTile: PROCEDURE [tile: CStitching.Tile, data: REF ANY]
-- CStitching.PerTileProc -- =
BEGIN -- only called on tiles with non-NIL values

DoOutput: PROC =
BEGIN
ms: MaskState = NARROW[data];
tpp: Tad = ms.tadsPerNm*ms.mebesPixelPitch; -- tads per pixel
tr: TadRect = CDBasics.MoveRect[
r: CDBasics.Intersection[tile.Area, ms.tadStripeClip],
offset: CDBasics.NegOffset[CDBasics.BaseOfRect[ms.tadStripeClip]]
];
mr: MEBESRect = [x1: tr.x1/tpp, y1: tr.y1/tpp, x2: tr.x2/tpp, y2: tr.y2/tpp];
IF CDBasics.NonEmpty[mr] THEN
BEGIN
ms.drawCommand^ _ [
x: mr.x1,
y: mr.y1,
w: mr.x2-mr.x1,
h: mr.y2-mr.y1
];
SendCommand[s: ms.s, comm: ms.drawCommand];
ms.stripeRectCount _ ms.stripeRectCount+1;
END;
END;

WITH tile.value SELECT FROM
a: ATOM =>
SELECT a FROM
$covered => DoOutput[];
ENDCASE => ERROR;
ENDCASE => ERROR;
END;


Today: PROC RETURNS [ d: Date ] =
TRUSTED BEGIN
time: BasicTime.Unpacked = BasicTime.Unpack[BasicTime.Now[]];
moDayYr: ROPE = IO.PutFR[format: "%02d%02d%02d",
v1: IO.card[LOOPHOLE[time.month, CARDINAL]+1], v2: IO.int[time.day], v3: IO.int[time.year MOD 100]];
FOR i: [0..6) IN [0..6) DO d[i] _ Rope.Fetch[moDayYr, i] ENDLOOP;
END;


GenPatternFileName: PROC [ mode: MEBESMode, maskSetName, maskName: ROPE, row, col: NAT ] RETURNS [ rfn: ROPE ] =
BEGIN
r: ROPE;
twoCharMaskName: ROPE = Rope.Substr[base: Rope.Cat[maskName, "xx"], len: 2];
SELECT mode FROM
oneTwo, extended => {
r _ IO.PutFR[format: "%s%s.%g%g",
v1: IO.rope[Rope.Substr[base: Rope.Cat[maskSetName, "xxxxxxx"], len: 7]],
v2: IO.rope[twoCharMaskName],
v3: IO.char[LOOPHOLE['A+col]], v4: IO.char[LOOPHOLE['A+row]]];
};
reticle => {
IF row # 0 OR col # 0 THEN ERROR;
r _ IO.PutFR[format: "%s.%s",
v1: IO.rope[Rope.Substr[base: Rope.Cat[maskSetName, "xxxxxxx"], len: 9]],
v2: IO.rope[twoCharMaskName]];
};
ENDCASE => ERROR;
rfn _ Rope.Translate[base: r, translator: ToUpperCase];
END;


ToUpperCase: PROC [old: CHAR] RETURNS [new: CHAR] -- Rope.TranslatorType -- =
{new _ Ascii.Upper[old]};


RopeToPatternFileName: PROC [ rfn: ROPE ] RETURNS [ fn: PatternFileName ] =
{FOR i: [0..12) IN [0..12) DO fn[i] _ Rope.Fetch[rfn, i] ENDLOOP};


AbortFile: PROC [s: IO.STREAM ] RETURNS [ IO.STREAM ] =
{IF s#NIL THEN s.Close[abort: TRUE]; RETURN[NIL]};


ComputeTadsPerNm: PROC [ ms: MaskState, minAllowable: Tad _ 1 ] = {
prop: ATOM = $CDMEBESTadsPerNm;
ms.tadsPerNm _ NumericProp[ms, prop, NEW[INT _ defaultTadsPerNm]];
IF ms.tadsPerNm < minAllowable THEN {
TerminalIO.PutF["\n\nSorry, your basic unit of measure of 1/%d nm was too large.  I've made it smaller for you.  Restarting conversion of this mask.\n", IO.int[ms.tadsPerNm]];
ms.tadsPerNm _ minAllowable;
defaultTadsPerNm _ MAX[defaultTadsPerNm, minAllowable];
IF Prop[ms, $CDMEBESTadsPerNm, NIL] # NIL THEN
CDProperties.PutDesignProp[ms.design, prop, NEW[Tad _ minAllowable]];
};
};


Init[];

END. -- of CDMEBESMainImpl

δCDMEBESMainImpl.mesa
Copyright c 1985, 1987 by Xerox Corporation.  All rights reserved.
written by E. McCreight, November 2, 1983 6:03 pm
McCreight, April 30, 1987 6:36:33 pm PDT
Last edited by: Christian Jacobi, May 7, 1987 5:11:20 pm PDT
Last Edited by: McCreight December 2, 1987 1:17:55 pm PST
A package to output a ChipnDale design in MEBES format for a Perkin-Elmer Lithographic System.  Files produced herein should conform to the MEBES Mode I/II, extended mode, or reticle mode pattern file format described in the MEBES Software Manual, document A900-0102C, Data Files, document A900-0024D, publication of

Perkin-Elmer
Electron Beam Technology
3392 Investment Boulevard
Hayward, CA  94545

Global Variables

.. measure design in ChipNDale units, leaves result in ms.designClip
... index where the block count CARDINAL is stored in extended or reticle mode files
.. open a new pattern file and generate a header
.. to be filled in later with block count
.. leave room for the segment (column) directory
.. keep user happy
.. fill in the number of blocks needed
.. fill in the number of blocks needed
(e.g., LIST[$Bletch, NEW[INT _ 2], NEW[CDLayer _ []], NEW[CDLayer _ []]] )
... think very carefully about this ...
Module START code...

Κ’˜š
œ™Icodešœ
Οm
œ7™BJš
œ1™1K™(K™<K™9—J˜Jš
œΌ™Ό™J™J™J™J™—J˜J™š
Οk	˜	Jš	œ3žœ.žœ:žœžœ%˜Ο
J˜—šΠbnœžœ
ž˜Jš
žœ+žœ.žœ:žœžœ$˜Ν
Jšžœ
žœ˜Jšžœ
žœ
žœ
˜˜J˜—Jš
Οb™J˜Jšœžœ
žœ˜!Jšœžœ
žœ˜!Jšœžœ
žœ˜Jšœžœžœ
˜$Jšœžœ
žœ
žœžœ
žœ˜'Jšœžœžœ
˜J˜J˜šΟnœžœ˜Jš
œR˜RJš
œu˜uJš
œ>˜>J˜J˜—J™J˜š‘œžœ˜9Jšžœ
ž˜
Jš
œ.˜.šžœ!žœ˜)Jš
œ9˜9Jš
ž˜J˜—šžœ/žœ˜7Jš
œB˜BJš
ž˜J˜—Jš
œP˜PJšœ
žœ
˜Jš
œU˜UJšžœ
˜J˜J˜—š‘	œžœ ˜/Jš
ž˜J˜Jš‘œžœCžœ
˜]˜šžœ
ž˜Jš
ž˜Jšžœžœ˜Jšœžœ˜"Jšžœ˜Jšžœ
˜—Jš
œ2˜2Jšžœžœ˜Jšžœ˜Jšžœ
˜—Jšžœ
˜J˜J˜—Jšœžœžœžœ	žœ
žœ˜IJ˜š‘œžœžœ	žœ
žœΟcœ˜YJš
ž˜šœžœ˜šœ
žœ˜&Jšœžœžœžœ ˜VJš
œ˜—Jš
œ˜Jš
œ˜—Jšžœ
˜J˜J˜—š‘œžœžœžœžœ	žœ˜UJš
œ4˜4Jšžœ	žœ
žœD˜WJšžœ	žœ
žœ2˜EJšžœ	žœ
žœ˜$šžœž˜Jš
ž˜Jšœ3žœ˜JJšžœ˜Jšžœ
˜—Jš
œ˜J˜—š‘œžœžœžœžœžœ	žœ˜YJšœžœžœ
žœ˜2Jš
œ˜J˜J˜—š‘	œžœ9˜HJ˜Jš
ž˜J˜šœžœ˜%Jš
œ˜Jšœ
žœ˜"—J˜Jšžœ3˜:J˜JšœPžœ	˜[J˜šžœ
žœž˜šžœ
žœ
’
˜Jš
ž˜Jšžœ˜!Jšžœ
˜J˜—š‘œžœžœ˜DJš
ž˜J˜š
‘œžœ	žœžœžœ˜pJš
ž˜Jšœ'žœ˜8šžœž˜Jšœlžœžœ
žœ
˜š
Jšžœ˜—Jš
œ ˜ Jš
œ˜Jšžœ
˜J˜—š
œ(˜(Jš
œ%˜%Jš
œ2˜2—Jš
œˆ
˜ˆ
Jš
œˆ
˜ˆ
Jšžœ’˜J˜—Jšœ3žœ˜DJš
œI˜IJšœžœ˜Jš
œžœ
žœžœ
žœžœ
žœ˜=J•StartOfExpansion'[t: 
CD.Technology, uniqueKey: 
ATOM]šœžœ<˜WJ˜Jš
œ˜šœžœ4ž˜LJšœ=žœ(˜i—Jšœžœ ˜7Jšœžœ#˜=Jš
œ6˜6Jš
œ˜J˜šœ9žœ
˜FJšœ)žœ˜7J˜—Jš
œžœžœžœ
žœ
žœ
žœ˜KJ˜Jšœžœ
žœ˜,J˜šžœžœ
žœ
žœ
žœžœžœ
ž˜Ašžœ	žœ
ž˜š
œ!˜!Jš
œ,˜,—Jšžœžœ
˜—Jšžœ’˜
—šžœžœž˜$Jš
œ6˜6—Jšœžœ
˜J˜šžœž˜$Jšžœžœ
žœ$žœžœ
žœ˜ξ
J˜—Jš
œ.˜.J˜šžœžœ˜Jš
œ˜šœžœ˜.Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ
žœ
˜Jšœžœ
˜Jš
œ˜Jš
œ˜Jš
œD™D—J˜—J˜Jšžœ
žœ#žœ˜LJ˜š
œ&˜&Jš
œ˜Jš
œ9˜9Jš
œ˜—J˜šžœžœ
žœ
žœ
žœžœžœ
ž˜Cšžœ	žœ
ž˜Jš
œ9˜9Jšžœ˜%—Jšžœ
˜J˜—š
œz˜zJšžœ˜
Jšžœ˜Jšžœ˜Jšžœ.˜0Jšžœ-˜/Jš
œ˜—šžœžœ
˜Jš
œI˜I—J˜šžœžœ
žœ
žœ
žœžœžœ
ž˜AJšœ
žœ
˜šžœ	žœ
ž˜š
œ#˜#Jšœžœ4˜UJš
œ˜šžœ	ž˜šžœ1˜5š
œ˜Jš
œ%˜%Jš
ž˜Jšœ’˜——Jšžœ_žœ˜—J˜—šœ’!˜4Jš
œ˜—Jšžœžœ
˜J˜—Jšžœžœ
žœ˜"J˜šžœžœ
ž˜Jš
ž˜Jšœžœ
˜Jš	œžœ
žœžœ
žœ˜Jšœžœ ˜)Jšžœ(˜/Jš
œ7˜7Jšœžœ
˜Jšœžœ˜'Jšžœ
˜—Jšžœ’˜
J˜—Jšœ<žœ	˜Gš
ž˜Jš
œ&˜&—Jšžœ
˜—Jšžœ
˜J˜J˜—š‘œžœ(˜Cšžœžœ
ž˜š	œžœ
žœ
žœ
žœ˜šžœžœ
žœ
žœ
žœžœžœ
ž˜6Jš
œ#˜#Jšžœ
˜——Jšœ7žœ
˜<Jšžœžœ
˜—Jš
œ˜J˜—š
‘	œžœžœ
žœ
žœ
˜=Jš
ž˜Jšœžœ˜)Jšžœžœ
žœ˜.Jšœžœ#žœ&žœ˜gšžœžœžœ˜Jšœžœ
˜Jšœžœžœ’˜FJ˜—Jšžœ
˜—˜J˜—J˜š‘
œžœf˜yJš
ž˜J˜š‘œžœ
’œžœžœ
’œ˜tJš
œ˜Jšœžœ˜š	žœžœ
žœ	žœ
’2˜KJš
œ5˜5Jš
œ˜šžœžœ˜Jš
œ&˜&Jš
œ
˜
Jš
œ˜—Jšžœ
˜—Jš
œ˜J˜—šœžœ
˜Jš
œT™T—J˜š
œ9˜9Jšœ!’œ˜8—šœžœ˜Jšœ-’œ˜AJšœ’˜$Jš
œ˜—šœžœ˜Jšœ-’œ˜AJšœ’œ˜&J˜—Jšœžœ%˜:J˜Jš
œ&˜&Jš
œ˜J˜Jš
œb˜bJ˜šžœžœ
žœž˜Jš
œ6˜6J˜Jšžœžœ
žœž˜Jš
œ9˜9˜Jšœžœžœj˜‚
J˜šžœžœ
žœ
žœ˜4Jš
œ0™0šœžœ
˜Jš
œm˜mJš
œ˜—Jš
œ˜Jšœ-žœ"žœ	˜\J˜šœžœž˜4šœ
žœ˜$šœžœž˜*J˜
J˜
Jšžœžœ˜—JšœžœC˜JJšœžœE˜LJš
œ˜Jš
œA˜AJš
œ˜—šœžœ˜+Jš
œ0˜0Jš
œ.˜.JšœžœC˜MJšœžœE˜OJš
œ˜Jš
œA˜AJš
œ˜—šœžœ˜*Jš
œ0˜0Jš
œ.˜.Jš
œA˜AJš
œ?˜?Jš
œA˜AJš
œ?˜?Jš
œ˜Jš
œB˜BJšœ
žœ
žœžœ@˜`Jš
œ˜—Jšžœžœ˜J˜—šžœžœ˜Jš
œ&˜&šœžœ
žœ˜.J™)—šžœžœ˜J™0Jšœžœžœ˜3šžœ
žœ
žœž˜!Jš
œ˜Jšžœ
˜—Jš
œ˜—J˜—˜J˜——šžœžœ	žœ’+˜SJšœ
žœ˜ Jšœ8žœ
žœžœ˜fšœžœ˜4Jš
œ(˜(Jšœ"žœ"˜GJš
œ˜—J˜Jšœžœ5˜SJš
œ˜J˜—Jš	žœ
žœ
’œ!žœž˜m˜Jšœžœ
˜J˜šžœžœ
žœ
˜J˜—š
œ˜š
œ)˜)Jš
œ	˜	Jš
œ#˜#Jš
œ˜Jš
œ4˜4Jš
œ˜—š
œ2˜2J˜——š
œ&˜&Jš
œD˜DJ˜—Jš
œ6˜6š
œ;˜;Jš
œ™J˜—Jšœžœžœ1˜]J˜J˜š	žœ	žœ
žœžœ-ž˜Rš
œ˜š
œ)˜)Jš
œ	˜	Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜—Jš
œ2˜2—Jš
œ˜šœžœ	ž˜/Jšœ
žœ:˜GJšœžœ?˜Nšœžœ˜'Jš
œ4˜4—Jšžœžœ˜—šžœžœ
žœ
žœ
žœžœžœ
ž˜EJšœ
žœ˜Jšœžœ-˜Hšœžœ
žœ-˜9Jš
œ$˜$—š
œ2˜2Jš
œ˜Jš
œ/˜/Jš
œ˜—Jšžœ
˜—Jš
œQ˜QJšœžœ˜:Jšœžœ’˜DJšžœ’	˜J˜—Jš
œ"˜"Jšžœ’
˜J˜—šžœžœ˜Jšœžœ˜;Jš
œ
˜
šžœžœ˜Jšœ
žœ˜ Jš
œ#˜#šœžœ
žœ˜DJš
œ&™&—J˜Jš
œ˜—Jš
œ
˜
Jšœžœ
˜J˜——˜Jšžœ’˜—Jšžœ’˜J˜—šžœžœ˜Jšœ
žœ
˜Jšœžœ˜;Jš
œ
˜
Jš
œ˜Jš
œ#˜#šœžœ
žœ˜DJš
œ&™&—J˜Jš
œ
˜
Jšœžœ
˜J˜J˜—Jšžœ
˜J˜J˜—š‘œžœ%˜9Jš
ž˜Jšžœ
˜J˜J˜—š‘
œžœ
žœCžœ˜}Jš
ž˜šžœžœ
ž˜š	œžœ
žœ
žœ
žœ˜Jš
ž˜Jš
’J™JJšœžœ
žœ0˜<Jšœžœžœ2˜Išžœ
˜J˜——˜šžœž˜š
œ˜Jš
ž˜Jšœžœ˜Jšœ6žœ5˜oJšžœ
˜J˜—šžœ˜!Jš
œ˜šžœ
˜Jšžœ˜Jšžœ9˜<—Jš
œ˜——J˜—Jšžœžœžœ
žœžœžœ
žœ
˜E—Jšžœ
˜J˜J˜—š‘	œžœ&˜5Jš
ž˜šžœ
žœžœ
žœžœžœ
žœžœ’˜eJšœ7’˜IJš
œ˜Jš
œ+˜+Jšœžœ4˜UJš
œ!˜!Jš
œ5˜5šžœžœ’˜6J˜š‘œžœ˜šžœ
žœ
žœ	ž˜šžœ
žœ
žœ	ž˜š
œ,˜,š
œ+˜+Jš
œ,˜,—Jš
œ˜—Jš
œ[˜[šžœ%ž˜+Jš
œ-˜-—Jšžœ
˜—Jšžœ
˜—Jš
œ˜J˜—JšœJ’˜VJšœJ’
˜WJšœJ’	˜SJšœJ’˜PJš
œ˜—J˜—Jšžœ
˜J˜J˜—Jšœ
žœžœ
˜!šœ
žœžœ˜Jš
œžœ
žœžœ
žœ	žœžœ˜PJšœžœ
˜Jšœžœ˜—J˜š
‘œžœ
žœ-žœ
žœ)˜
Jš
ž˜šžœ
žœ
ž˜Jš
ž˜Jš
œ˜Jš
œ
˜
Jš
œžœ
žœžœ
žœžœ
žœ˜>šœžœ
žœ˜"Jš
œ˜Jšœ(žœW˜‚
Jš
œ˜Jšœžœ(˜?Jš
œ˜Jšœ
žœ
˜Jšœžœ
˜Jš
œ˜Jš
œ˜J˜—šžœžœ
žœžœžœ
ž˜AJš
œ˜Jšœžœ
˜Jšœ!žœ3˜XJšžœ+žœ
žœ
˜8Jšœžœ$˜6Jšžœ
˜J˜—Jšœ!’)˜JJšžœ
˜—Jšžœ
˜J˜—š
‘œžœžœ
žœ
žœ
˜DJš
ž˜Jšœžœ˜(šžœžœž˜2Jš
ž˜Jš
œ.˜.šžœ ž˜&Jš
œ+˜+—Jš
œ-˜-Jšžœ
˜—Jšžœ
˜J˜J˜—š
‘
œž	œžœ
žœ’œ˜[Jšžœ
’+˜1J˜š‘œžœ˜Jš
ž˜Jšœžœ˜Jšœ,’˜=š
œ ˜ Jš
œ6˜6Jš
œA˜AJš
œ˜—Jš
œM˜Mšžœž˜Jš
ž˜š
œ˜Jš
œ	˜	Jš
œ	˜	Jš
œ˜Jš
œ˜Jš
œ˜J™'—Jš
œ+˜+Jš
œ*˜*Jšžœ
˜—Jšžœ
˜J˜—šžœžœ
ž˜šœžœ˜
šžœž˜
Jš
œ˜Jšžœžœ
˜——Jšžœžœ
˜—Jšžœ
˜J˜—J˜š‘œžœ
žœ˜!Jšžœ
ž˜
Jš
œ=˜=Jšœ	žœžœ#žœžœ
žœ
žœžœžœ˜•
Jšžœžœžœžœ
˜AJšžœ
˜J˜J˜—š‘œžœ+žœžœžœžœ˜pJš
ž˜Jšœžœ
˜Jšœžœ7˜Lšžœž˜š
œ˜Jšœžœ žœHžœžœžœžœžœ˜Θ
Jš
œ˜—š
œ˜Jšžœ	žœ	žœ
žœ
˜!JšœžœžœHžœ˜†
Jš
œ˜—Jšžœžœ
˜—Jš
œ7˜7Jšžœ
˜J˜J˜—š‘œžœžœžœžœ’œ˜MJš
œ˜J˜J˜—š‘œžœžœžœ˜KJš	œ
žœžœ	žœžœ˜BJ˜J˜—š‘	œžœžœ
žœžœžœ
žœ˜7Jš
œ
žœžœ
žœžœžœ
žœ˜2J˜J˜—š‘œžœ-˜CJšœžœ˜Jšœ%žœ
žœ˜Bšžœžœ˜%Jšœ™
žœ˜―
Jš
œ˜Jšœžœ!˜7šžœžœžœ
ž˜.Jšœ,žœ˜E—J˜—J˜J˜J˜—Jš
œ™J™š
œ˜J˜—Jšžœ’˜—J˜—…—VZuΠ