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

CDMakeProcCommands: CEDAR PROGRAM
IMPORTS Ascii, Atom, Convert, CD, CDAtomicObjects, CDCells, CDCommandOps, CDDirectory, CDMenus, CDProperties, CDOrient, CDSequencer, CDSymbolicObjects, IO, 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

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.PropList
];
ExpressionProc: TYPE = CDMakeProcPrivate.ExpressionProc;

RegisterExpressionProc: PUBLIC PROC [for: REF, ep: ExpressionProc, tech: CD.Technology _ NIL] =
BEGIN
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
END;

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

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

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

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

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

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

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, ""];
END;

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

NewEnvironment: PROC [t: CD.Technology] RETURNS [env: Environment] =
BEGIN
env _ NEW[EnvironmentRep];
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[];
END;
FinishUp: PROC [env: Environment] =
BEGIN
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 _ "[] _ table.Register[""Temp"", CreateCell];";
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
]];
END;

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

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

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

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

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

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

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

RequestIdent: PROC [env: Environment, proposed: Rope.ROPE_NIL, whatFor: REF_NIL, global: BOOL_FALSE] RETURNS [r: Rope.ROPE] =
BEGIN

Trans: Rope.TranslatorType =
BEGIN
IF Ascii.Letter[old] THEN new _ old
ELSE IF Ascii.Digit[old] AND ~first THEN new _ old
ELSE new _ 'x;
first _ FALSE
END;

first: BOOL _ TRUE;
proposed _ Rope.Translate[base: proposed, translator: Trans];
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
END;

Ident: PROC [env: Environment, whatFor: REF, global: BOOL] RETURNS [Rope.ROPE_NIL] =
BEGIN
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;
END;

IdentForLocalObject: PROC  [env: Environment, ob: CD.Object] RETURNS [name: Rope.ROPE] =
BEGIN
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];
END;


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

RectToRope: PUBLIC PROC [rect: CD.Rect] RETURNS [r: Rope.ROPE] =
BEGIN
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] 
]]
END;

LayerIdent: PUBLIC PROC [env: Environment, l: CD.Layer] RETURNS [r: Rope.ROPE] =
BEGIN
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]]
END;

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

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

ProgramText: PROC [ob: CD.Object, design: CD.Design, env: Environment] =
BEGIN
IF ~CDCells.IsCell[ob] THEN ob _ CDDirectory.Expand[ob, design, NIL].new;
IF ob#NIL AND CDCells.IsCell[ob] THEN {
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, "CreateCell: 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;
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 list: CD.InstanceList _ cptr.contents, list.rest WHILE list#NIL DO
needInst: BOOL _ FALSE;
childName: Rope.ROPE _ "child";
pos: CD.Position _ MapClientPos[inst: list.first];
orientationCode: Rope.ROPE _ NIL;
IF list.first.orientation#0 THEN 
orientationCode _ IO.PutFR[", orientation: %g", IO.int[list.first.orientation]];
SELECT RefTab.Fetch[childs, list.first.ob].val FROM
$hasName => {
childName _ IdentForLocalObject[env, list.first.ob];
[r, needInst] _ MakeACallExpression[env, list.first.ob];
r _ Rope.Cat[childName, " _ ", r, ";"];
LocalStatement[env, r];
IF needInst THEN [] _ RefTab.Store[childs, list.first.ob, $hasValueMI]
ELSE [] _ RefTab.Store[childs, list.first.ob, $hasValue]
};
$hasValue => {
childName _ IdentForLocalObject[env, list.first.ob];
needInst _ FALSE;
};
$hasValueMI => {
childName _ IdentForLocalObject[env, list.first.ob];
needInst _ TRUE;
};
ENDCASE => {
childName _ "child";
[r, needInst] _ MakeACallExpression[env, list.first.ob];
r _ Rope.Cat[childName, " _ ", r, ";"];
LocalStatement[env, r];
};
IF CDProperties.GetInstanceProp[list.first, $SignalName]#NIL OR CDProperties.GetInstanceProp[list.first, $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].newInst;",
IO.rope[childName], 
IO.rope[PosToRope[pos]], 
IO.rope[orientationCode] 
]];
}
ELSE {
r _ Rope.Cat[
IO.PutFR["[] _ CDCells.IncludeOb[cell: ob, ob: %g, position: %g%0g];",
IO.rope[childName], 
IO.rope[PosToRope[pos]], 
IO.rope[orientationCode] 
]];
};
LocalStatement[env, r];
IF needInst THEN MakeInstanceStuff[env, list.first];
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;
}
END;

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

AtomToRope: PUBLIC PROC [env: Environment, a: ATOM] RETURNS [Rope.ROPE] =
BEGIN
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], "]"] ];
END;

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

HandleProp: PROC [key: ATOM] =
BEGIN
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];
};
END;

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

MakeACallExpression: PROC[env: Environment, ob: CD.Object] RETURNS [r: Rope.ROPE _ NIL, mustHandleInstance: BOOL _ FALSE] =
BEGIN
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]"];
};
};
END;

MakeProgramCommand: PROC [comm: CDSequencer.Command] =
BEGIN
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, "data"];
Reserve[env, "tech"];
Reserve[env, "child"];
Reserve[env, "CreateCell"];
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];
}
END;


[] _ CDProperties.RegisterProperty[$MakeCallExpression, $chj];
CDSequencer.ImplementCommand[$MakeProgram, MakeProgramCommand,, doQueue];
CDMenus.CreateEntry[menu: $ProgramMenu, entry: "make text", key: $MakeProgram];
TerminalIO.WriteRope["make program command loaded\n"];
END.




ŽCDMakeProcCommands.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 Christian Jacobi, March 25, 1986 6:27:17 pm PST



--make declarations
--make instances
--interest rect
--include in directory
--XX SPECIAL OBJECTS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

--XX INIT XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Κφ˜
codeš
œ0™0Kšœ
Οm
œ1™<Kš
œ0™0Kš
œ;™;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˜šΠblœžœ
ž˜!KšžœžœvžœG˜α
Kšžœ˜—Kš
ž˜K˜Kšœ
žœžœ˜'šœžœžœ˜&Kšœžœ
˜Kš
œ˜K˜KšœΟc!˜@Kšœ! !˜BKšœ 5˜QKšœ +˜GKšœ +˜JKšœ  5˜UKšœ) ˜GKšœ$ œ˜NK˜Kšœ
žœ˜Kš
œ˜Kš
œ˜Kš
œžœ
žœžœžœžœ
žœ˜7Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšœžœžœ
˜K˜Kšœžœ	˜Kš
œ˜—K™Kšœžœ$˜8K˜š
Οnœžœžœžœžœ˜_Kš
ž˜šžœžœ
ž˜šœžœ˜Kšœ8žœ˜P—Kšœžœžœ&˜JKšžœž˜—Kšžœ
˜—K˜š‘œžœžœ	žœ
žœžœ˜^Kš
ž˜KšœžœB˜Hšžœžœ
ž˜Kšœžœ%˜.Kšžœžœ
˜—Kšžœ
˜—K˜š‘œžœ˜0Kš
ž˜Kš
žœžœžœ
žœžœ˜LKšžœ
˜—K˜š‘œžœžœ˜2Kš
ž˜Kš
œ3˜3Kšžœ
˜—K˜š
‘œžœ!žœ
žœ
žœ˜XKš
ž˜Kš
œ4˜4Kš
œ2˜2Kšžœžœ1˜?Kšžœ
˜—K˜š‘
œžœ˜(Kš
ž˜Kšœžœž˜K˜šΟbœ˜Kš
ž˜Kšžœžœ9˜FKšžœ˜Kš
œ˜Kš
œ˜Kšœž˜Kšžœ
˜—K˜Kšœžœ˜
Kš
œ˜šžœžœ˜KšœDžœ˜JKš
œ/˜/K˜
—Kšžœ1˜5Kšžœ
˜—K˜š
‘œžœžœ
žœžœ˜GKš
ž˜š’œ˜Kš
ž˜Kšžœžœ˜Kšžœ˜Kš
œ˜Kš
œ˜Kšœž˜Kšžœ
˜—Kšœžœ˜
Kš
œ˜Kšžœ
˜—K˜š‘œžœžœ
žœ˜DKš
ž˜Kšœžœ˜Kšœžœ
žœ˜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š
œ˜Kšœžœ!˜4Kšœžœžœ
˜K˜Kš
œ˜Kš
œ2˜2Kš
œ6˜6K˜Kšœ(žœ˜.Kš
œH˜HK˜Kš
œ1˜1Kš
œ8˜8K˜Kš
œ˜Kš
œ+˜+Kšœ5žœ
˜9Kšœ1žœ
˜5Kšœ3žœ
˜7Kšœ0žœ
˜4Kšœžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ#˜#š
œ*˜*Kš
œ˜Kš
œ˜Kš
œ˜Kšœž˜
Kš
œ˜—Kšžœ
˜—K˜š‘œžœžœ˜GKš
ž˜Kš
œ5˜5Kšœžœ
˜Kšžœ˜Kšžœ
˜—K˜š‘œžœžœ˜IKš
ž˜Kš
œ5˜5Kšžœ˜Kšžœ
˜—K˜š‘œžœžœ˜EKš
ž˜Kš
œ2˜2Kš
œ%˜%Kšžœ
˜—K˜š‘œžœžœ˜EKš
ž˜Kš
œ=˜=Kš
œ1˜1Kšžœ
˜—K˜š‘œžœžœ˜BKš
ž˜Kš
œE˜EKš
œ5˜5Kšžœ
˜—K™š‘œžœ˜+Kš
ž˜šžœžœ˜Kšœžœ
˜Kšœ£Dœ˜`Kš
œ
˜
—Kšžœ
˜—K˜š‘œžœ
žœ"žœžœ
žœžœžœ˜nKš
ž˜Kšžœ'žœ˜4Kšžœ
˜—K˜š‘œžœ
žœžœžœžœ˜OKš
ž˜Kšžœžœ˜#Kšžœ
˜—K˜š‘œžœ#žœ
žœžœ
žœ
ž
œžœ
žœ˜}Kš
ž˜K˜š’œ˜Kš
ž˜Kšžœžœ
˜#Kšžœ
žœžœžœ
˜2Kšžœ
˜Kšœž˜
Kšžœ
˜—K˜Kšœžœžœ
˜Kš
œ=˜=Kš
œ
˜
š
ž˜šžœ,žœ˜4šžœžœ
˜Kš
œ5˜5—Kš
œ/˜/Kšžœ
˜K˜—Kš
œ˜Kš	œžœ£œžœžœ˜>Kš
ž˜—Kšžœ
˜—K˜š‘œžœžœ
žœžœžœ
žœ˜TKš
ž˜Kšœžœžœžœ˜Lšžœ žœ
ž˜/Kšœžœžœ˜Kšžœžœ
˜—Kšžœ
˜—K˜š
‘œžœžœ	žœ
žœ˜XKš
ž˜Kšœžœ
˜Kšœžœ˜Kšžœžœ
žœ
žœ˜Kš
œ˜šžœžœ˜Kš
œ)˜)K˜—Kš
œ˜Kšžœžœ˜7š
œ˜Kš
œ˜Kš
œ˜K˜—Kšœ#žœ˜*Kšžœ
˜K˜—K˜š
‘	œžœžœžœ
žœ˜BKš
ž˜šžœžœ£˜"Kšžœ
˜Kšžœ˜Kš
œ˜—Kšžœ
˜—K˜š
‘
œžœžœžœ
žœ˜@Kš
ž˜šžœžœ£"˜4Kšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—Kšžœ
˜—K˜š
‘
œžœžœžœ
žœ˜PKš
ž˜šžœžœ
žœ˜#Kšœžœ
˜
Kšœžœ#žœ˜CKš
œ˜šœžœ£5œ˜FKšžœ˜Kšžœžœ
˜Kš
œ˜—Kš
œ˜K˜—Kšžœ˜Kšžœ
˜K˜—š
‘œžœžœžœ
žœ˜IKš
ž˜šžœ˜Kšœ
žœ˜&Kš
œ˜Kš
œ!˜!Kš
œ˜K˜—Kšžœ
˜—K˜š‘œžœžœ˜AKš
ž˜Kš
œ˜Kš
œ4˜4Kš
œ%˜%Kšžœ
˜—K˜š‘œžœžœžœ˜HKš
ž˜Kšžœžœ%žœ˜Išžœžœ
žœžœ˜'Kšœžœ˜Kšœ	žœžœ
˜Kšœžœ˜
Kšœžœžœ
˜Kšœžœžœ˜*K˜%Kš
œ0˜0Kšœ £œ˜IKš
œ?˜?Kšœ+£œ˜3Kš
œ™š	žœžœ)žœžœ
ž˜FKšœžœ+˜1šžœžœ
žœ˜Kš
œ
˜
Kš
œ0˜0K˜
—šžœ
žœ
žœ˜Kšœžœ+˜7Kš
œ
˜
Kš
œ3˜3Kšœ!£œ˜1Kš
œ˜—Kšžœ
žœ
˜
Kšžœ
˜—Kšžœžœ£œ˜7Kšœ£%œ˜=Kšœ£œ˜7Kš
œ™š	žœžœ)žœžœ
ž˜FKšœ
žœžœ
˜Kšœžœ£œ˜Kšœžœ+˜2Kšœžœžœ
˜!šžœžœ
˜!Kšœžœ£œžœ˜P—šžœ)ž˜3š
œ
˜
Kš
œ4˜4Kš
œ8˜8Kšœ£œ£˜'Kš
œ˜Kšžœ
žœ6˜FKšžœ4˜8Kš
œ˜—š
œ˜Kš
œ4˜4Kšœžœ
˜K˜—š
œ˜Kš
œ4˜4Kšœžœ
˜K˜—šžœ˜Kš
œ˜Kš
œ8˜8Kšœ£œ£˜'Kš
œ˜K˜——Kšžœ7žœ
žœ9žœ
žœžœ
˜‘
šžœ
žœ˜Kšœ
žœ
˜š
œ
˜
Kšžœ£<œ£˜PKšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—K˜
—šžœ˜š
œ
˜
Kšžœ£<˜FKšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—K˜—Kš
œ˜Kšžœ
žœ$˜4Kšžœ
˜—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šžœ
˜—K˜š
‘
œžœžœžœžœ˜IKš
ž˜Kšœžœ˜ Kšœžœ˜Kšœžœ
˜šžœžœ
žœž˜Kšœžœ˜Kš
žœžœžœ
žœžœ
˜EKšžœ
˜—Kšžœžœ
žœ˜-Kš
œ˜Kšžœ
£œ£
œ˜DKšžœ
˜—K˜š‘œžœžœ˜>Kš
ž˜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š
ž˜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˜š‘œžœ˜6Kš
ž˜Kšœžœ@˜Hšžœžœ
žœ˜Kš
œ;˜;Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ$˜$Kš
œ˜Kš
œ%˜%Kš
œ'˜'Kš
œ˜Kš
œ
˜
—Kšžœ
˜—K˜Kš
œ3™3K™Kš
œ(™(K˜Kš
œ>˜>Kš
œI˜IKš
œO˜OKš
œ6˜6Kšžœ
˜K˜K˜K˜—…—Dτ]x