DIRECTORY
Ascii,
Atom,
CD,
CDAtomicObjects,
CDBasics,
CDCells,
CDCommandOps,
CDDirectory,
CDInstances, 
CDMakeProcPrivate,
CDProperties,
CDOrient,
CDSequencer,
CDSymbolicObjects,
Convert,
IO,
PriorityQueue,
RefTab,
Rope,
SymTab,
TerminalIO,
TiogaFileOps,
TiogaOps,
ViewerTools;

CDMakeProcCommands: CEDAR PROGRAM
IMPORTS Ascii, Atom, Convert, CD, CDAtomicObjects, CDBasics, CDCells, CDCommandOps, CDDirectory, CDInstances, CDProperties, CDOrient, CDSequencer, CDSymbolicObjects, IO, PriorityQueue, RefTab, Rope, SymTab, TerminalIO, TiogaFileOps, TiogaOps, ViewerTools
EXPORTS CDMakeProcPrivate = 
BEGIN

Environment: TYPE = REF EnvironmentRep;
EnvironmentRep: PUBLIC TYPE = RECORD [
invocationKey: REF,
rootNode: TiogaFileOps.Ref,

commentNode: TiogaFileOps.Ref, --insert sibling for next comment
modHeaderNode: TiogaFileOps.Ref, --DIRECTORY... to excluding BEGIN
declNode: TiogaFileOps.Ref, --insert sibling for next declaration on module level
procNode: TiogaFileOps.Ref, --insert sibling for next global procedures
procDecNode: TiogaFileOps.Ref, --insert sibling for next local declaration
postDeclNode: TiogaFileOps.Ref, --insert sibling for next declaration on module level
firstModStatementNode: TiogaFileOps.Ref, --reserved for first statement
modStatementNode: TiogaFileOps.Ref, --insert sibling for next mudule statement

procName: Rope.ROPE,
modifier: INT _ 0,
directory: SymTab.Ref,
imports: SymTab.Ref, 
declaredLayers: ARRAY CD.Layer OF Rope.ROPE _ ALL[NIL],
nameToThing: SymTab.Ref,
thingToName: RefTab.Ref,
globalThingToName: RefTab.Ref,

hasDirGen: BOOL _ FALSE,

properties: CD.PropRef
];
ExpressionProc: TYPE = CDMakeProcPrivate.ExpressionProc;

GetEnvironmentProp: PUBLIC PROC [env: Environment, key: REF] RETURNS [REF] = {
RETURN [CDProperties.GetProp[env.properties, key]]
};

PutEnvironmentProp: PUBLIC PROC [env: Environment, key: REF, val: REF] = {
CDProperties.PutProp[env.properties, key, val]
};

RegisterExpressionProc: PUBLIC PROC [for: REF, ep: ExpressionProc, tech: CD.Technology _ NIL] = {
WITH for SELECT FROM
c: CD.ObjectClass => 
CDProperties.PutProp[c.properties, $MakeCallExpression, NEW[ExpressionProc_ep]];
a: ATOM => RegisterExpressionProc[CD.FetchObjectClass[a, tech], ep, tech];
ENDCASE => ERROR
};

SpecificCallExpression: PROC [env: Environment, ob: CD.Object] RETURNS [r: Rope.ROPE  _ NIL] = {
x: REF _ CDProperties.GetProp[ob.class.properties, $MakeCallExpression];
WITH x SELECT FROM
rmce: REF ExpressionProc => r _ rmce^[env, ob]
ENDCASE => NULL;
};

MakeNodeComment: PROC [node: TiogaFileOps.Ref] = {
TRUSTED { TiogaOps.PutProp[LOOPHOLE[node], $Comment, NEW[BOOLEAN _ TRUE]] };
};

Reserve: PROC [env: Environment, key: Rope.ROPE] = {
[] _ SymTab.Store[env.nameToThing, key, $reserved];
};

IncludeDirectory: PUBLIC PROC [env: Environment, module: Rope.ROPE, import: BOOL_TRUE] = {
[] _ SymTab.Store[env.nameToThing, module, $module];
[] _ SymTab.Insert[env.directory, module, module];
IF import THEN [] _ SymTab.Insert[env.imports, module, module];
};

MakeDirectory: PROC [env: Environment] = {
r: Rope.ROPE _ NIL;

Each: SymTab.EachPairAction = {
IF num=0 THEN TiogaFileOps.SetContents[env.modHeaderNode, "DIRECTORY"]
ELSE r _ r.Concat[", "];
r _ r.Concat[key];
num _ num+1;
quit _ FALSE
};

num: INT _ 0;
[] _ env.directory.Pairs[Each];
IF num>0 THEN {
node: TiogaFileOps.Ref _ TiogaFileOps.InsertNode[env.modHeaderNode, TRUE];
TiogaFileOps.SetContents[node,  r.Concat[";"]];
}
ELSE TiogaFileOps.SetContents[env.modHeaderNode, ""];
};

MakeImportsExpr: PROC [env: Environment] RETURNS [r: Rope.ROPE _ NIL] = {
Each: SymTab.EachPairAction = {
IF num=0 THEN r _ "IMPORTS "
ELSE r _ r.Concat[", "];
r _ r.Concat[key];
num _ num+1;
quit _ FALSE
};
num: INT _ 0;
[] _ env.imports.Pairs[Each];
};

NewEnvironment: PROC [t: CD.Technology] RETURNS [env: Environment] = {
env _ NEW[EnvironmentRep_[properties: CD.InitPropRef[]]];
env.invocationKey _ NEW[INT];
env.rootNode _ TiogaFileOps.CreateRoot[];
env.commentNode _ TiogaFileOps.InsertNode[env.rootNode, TRUE];
TiogaFileOps.SetContents[env.commentNode, "--///temp/ChipNDale/temp.mesa"];
MakeNodeComment[env.commentNode];
env.commentNode _ TiogaFileOps.InsertNode[env.commentNode];
TiogaFileOps.SetContents[env.commentNode, "--created by ChipNDale"];
MakeNodeComment[env.commentNode];
env.modHeaderNode _ TiogaFileOps.InsertNode[env.commentNode];
env.declNode _ TiogaFileOps.InsertNode[env.modHeaderNode];
TiogaFileOps.SetContents[env.declNode, "BEGIN"];
GlobalDeclaration1[env, IO.PutFR["tech: CD.Technology _ CD.FetchTechnology[$%g];", IO.atom[t.key]]];
env.procNode _ TiogaFileOps.InsertNode[env.declNode];
TiogaFileOps.SetContents[env.procNode, ""];
env.postDeclNode _ TiogaFileOps.InsertNode[env.procNode];
TiogaFileOps.SetContents[env.postDeclNode, "table: CDGenerate.Table _ CDGenerate.AssertTable[""USER""];"];
env.firstModStatementNode _ env.modStatementNode _ TiogaFileOps.InsertNode[env.postDeclNode];
env.nameToThing _ SymTab.Create[];
env.directory _ SymTab.Create[];
env.imports _ SymTab.Create[];
env.thingToName _ RefTab.Create[];
env.globalThingToName _ RefTab.Create[];
};
FinishUp: PROC [env: Environment] = {
node: TiogaFileOps.Ref;
subNode: TiogaFileOps.Ref;
fileName: Rope.ROPE _ "///temp/ChipNDale/temp.mesa";
r: Rope.ROPE _ NIL;

MakeDirectory[env];
node _ TiogaFileOps.InsertNode[env.modHeaderNode];
TiogaFileOps.SetContents[node, "Temp: CEDAR PROGRAM"];

subNode _ TiogaFileOps.InsertNode[node, TRUE];
TiogaFileOps.SetContents[subNode, Rope.Cat[MakeImportsExpr[env], " ="]];

r _ IO.PutFR["[] _ table.Register[""%g"", %g];", IO.rope[env.procName], IO.rope[env.procName]];
TiogaFileOps.SetContents[env.firstModStatementNode, r]; 

GlobalStatement[env, "END."];
TiogaFileOps.Store[env.rootNode, fileName];
env.rootNode _ env.commentNode _ env.modHeaderNode _ NIL;
env.declNode _ env.procNode _ env.postDeclNode _ NIL;
env.firstModStatementNode _ env.modStatementNode _ NIL;
env.directory _ env.imports _ env.nameToThing _ NIL;
env.thingToName _ NIL;
env.globalThingToName _ NIL;
TerminalIO.WriteRope[fileName];
TerminalIO.WriteRope[" created\n"];
[] _ ViewerTools.MakeNewTextViewer[info: [
file: fileName, 
label: fileName, 
name: fileName,
iconic: FALSE
]];
};

MakeProcedureNode: PROC [env: Environment] RETURNS [TiogaFileOps.Ref] = {
env.procNode _ TiogaFileOps.InsertNode[env.procNode];
env.procDecNode _ NIL;
RETURN [env.procNode]
};

MakeDeclarationNode: PROC [env: Environment] RETURNS [TiogaFileOps.Ref] = {
env.declNode _ TiogaFileOps.InsertNode[env.declNode];
RETURN [env.declNode]
};

GlobalDeclaration1: PUBLIC PROC [env: Environment, line: Rope.ROPE] = {
node: TiogaFileOps.Ref _ MakeDeclarationNode[env];
TiogaFileOps.SetContents[node, line];
};

GlobalDeclaration2: PUBLIC PROC [env: Environment, line: Rope.ROPE] = {
env.postDeclNode _ TiogaFileOps.InsertNode[env.postDeclNode];
TiogaFileOps.SetContents[env.postDeclNode, line];
};

GlobalStatement: PUBLIC PROC [env: Environment, line: Rope.ROPE] = {
env.modStatementNode _ TiogaFileOps.InsertNode[env.modStatementNode];
TiogaFileOps.SetContents[env.modStatementNode, line];
};
MakeDirGenerator: PROC [env: Environment] = {
IF ~env.hasDirGen THEN {
env.hasDirGen _ TRUE;
GlobalDeclaration2[env, "directory: CDGenerate.Table _ CDGenerate.AssertTable[""DIRECTORY""];"];
}
};

RequestGlobalIdent: PUBLIC PROC[env: Environment, proposed: Rope.ROPE, whatFor: REF_NIL] RETURNS [Rope.ROPE] = {
RETURN [RequestIdent[env, proposed, whatFor, TRUE]];
};

GlobalIdent: PUBLIC PROC [env: Environment, whatFor: REF] RETURNS [Rope.ROPE] = {
RETURN [Ident[env, whatFor, TRUE]];
};

RopeToId: PROC [r: Rope.ROPE] RETURNS [id: Rope.ROPE] = {
first: BOOL _ TRUE;
Trans: Rope.TranslatorType = {
IF Ascii.Letter[old] THEN new _ old
ELSE IF Ascii.Digit[old] AND ~first THEN new _ old
ELSE new _ 'x;
first _ FALSE
};
id _ Rope.Translate[base: r, translator: Trans];
IF Rope.IsEmpty[id] THEN id _ "x";
};

RequestIdent: PROC [env: Environment, proposed: Rope.ROPE_NIL, whatFor: REF_NIL, global: BOOL_FALSE] RETURNS [r: Rope.ROPE] = {
proposed _ RopeToId[proposed];
r _ proposed;
DO
IF SymTab.Insert[env.nameToThing, r, whatFor] THEN {
IF global THEN 
[] _ RefTab.Store[env.globalThingToName, whatFor, r];
[] _ RefTab.Store[env.thingToName, whatFor, r];
RETURN;
};
env.modifier _ env.modifier+1;
r _ IO.PutFR["%gx%g", IO.rope[proposed], IO.int[env.modifier]]
ENDLOOP
};

Ident: PROC [env: Environment, whatFor: REF, global: BOOL] RETURNS [Rope.ROPE_NIL] = {
tab: RefTab.Ref _ IF global THEN env.globalThingToName ELSE env.thingToName;
WITH RefTab.Fetch[tab, whatFor].val SELECT FROM
n: Rope.ROPE => RETURN [n];
ENDCASE =>NULL;
};

IdentForLocalObject: PROC  [env: Environment, ob: CD.Object] RETURNS [name: Rope.ROPE] = {
first: CHAR;
name _ Ident[env, ob, FALSE];
IF name#NIL THEN RETURN [name];
name _ CDDirectory.Name[ob];
IF Rope.IsEmpty[name] THEN {
name _ Atom.GetPName[ob.class.objectType]
};
first _ Rope.Fetch[name];
IF Ascii.Letter[first] THEN first _ Ascii.Lower[first];
name _ Rope.Replace[
base: name, start: 0, len: 1, 
with: Rope.FromChar[first]
];
name _ RequestIdent[env, name, ob, FALSE];
};


PosToRope: PUBLIC PROC [pos: CD.Position] RETURNS [r: Rope.ROPE] = {
RETURN [IO.PutFR["[x: %g, y: %g]",
IO.int[pos.x], 
IO.int[pos.y] 
]]
};

RectToRope: PUBLIC PROC [rect: CD.Rect] RETURNS [r: Rope.ROPE] = {
RETURN [IO.PutFR["[x1: %g, y1: %g, x2: %g, y2: %g]",
IO.int[rect.x1], 
IO.int[rect.y1], 
IO.int[rect.x2], 
IO.int[rect.y2] 
]]
};

LayerIdent: PUBLIC PROC [env: Environment, l: CD.Layer] RETURNS [r: Rope.ROPE] = {
IF env.declaredLayers[l]=NIL THEN {
r: Rope.ROPE;
name: Rope.ROPE _ RequestIdent[env, Atom.GetPName[CD.LayerKey[l]]];
env.declaredLayers[l] _ name;
r _ IO.PutFR["%g: CD.Layer _ CD.FetchLayer[t: tech, uniqueKey: $%g];",
IO.rope[name],
IO.atom[CD.LayerKey[l]]
];
GlobalDeclaration1[env, r];
};
RETURN [env.declaredLayers[l]]
};

MapIPos: PROC [inst: CD.Instance] RETURNS [iPos: CD.Position] = {
iPos _ CDBasics.BaseOfRect[CDInstances.InstRectI[inst]];
};

MapClientPos: PROC [inst: CD.Instance] RETURNS [originPos: CD.Position] = {
RETURN [CDOrient.MapPoint[
pointInCell: CD.ClientOrigin[inst.ob],
cellSize: inst.ob.size,
cellInstOrient: inst.orientation,
cellInstPos: inst.location
]]
};

LocalStatement: PUBLIC PROC [env: Environment, line: Rope.ROPE] = {
node: TiogaFileOps.Ref;
node _ TiogaFileOps.InsertAsLastChild[env.procNode];
TiogaFileOps.SetContents[node, line];
};

ProgramText: PROC [ob: CD.Object, design: CD.Design, env: Environment] = {
env.procName _ RequestGlobalIdent[env, CDDirectory.Name[ob], ob];
IF ~CDCells.IsCell[ob] THEN ob _ CDDirectory.Expand[ob, design, NIL].new;
IF ob#NIL AND CDCells.IsCell[ob] THEN {
pq: PriorityQueue.Ref _ PriorityQueue.Create[SortPred, IF ob.size.x<ob.size.y THEN $y ELSE $x];
ir: CD.Rect;
hasInst: BOOL _ FALSE;
num: INT _ 0;
r: Rope.ROPE _ NIL;
cptr: CD.CellPtr = NARROW[ob.specificRef];
childs: RefTab.Ref _ RefTab.Create[];
node: TiogaFileOps.Ref _ MakeProcedureNode[env];
TiogaFileOps.SetContents[node, Rope.Cat[env.procName, ": CDGenerate.GeneratorProc ="]];
env.procDecNode _ TiogaFileOps.InsertAsLastChild[env.procNode];
TiogaFileOps.SetContents[env.procDecNode, "BEGIN"];
FOR list: CD.InstanceList _ cptr.contents, list.rest WHILE list#NIL DO
x: REF _ RefTab.Fetch[childs, list.first.ob].val;
PriorityQueue.Insert[pq, list.first];
IF x=NIL THEN {
num  _ num+1;
[] _ RefTab.Store[childs, list.first.ob, $first]
}
ELSE IF x=$first THEN {
r: Rope.ROPE _ IdentForLocalObject[env, list.first.ob];
num  _ num-1;
[] _ RefTab.Store[childs, list.first.ob, $hasName];
LocalStatement[env, Rope.Cat[r, ": CD.Object;"]];
} 
ELSE NULL;
ENDLOOP;
IF num#0 THEN LocalStatement[env, "child: CD.Object;"];
LocalStatement[env, "IF design.technology#tech THEN ERROR;"];
LocalStatement[env, "ob _ CDCells.CreateEmptyCell[];"];
FOR num: INT IN [0..PriorityQueue.Size[pq]) DO
inst: CD.Instance _ NARROW[PriorityQueue.Remove[pq]];

EachInst: PROC [inst: CD.Instance] = {
needInst: BOOL _ FALSE;
childName: Rope.ROPE _ "child";
pos: CD.Position _ MapClientPos[inst];
iPos: CD.Position _ MapIPos[inst];
orientationCode: Rope.ROPE _ NIL;
IF inst.orientation#0 THEN 
orientationCode _ IO.PutFR[", orientation: %g", IO.int[inst.orientation]];
SELECT RefTab.Fetch[childs, inst.ob].val FROM
$hasName => {
childName _ IdentForLocalObject[env, inst.ob];
[r, needInst] _ MakeACallExpression[env, inst.ob];
r _ Rope.Cat[childName, " _ ", r, ";"];
LocalStatement[env, r];
IF needInst THEN [] _ RefTab.Store[childs, inst.ob, $hasValueMI]
ELSE [] _ RefTab.Store[childs, inst.ob, $hasValue]
};
$hasValue => {
childName _ IdentForLocalObject[env, inst.ob];
needInst _ FALSE;
};
$hasValueMI => {
childName _ IdentForLocalObject[env, inst.ob];
needInst _ TRUE;
};
ENDCASE => {
childName _ "child";
[r, needInst] _ MakeACallExpression[env, inst.ob];
r _ Rope.Cat[childName, " _ ", r, ";"];
LocalStatement[env, r];
};
IF CDProperties.GetInstanceProp[inst, $SignalName]#NIL OR CDProperties.GetInstanceProp[inst, $InstanceName]#NIL THEN needInst _ TRUE;
IF needInst THEN {
hasInst _ TRUE;
r _ Rope.Cat[
IO.PutFR["inst _ CDCells.IncludeOb[cell: ob, ob: %g, position: %g%0g, obCSystem: interrestCoords].newInst;",
IO.rope[childName], 
IO.rope[PosToRope[iPos]], 
IO.rope[orientationCode] 
]];
}
ELSE {
r _ Rope.Cat[
IO.PutFR["[] _ CDCells.IncludeOb[cell: ob, ob: %g, position: %g%0g, obCSystem: interrestCoords];",
IO.rope[childName], 
IO.rope[PosToRope[iPos]], 
IO.rope[orientationCode] 
]];
};
LocalStatement[env, r];
IF needInst THEN MakeInstanceStuff[env, inst];
};

EachInst[inst];
ENDLOOP; 


ir _ CD.InterestRect[ob];
r _ Rope.Cat["CDCells.SetInterestRect[ob, ", RectToRope[ir], "];"];
LocalStatement[env, r];
r _ Rope.Cat["[] _ CDDirectory.Include[design: design, object: ob"];
IF cptr.name#NIL THEN 
r _ Rope.Cat[r, ", alternateName: ", RopeToRope[cptr.name]];
r _ Rope.Cat[r, "];"];
LocalStatement[env, r];
LocalStatement[env, "END;"];
LocalStatement[env, ""];
IF hasInst THEN {
env.procDecNode _ TiogaFileOps.InsertNode[env.procDecNode];
TiogaFileOps.SetContents[env.procDecNode, "inst: CD.Instance;"];
};
childs _ NIL;
}
ELSE {
TerminalIO.WriteRope["**could not convert to cell\n"];
ERROR ABORTED;
}
};

RopeToRope: PUBLIC PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = {
RETURN [Convert.RopeFromRope[r]];
};

AtomToRope: PUBLIC PROC [env: Environment, a: ATOM] RETURNS [Rope.ROPE] = {
r: Rope.ROPE _ Atom.GetPName[a];
leng: INT _ Rope.Length[r];
normalCase: BOOL _ leng>0;
FOR i: INT IN [0..leng) DO
c: CHAR _ Rope.Fetch[r, i];
IF ~(Ascii.Letter[c] OR Ascii.Digit[c]) THEN {normalCase_FALSE; EXIT}
ENDLOOP;
IF normalCase THEN RETURN [Rope.Cat["$", r]];
IncludeDirectory[env, "Atom"];
RETURN [ Rope.Cat["Atom.MakeAtom[", Convert.RopeFromRope[r], "]"] ];
};

MakeInstanceStuff: PROC[env: Environment, inst: CD.Instance] = {
r: Rope.ROPE_NIL;

HandleProp: PROC [key: ATOM] = {
val: Rope.ROPE _ CDCommandOps.ToRope[CDProperties.GetInstanceProp[inst, key]];
IF ~Rope.IsEmpty[val] THEN {
r: Rope.ROPE _ Rope.Cat[
"CDProperties.PutInstanceProp[inst, ", 
AtomToRope[env, key], 
", ", 
RopeToRope[val], 
"];"
];
IncludeDirectory[env, "CDProperties"];
LocalStatement[env, r];
};
};

IF CDSymbolicObjects.IsSymbolicOb[inst.ob] THEN {
l: CD.Layer;
owner: ATOM;
name: Rope.ROPE _ CDSymbolicObjects.GetName[inst]; 
IF ~Rope.IsEmpty[name] THEN {
r _ Rope.Cat["CDSymbolicObjects.SetName[inst, ", RopeToRope[name], "];"];
LocalStatement[env, r];
};
l _ CDSymbolicObjects.GetLayer[inst];
IF l#CD.undefLayer THEN {
r _ Rope.Cat["CDSymbolicObjects.SetLayer[inst, ", LayerIdent[env, l], "];"];
LocalStatement[env, r];
};
owner  _ CDSymbolicObjects.GetOwner[inst];
IF owner#NIL THEN {
r _ Rope.Cat["CDSymbolicObjects.SetOwner[inst, ", AtomToRope[env, owner], "];"];
LocalStatement[env, r];
};
}
ELSE {
HandleProp[$SignalName];
HandleProp[$InstanceName];
}
};

SortPred: PriorityQueue.SortPred = {
p1: CD.Position _ CDBasics.BaseOfRect[CDInstances.InstRectI[NARROW[x]]];
p2: CD.Position _ CDBasics.BaseOfRect[CDInstances.InstRectI[NARROW[y]]];
IF data=$y AND p1.y#p2.y THEN RETURN[p1.y<p2.y];
IF p1.x=p2.x THEN RETURN[p1.y<p2.y];
RETURN [p1.x<p2.x];
};

MakeACallExpression: PROC[env: Environment, ob: CD.Object] RETURNS [r: Rope.ROPE _ NIL, mustHandleInstance: BOOL _ FALSE] = {
r _ SpecificCallExpression[env, ob];
IF Rope.IsEmpty[r] THEN {
IF ob.class.inDirectory THEN {
MakeDirGenerator[env];
r _ Rope.Cat["CDGenerate.FetchNCall[directory, design, ", RopeToRope[CDDirectory.Name[ob]], "]"];
}
ELSE IF CDAtomicObjects.IsAtomicOb[ob] THEN {
IncludeDirectory[env, "CDAtomicObjects"];
r _ "CDAtomicObjects.CreateAtomicOb[classKey: ";
r _ Rope.Cat[r, "$", CDCommandOps.ToRope[ob.class.objectType], ", size: "];
r _ Rope.Cat[r, PosToRope[CD.InterestSize[ob]], ", "];
r _ Rope.Cat[r, "tech: tech, lev: ", LayerIdent[env, ob.layer], "]"];
}
ELSE IF CDSymbolicObjects.IsPin[ob] THEN {
IncludeDirectory[env, "CDSymbolicObjects"];
r _ IO.PutFR["CDSymbolicObjects.CreatePin[%g]", IO.rope[PosToRope[ob.size]]];
mustHandleInstance _ TRUE;
}
ELSE IF CDSymbolicObjects.IsSegment[ob] THEN {
IncludeDirectory[env, "CDSymbolicObjects"];
r _ IO.PutFR["CDSymbolicObjects.CreateSegment[length: %g, dummyWidth: %g]", IO.int[ob.size.y], IO.int[ob.size.x]];
mustHandleInstance _ TRUE;
}
ELSE IF CDSymbolicObjects.IsMark[ob] THEN {
IncludeDirectory[env, "CDSymbolicObjects"];
r _ IO.PutFR["CDSymbolicObjects.CreateMark[dummySize: %g]", IO.int[ob.size.y]];
mustHandleInstance _ TRUE;
}
ELSE IF ob.class.wireTyped THEN {
IncludeDirectory[env, "CDRects"];
r _ "CDRects.CreateRect[size: ";
r _ Rope.Cat[r, PosToRope[CD.InterestSize[ob]]];
r _ Rope.Cat[r, ", l: ", LayerIdent[env, ob.layer], "]"];
}
ELSE {
r _ "--Unknown[]--";
IncludeDirectory[env, "CDRects"];
r _ Rope.Cat[r, "CDRects.CreateRect[size: "];
r _ Rope.Cat[r, PosToRope[CD.InterestSize[ob]]];
r _ Rope.Cat[r, ", l: CD.highLightError]"];
};
};
};

MakeProgramCommand: PROC [comm: CDSequencer.Command] = {
inst: CD.Instance = CDCommandOps.TheInstance[comm, "make program text"];
IF inst#NIL THEN {
env: Environment _ NewEnvironment[comm.design.technology]; 
Reserve[env, "design"];
Reserve[env, "key"];
Reserve[env, "table"];
Reserve[env, "directory"];
Reserve[env, "imports"];
Reserve[env, "data"];
Reserve[env, "tech"];
Reserve[env, "child"];
Reserve[env, "ob"];
Reserve[env, "inst"];
IncludeDirectory[env, "CDCells"];
IncludeDirectory[env, "CDGenerate"];
IncludeDirectory[env, "CD"];
IncludeDirectory[env, "CDDirectory"];
ProgramText[inst.ob, comm.design, env];
FinishUp[env];
}
};

[] _ CDProperties.RegisterProperty[$MakeCallExpression, $chj];
CDSequencer.ImplementCommand[$MakeProgram, MakeProgramCommand,, doQueue];
TerminalIO.WriteRope["make program command loaded\n"];
END.




tCDMakeProcCommands.mesa   (module for ChipNDale)
Copyright c 1985 by Xerox Corporation.  All rights reserved.
by Christian Jacobi, May 9, 1985 1:58:40 pm PDT 
Last edited by: Christian Jacobi, October 17, 1986 11:15:42 am PDT



--given an instance find the origin in interest coordinates
--make declarations
--make instances
--interest rect
--include in directory

ΚE˜
codeš
œ0™0Kšœ
Οm
œ1™<Kš
œ0™0K™BK˜—š
Οk	˜	Kš
œ˜Kš
œ˜Kšžœ
˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ	˜	K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ
˜
Kš
œ	˜	Kš
œ˜—K˜šΟnœžœ
ž˜!Kšžœžœ†
žœV˜ώ
Kšžœ˜—Kš
ž˜K˜Kšœ
žœžœ˜'šœžœžœ˜&Kšœžœ
˜Kš
œ˜K˜KšœΟc!˜@Kšœ! !˜BKšœ 5˜QKšœ +˜GKšœ +˜JKšœ  5˜UKšœ) ˜GKšœ$ œ˜NK˜Kšœžœ
˜Kšœ
žœ˜Kš
œ˜Kš
œ˜Kš
œžœ
žœžœžœžœ
žœ˜7Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšœžœžœ
˜K˜Kšœžœ˜Kš
œ˜—K™Kšœžœ$˜8K˜šŸœžœ
žœžœžœžœ˜NKšžœ,˜2K˜—K˜š
Ÿœžœ
žœžœžœ˜JKš
œ.˜.K˜—K˜š
Ÿœžœžœžœžœ˜ašžœžœ
ž˜šœžœ˜Kšœ8žœ˜P—Kšœžœžœ&˜JKšžœž˜—Kš
œ˜—K˜šŸœžœžœ	žœ
žœžœ˜`KšœžœB˜Hšžœžœ
ž˜Kšœžœ%˜.Kšžœžœ
˜—Kš
œ˜—K˜šŸœžœ˜2Kš
žœžœžœ
žœžœ˜LKš
œ˜—K˜šŸœžœžœ˜4Kš
œ3˜3Kš
œ˜—K˜šŸœžœ
žœ!žœ
žœ
žœ˜ZKš
œ4˜4Kš
œ2˜2Kšžœžœ1˜?Kš
œ˜—K˜šŸ
œžœ˜*Kšœžœžœ
˜K˜šΠbnœ˜Kšžœžœ9˜FKšžœ˜Kš
œ˜Kš
œ˜Kšœž˜Kš
œ˜—K˜Kšœžœ˜
Kš
œ˜šžœžœ˜KšœDžœ˜JKš
œ/˜/K˜
—Kšžœ1˜5Kš
œ˜—K˜š
Ÿœžœžœ
žœžœ˜IšΟbœ˜Kšžœžœ˜Kšžœ˜Kš
œ˜Kš
œ˜Kšœž˜Kš
œ˜—Kšœžœ˜
Kš
œ˜Kš
œ˜—K˜šŸœžœžœ
žœ˜FKšœžœžœ˜9Kšœžœ
žœ˜Kš
œ)˜)šœ8žœ˜>Kš
œK˜KKš
œ!˜!—š
œ;˜;Kš
œD˜DKš
œ!˜!—Kš
œ=˜=Kš
œ:˜:Kš
œ0˜0KšœžœΠfs-œžœ˜dKš
œ5˜5Kš
œ+˜+Kš
œ9˜9Kš
œj˜jKš
œ]˜]Kš
œ"˜"Kš
œ ˜ Kš
œ˜Kš
œ"˜"Kš
œ(˜(Kš
œ˜—K™šŸœžœ˜%Kš
œ˜Kš
œ˜Kšœžœ!˜4Kšœžœžœ
˜K˜Kš
œ˜Kš
œ2˜2Kš
œ6˜6K˜Kšœ(žœ˜.Kš
œH˜HK˜Kš	œžœ£œžœžœ˜_Kš
œ8˜8K˜Kš
œ˜Kš
œ+˜+Kšœ5žœ
˜9Kšœ1žœ
˜5Kšœ3žœ
˜7Kšœ0žœ
˜4Kšœžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ#˜#š
œ*˜*Kš
œ˜Kš
œ˜Kš
œ˜Kšœž˜
Kš
œ˜—Kš
œ˜—K˜šŸœžœžœ˜IKš
œ5˜5Kšœžœ
˜Kšžœ˜Kš
œ˜—K˜šŸœžœžœ˜KKš
œ5˜5Kšžœ˜Kš
œ˜—K˜šŸœžœžœ˜GKš
œ2˜2Kš
œ%˜%Kš
œ˜—K˜šŸœžœžœ˜GKš
œ=˜=Kš
œ1˜1Kš
œ˜—K˜šŸœžœžœ˜DKš
œE˜EKš
œ5˜5Kš
œ˜—K™šŸœžœ˜-šžœžœ˜Kšœžœ
˜Kšœ£Dœ˜`Kš
œ
˜
—Kš
œ˜—K˜šŸœžœ
žœ"žœžœ
žœžœžœ˜pKšžœ'žœ˜4Kš
œ˜—K˜šŸœžœ
žœžœžœžœ˜QKšžœžœ˜#Kš
œ˜—K˜š
Ÿœžœ
žœžœžœ˜9Kšœžœžœ
˜š‘œ˜Kšžœžœ
˜#Kšžœ
žœžœžœ
˜2Kšžœ
˜Kšœž˜
Kš
œ˜—Kš
œ0˜0Kšžœžœ
˜"Kš
œ˜—K˜šŸœžœ#žœ
žœžœ
žœ
ž
œžœ
žœ˜Kš
œ˜Kš
œ
˜
š
ž˜šžœ,žœ˜4šžœžœ
˜Kš
œ5˜5—Kš
œ/˜/Kšžœ
˜K˜—Kš
œ˜Kš	œžœ£œžœžœ˜>Kš
ž˜—Kš
œ˜—K˜šŸœžœžœ
žœžœžœ
žœ˜VKšœžœžœžœ˜Lšžœ žœ
ž˜/Kšœžœžœ˜Kšžœžœ
˜—Kš
œ˜—K˜š
Ÿœžœžœ	žœ
žœ˜ZKšœžœ
˜Kšœžœ˜Kšžœžœ
žœ
žœ˜Kš
œ˜šžœžœ˜Kš
œ)˜)K˜—Kš
œ˜Kšžœžœ˜7š
œ˜Kš
œ˜Kš
œ˜K˜—Kšœ#žœ˜*Kš
œ˜K˜—K˜š
Ÿ	œžœžœžœ
žœ˜Dšžœžœ£˜"Kšžœ
˜Kšžœ˜Kš
œ˜—Kš
œ˜—K˜š
Ÿ
œžœžœžœ
žœ˜Bšžœžœ£"˜4Kšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—Kš
œ˜—K˜š
Ÿ
œžœžœžœ
žœ˜Ršžœžœ
žœ˜#Kšœžœ
˜
Kšœžœ#žœ˜CKš
œ˜šœžœ£5œ˜FKšžœ˜Kšžœžœ
˜Kš
œ˜—Kš
œ˜K˜—Kšžœ˜Kš
œ˜K˜—š
Ÿœžœžœžœžœ˜AKš
œ;™;Kš
œ8˜8Kš
œ˜—K˜š
Ÿœžœžœžœ
žœ˜Kšžœ˜Kšœ
žœ˜&Kš
œ˜Kš
œ!˜!Kš
œ˜K˜—Kš
œ˜—K˜šŸœžœžœ˜CKš
œ˜Kš
œ4˜4Kš
œ%˜%Kš
œ˜—K˜šŸœžœžœžœ˜JKš
œA˜AKšžœžœ%žœ˜Išžœžœ
žœžœ˜'Kšœ7žœžœžœ˜_Kšœžœ˜Kšœ	žœžœ
˜Kšœžœ˜
Kšœžœžœ
˜Kšœžœžœ˜*K˜%Kš
œ0˜0Kšœ7£œ˜WKš
œ?˜?Kšœ+£œ˜3Kš
œ™š	žœžœ)žœžœ
ž˜FKšœžœ+˜1Kš
œ%˜%šžœžœ
žœ˜Kš
œ
˜
Kš
œ0˜0K˜
—šžœ
žœ
žœ˜Kšœžœ+˜7Kš
œ
˜
Kš
œ3˜3Kšœ!£œ˜1Kš
œ˜—Kšžœ
žœ
˜
Kšžœ
˜—Kšžœžœ£œ˜7Kšœ£%œ˜=Kšœ£œ˜7Kš
œ™šžœžœ
žœž˜.Kšœžœžœ˜5K˜šŸœžœžœ˜&Kšœ
žœžœ
˜Kšœžœ£œ˜Kšœžœ˜&Kšœžœ˜"Kšœžœžœ
˜!šžœžœ
˜Kšœžœ£œžœ˜J—šžœ#ž˜-š
œ
˜
Kš
œ.˜.Kš
œ2˜2Kšœ£œ£˜'Kš
œ˜Kšžœ
žœ0˜@Kšžœ.˜2Kš
œ˜—š
œ˜Kš
œ.˜.Kšœžœ
˜K˜—š
œ˜Kš
œ.˜.Kšœžœ
˜K˜—šžœ˜Kš
œ˜Kš
œ2˜2Kšœ£œ£˜'Kš
œ˜K˜——Kšžœ1žœ
žœ3žœ
žœžœ
˜…
šžœ
žœ˜Kšœ
žœ
˜š
œ
˜
Kšžœ£Xœ£˜lKšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—K˜
—šžœ˜š
œ
˜
Kšžœ£X˜bKšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—K˜—Kš
œ˜Kšžœ
žœ˜.Kš
œ˜—K˜Kš
œ˜Kšžœ
˜	—K˜K˜š
œ™Kšœžœ˜Kšœ£œ£œ˜CKš
œ˜—š
œ™Kšœ£3œ˜Dšžœžœ
žœ
˜Kš
œ<˜<—Kšœ£œ˜Kš
œ˜—Kšœ£œ˜Kš
œ˜šžœ	žœ˜Kš
œ;˜;Kšœ+£œ˜@K˜—Kšœ	žœ
˜
Kš
œ
˜
—šžœ˜K˜6Kšžœ
ž˜K˜
—Kš
œ˜—K˜š
Ÿ
œžœ
žœžœžœ˜>Kšžœ˜!Kš
œ˜—K˜š
Ÿ
œžœžœžœžœ˜KKšœžœ˜ Kšœžœ˜Kšœžœ
˜šžœžœ
žœž˜Kšœžœ˜Kš
žœžœžœ
žœžœ
˜EKšžœ
˜—Kšžœžœ
žœ˜-Kš
œ˜Kšžœ
£œ£
œ˜DKš
œ˜—K˜šŸœžœžœ˜@Kšœžœ
žœ
˜K˜šŸ
œžœžœ˜ Kšœ
žœ@˜Nšžœžœ˜šœžœ˜Kšœ
£#œ˜'Kš
œ˜Kšœ
£œ˜Kš
œ˜Kšœ
£œ
˜Kš
œ˜—Kš
œ&˜&Kš
œ˜K˜—Kš
œ˜—K˜šžœ)žœ˜1Kšœžœ˜Kšœžœ
˜Kšœžœ$˜3šžœžœ˜Kšœ£Οsœ€œ˜IKš
œ˜K˜—Kš
œ%˜%šžœž
œ
žœ˜Kšœ£€œ€œ˜LKš
œ˜K˜—Kš
œ*˜*šžœžœ
žœ˜Kšœ£€œ€œ˜PKš
œ˜K˜—Kš
œ
˜
—šžœ˜Kš
œ˜Kš
œ˜K˜
—Kš
œ˜—K˜šŸœ˜$Kšœžœ6žœ˜HKšœžœ6žœ˜HKšžœ	žœžœ
žœ˜0Kšžœžœ
žœ˜$Kšžœ
˜K˜—K˜šŸœžœžœ	žœ
žœžœžœžœ˜}Kš
œ$˜$šžœžœ˜šžœžœ˜Kš
œ˜Kšœ£*œ#£œ
£˜aK˜
—šžœ
žœ žœ˜-Kš
œ)˜)Kš
œ0˜0Kš
œK˜KKšœžœ˜6Kšœ£œ£
œ˜EKš
œ
˜
—šžœ
žœžœ˜*Kš
œ+˜+Kš	œžœ£œ£
œžœ˜MKšœž˜Kš
œ
˜
—šžœ
žœ!žœ˜.Kš
œ+˜+Kšœžœ£(œ£œ£
œžœ£žœ˜rKšœžœ
˜Kš
œ
˜
—šžœ
žœžœ˜+Kš
œ+˜+Kš	œžœ£(œ£
œžœ˜OKšœžœ
˜Kš
œ
˜
—šžœ
žœžœ˜!Kš
œ!˜!Kšœ£œ˜ Kšœžœ˜0Kšœ£œ£
œ˜9Kš
œ
˜
—šžœ˜Kšœ£œ˜Kš
œ!˜!Kšœ£œ˜-Kšœžœ˜0Kšœ£œ£
œ˜+Kš
œ˜—Kš
œ˜—Kš
œ˜—K˜šŸœžœ ˜8Kšœžœ@˜Hšžœžœ
žœ˜Kš
œ;˜;Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ$˜$Kš
œ˜Kš
œ%˜%Kš
œ'˜'Kš
œ˜Kš
œ
˜
—Kš
œ˜—K˜K™Kš
œ>˜>Kš
œI˜IKš
œ6˜6Kšžœ
˜K˜K˜K˜—…—HΆao