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

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

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

fileName: Rope.ROPE,
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

mainName: Rope.ROPE _ NIL,

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

hasDirGen: BOOL _ FALSE,

design: CD.Design,
properties: CD.PropRef
];
ObjectExpressionProc: TYPE = CDMakeProc.ObjectExpressionProc;

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

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

CallObjectExpressionProc: 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 ObjectExpressionProc => 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];
};

MakePreamble: 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 [design: CD.Design] RETURNS [env: Environment] = {
env _ NEW[EnvironmentRep_[properties: CD.InitPropRef[]]];
env.fileName _ Rope.Cat[CDEnvironment.GetWorkingDirectory[design], "CDMakeProc-Temp.mesa"];
env.invocationKey _ NEW[INT];
env.rootNode _ TiogaFileOps.CreateRoot[];
env.mustDo _ RefTab.Create[];
env.done _ RefTab.Create[];
env.commentNode _ TiogaFileOps.InsertNode[env.rootNode, TRUE];
TiogaFileOps.SetContents[env.commentNode, Rope.Cat["--", env.fileName]];
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"];
PlaceDeclarationM1[env, IO.PutFR["tech: CD.Technology _ CD.FetchTechnology[$%g];", IO.atom[design.technology.key]]];
env.procNode _ TiogaFileOps.InsertNode[env.declNode];
TiogaFileOps.SetContents[env.procNode, ""];
env.postDeclNode _ TiogaFileOps.InsertNode[env.procNode];
TiogaFileOps.SetContents[env.postDeclNode, "context: CDGenerate.Context _ CDGenerate.AssertContext[""USER""];"];
env.firstModStatementNode _ env.modStatementNode _ TiogaFileOps.InsertNode[env.postDeclNode];
env.nameToThing _ SymTab.Create[];
env.directory _ SymTab.Create[];
env.imports _ SymTab.Create[];
env.localThingToName _ RefTab.Create[];
env.globalThingToName _ RefTab.Create[];
env.design _ design;
};
FinishUp: PROC [env: Environment] = {
node: TiogaFileOps.Ref;
subNode: TiogaFileOps.Ref;
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["[] _ context.Register[""%g"", %g];", IO.rope[env.mainName], IO.rope[env.mainName]];
TiogaFileOps.SetContents[env.firstModStatementNode, r]; 

PlaceStatementM[env, "END."];
TiogaFileOps.Store[env.rootNode, env.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.localThingToName _ NIL;
env.globalThingToName _ NIL;
TerminalIO.PutRope[env.fileName];
TerminalIO.PutRope[" created\n"];
[] _ ViewerTools.MakeNewTextViewer[info: [
file: env.fileName, 
label: env.fileName, 
name: env.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]
};

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

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

PlaceStatementM: 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;
PlaceDeclarationM2[env, "directory: CDGenerate.Context _ CDGenerate.AssertContext[""DIRECTORY""];"];
}
};

Identifier: PUBLIC 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";
IF SymTab.Fetch[reservedWords, id].found THEN {id _ Rope.Concat[id, "X"]}
};

ForceGlobalIdent: PUBLIC PROC[env: Environment, proposed: Rope.ROPE, whatFor: REF_NIL] RETURNS [ident: Rope.ROPE] = {
ident _ ForeceNewIdent[env, proposed, whatFor, TRUE];
};

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

EnsureGlobalObjectIdent: PROC [env: Environment, ob: CD.Object] RETURNS [r: Rope.ROPE] = {
r _ GetGlobalIdent[env, ob];
IF Rope.IsEmpty[r] THEN { 
name: Rope.ROPE _ CDDirectory.Name[ob, env.design];
IF Rope.IsEmpty[name] THEN name _ "CreateSubObject";
r _ ForceGlobalIdent[env, name, ob];
}
};

ForeceNewIdent: PROC [env: Environment, proposed: Rope.ROPE_NIL, whatFor: REF_NIL, global: BOOL_FALSE] RETURNS [ident: Rope.ROPE] = {
refTab: RefTab.Ref _ IF global THEN env.globalThingToName ELSE env.localThingToName;
proposed _ Identifier[proposed];
ident _ proposed;
DO
IF SymTab.Insert[env.nameToThing, ident, whatFor] THEN {
IF whatFor#NIL THEN [] _ RefTab.Store[refTab, whatFor, ident];
RETURN;
};
env.modifier _ env.modifier+1;
ident _ IO.PutFR["%gx%g", IO.rope[proposed], IO.int[env.modifier]]
ENDLOOP
};

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

Capital: PUBLIC PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = {
IF ~Rope.IsEmpty[r] AND Rope.Fetch[r, 0] IN ['a..'z] THEN
RETURN [ Rope.Replace[base: r, start: 0, len: 1,
with: Rope.FromChar[Ascii.Upper[Rope.Fetch[r, 0]]]
]];
RETURN [r];
};

Small: PUBLIC PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = {
IF ~Rope.IsEmpty[r] AND Rope.Fetch[r, 0] IN ['A..'Z] THEN
RETURN [ Rope.Replace[base: r, start: 0, len: 1,
with: Rope.FromChar[Ascii.Lower[Rope.Fetch[r, 0]]]
]];
RETURN [r];
};

IdentForLocalObject: PROC [env: Environment, ob: CD.Object] RETURNS [name: Rope.ROPE] = {
name _ GetIdent[env, ob, FALSE];
IF name=NIL THEN {
name _ CD.Describe[ob, NIL, env.design, 0];
IF Rope.IsEmpty[name] THEN {
name _ Atom.GetPName[ob.class.objectType]
};
name _ ForeceNewIdent[env, Small[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] 
]]
};

MakeLayer: PUBLIC PROC [env: Environment, l: CD.Layer] RETURNS [r: Rope.ROPE] = {
IF env.declaredLayers[l]=NIL THEN {
r: Rope.ROPE;
name: Rope.ROPE _ ForeceNewIdent[env, Small[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]]
];
PlaceDeclarationM1[env, r];
};
RETURN [env.declaredLayers[l]]
};

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

OrientationToRope: PUBLIC PROC [o: CD.Orientation] RETURNS [r: Rope.ROPE] = {
RETURN [SELECT o FROM
original => "original",
mirrorX => "mirrorX",
rotate90 => "rotate90",
rotate90X => "rotate90X",
rotate180 => "rotate180",
rotate180X => "rotate180X",
rotate270 => "rotate270",
rotate270X => "rotate270X"
ENDCASE => "bad"]
};

TransformationToRope: PUBLIC PROC [trans: CD.Transformation] RETURNS [r: Rope.ROPE] = {
r _ IO.PutFR["[[x: %g, y: %g]",
IO.int[trans.off.x], 
IO.int[trans.off.y] 
];
IF trans.orient#original THEN r _ Rope.Cat[r, ", ", OrientationToRope[trans.orient]]; 
r _ Rope.Concat[r, "]"];
};

NextObject: PROC [env: Environment] RETURNS [ob: CD.Object_NIL] = {
EachOb: RefTab.EachPairAction = {
ob1: CD.Object _ NARROW[key];
IF RefTab.Fetch[env.done, ob1].found THEN RETURN [FALSE];
ob _ ob1; quit _ TRUE
};
[] _ RefTab.Pairs[env.mustDo, EachOb]
};

ProgramText: PROC [ob: CD.Object, design: CD.Design, env: Environment] = {
ob1: CD.Object;
env.mainName _ ForceGlobalIdent[env, CDDirectory.Name[ob, env.design], ob];
OneObject[ob, design, env];
WHILE (ob1_NextObject[env]) #NIL DO
env.localThingToName _ RefTab.Create[];
OneObject[ob1, design, env];
ENDLOOP
};

OneObject: PROC [ob: CD.Object, design: CD.Design, env: Environment] = {
[] _ RefTab.Insert[env.done, ob, ob];
IF ~CDCells.IsCell[ob] THEN ob _ CDDirectory.Expand1[ob, design, NIL].new;
IF ob#NIL AND CDCells.IsCell[ob] THEN {
is: CD.Position _ CD.InterestSize[ob];
pq: PriorityQueue.Ref _ PriorityQueue.Create[SortPred, IF is.x<is.y THEN $y ELSE $x];
ir: CD.Rect;
hasInst: BOOL _ FALSE;
num: INT _ 0;
r: Rope.ROPE _ NIL;
cptr: CD.CellSpecific = NARROW[ob.specific];
childs: RefTab.Ref _ RefTab.Create[];
node: TiogaFileOps.Ref _ MakeProcedureNode[env];
EnQueueInst: CDCells.InstEnumerator = {
x: REF _ RefTab.Fetch[childs, inst.ob].val;
PriorityQueue.Insert[pq, inst];
IF x=NIL THEN {
num  _ num+1;
[] _ RefTab.Store[childs, inst.ob, $occurs]
}
ELSE IF x=$occurs THEN {
r: Rope.ROPE _ IdentForLocalObject[env, inst.ob];
num  _ num-1;
[] _ RefTab.Store[childs, inst.ob, $needsName];
PlaceStatement[env, Rope.Cat[r, ": CD.Object;"]];
} 
ELSE NULL;
};
TiogaFileOps.SetContents[node, Rope.Cat[EnsureGlobalObjectIdent[env, ob], ": CDGenerate.GeneratorProc ="]];
env.procDecNode _ TiogaFileOps.InsertAsLastChild[env.procNode];
TiogaFileOps.SetContents[env.procDecNode, "BEGIN"];
[] _ CDCells.EnumerateInstances[ob, EnQueueInst];
IF num#0 THEN PlaceStatement[env, "child: CD.Object;"];
PlaceStatement[env, "IF design.technology#tech THEN ERROR;"];
PlaceStatement[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";
trans: CD.Transformation _ inst.trans;
SELECT RefTab.Fetch[childs, inst.ob].val FROM
$needsName => {
childName _ IdentForLocalObject[env, inst.ob];
[r, needInst] _ MakeACallExpression[env, inst.ob];
r _ Rope.Cat[childName, " _ ", r, ";"];
PlaceStatement[env, r];
IF needInst THEN [] _ RefTab.Store[childs, inst.ob, $hasValueAndNeedsInst]
ELSE [] _ RefTab.Store[childs, inst.ob, $hasValue]
};
$hasValue => {
childName _ IdentForLocalObject[env, inst.ob];
needInst _ FALSE;
};
$hasValueAndNeedsInst => {
childName _ IdentForLocalObject[env, inst.ob];
needInst _ TRUE;
};
ENDCASE => {
childName _ "child";
[r, needInst] _ MakeACallExpression[env, inst.ob];
r _ Rope.Cat[childName, " _ ", r, ";"];
PlaceStatement[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, trans: %g, mode: dontResize].newInst;",
IO.rope[childName], 
IO.rope[TransformationToRope[trans]] 
]];
}
ELSE {
r _ Rope.Cat[
IO.PutFR["[] _ CDCells.IncludeOb[cell: ob, ob: %g, trans: %g, mode: dontResize];",
IO.rope[childName], 
IO.rope[TransformationToRope[trans]] 
]];
};
PlaceStatement[env, r];
IF needInst THEN MakeInstanceStuff[env, inst];
};

EachInst[inst];
ENDLOOP; 


ir _ CD.InterestRect[ob];
r _ Rope.Cat["CDCells.SetInterestRect[NIL, ob, ", RectToRope[ir], "];"];
PlaceStatement[env, r];
PlaceStatement[env, "END;"];
PlaceStatement[env, ""];
IF hasInst THEN {
env.procDecNode _ TiogaFileOps.InsertNode[env.procDecNode];
TiogaFileOps.SetContents[env.procDecNode, "inst: CD.Instance;"];
};
childs _ NIL;
}
ELSE {
TerminalIO.PutRope["**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]];
MakePreamble[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 _ CDOps.ToRope[CDProperties.GetInstanceProp[inst, key]];
IF ~Rope.IsEmpty[val] THEN {
r: Rope.ROPE _ Rope.Cat[
"CDProperties.PutInstanceProp[inst, ", 
AtomToRope[env, key], 
", ", 
RopeToRope[val], 
"];"
];
MakePreamble[env, "CDProperties"];
PlaceStatement[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], "];"];
PlaceStatement[env, r];
};
l _ CDSymbolicObjects.GetLayer[inst];
IF l#CD.undefLayer THEN {
r _ Rope.Cat["CDSymbolicObjects.SetLayer[inst, ", MakeLayer[env, l], "];"];
PlaceStatement[env, r];
};
owner  _ CDSymbolicObjects.GetOwner[inst];
IF owner#NIL THEN {
r _ Rope.Cat["CDSymbolicObjects.SetOwner[inst, ", AtomToRope[env, owner], "];"];
PlaceStatement[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 _ CallObjectExpressionProc[env, ob];
IF Rope.IsEmpty[r] THEN {
IF ob.class.composed THEN {
IF CDDirectory.IsIncluded[env.design, ob] THEN {
MakeDirGenerator[env];
r _ Rope.Cat["CDGenerate.FetchNCall[directory, design, ", RopeToRope[CDDirectory.Name[ob, env.design]], "]"];
}
ELSE {
r _ EnsureGlobalObjectIdent[env, ob];
[] _ RefTab.Insert[env.mustDo, ob, r];
r _ Rope.Cat[r, "[design, NIL, context, NIL]"];
}
}
ELSE IF CDAtomicObjects.IsAtomicOb[ob] THEN {
MakePreamble[env, "CDAtomicObjects"];
r _ "CDAtomicObjects.CreateAtomicOb[classKey: ";
r _ Rope.Cat[r, "$", CDOps.ToRope[ob.class.objectType], ", size: "];
r _ Rope.Cat[r, PosToRope[CD.InterestSize[ob]], ", "];
r _ Rope.Cat[r, "tech: tech, layer: ", MakeLayer[env, ob.layer], "]"];
}
ELSE IF CDSymbolicObjects.IsPin[ob] THEN {
MakePreamble[env, "CDSymbolicObjects"];
r _ IO.PutFR["CDSymbolicObjects.CreatePin[%g]", IO.rope[PosToRope[CD.InterestSize[ob]]]];
mustHandleInstance _ TRUE;
}
ELSE IF CDSymbolicObjects.IsSegment[ob] THEN {
MakePreamble[env, "CDSymbolicObjects"];
r _ IO.PutFR["CDSymbolicObjects.CreateSegment[length: %g, dummyWidth: %g]", IO.int[CD.InterestSize[ob].y], IO.int[CD.InterestSize[ob].x]];
mustHandleInstance _ TRUE;
}
ELSE IF CDSymbolicObjects.IsMark[ob] THEN {
MakePreamble[env, "CDSymbolicObjects"];
r _ IO.PutFR["CDSymbolicObjects.CreateMark[dummySize: %g]", IO.int[CD.InterestSize[ob].y]];
mustHandleInstance _ TRUE;
}
ELSE IF ob.class.wireTyped THEN {
MakePreamble[env, "CDRects"];
r _ "CDRects.CreateRect[size: ";
r _ Rope.Cat[r, PosToRope[CD.InterestSize[ob]]];
r _ Rope.Cat[r, ", l: ", MakeLayer[env, ob.layer], "]"];
}
ELSE {
r _ "--Unknown[]--";
MakePreamble[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 = CDOps.TheInstance[comm.design, "make program text\n"];
IF inst#NIL THEN {
env: Environment _ NewEnvironment[comm.design]; 
Reserve[env, "design"];
Reserve[env, "key"];
Reserve[env, "context"];
Reserve[env, "directory"];
Reserve[env, "imports"];
Reserve[env, "data"];
Reserve[env, "tech"];
Reserve[env, "child"];
Reserve[env, "ob"];
Reserve[env, "inst"];
MakePreamble[env, "CDCells"];
MakePreamble[env, "CDGenerate"];
MakePreamble[env, "CD"];
ProgramText[inst.ob, comm.design, env];
FinishUp[env];
}
};

reservedWords: SymTab.Ref _ SymTab.Create[];

InitReservedWords: PROC [] = {
[] _ SymTab.Insert[reservedWords, "ALL", $x];
[] _ SymTab.Insert[reservedWords, "ANY", $x];
[] _ SymTab.Insert[reservedWords, "ARRAY", $x];
[] _ SymTab.Insert[reservedWords, "ATOM", $x];
[] _ SymTab.Insert[reservedWords, "BEGIN", $x];
[] _ SymTab.Insert[reservedWords, "BOOL", $x];
[] _ SymTab.Insert[reservedWords, "BOOLEAN", $x];
[] _ SymTab.Insert[reservedWords, "CARD", $x];
[] _ SymTab.Insert[reservedWords, "CARD16", $x];
[] _ SymTab.Insert[reservedWords, "CARD32", $x];
[] _ SymTab.Insert[reservedWords, "CARDINAL", $x];
[] _ SymTab.Insert[reservedWords, "CEDAR", $x];
[] _ SymTab.Insert[reservedWords, "CONTINUE", $x];
[] _ SymTab.Insert[reservedWords, "DIRECTORY", $x];
[] _ SymTab.Insert[reservedWords, "DO", $x];
[] _ SymTab.Insert[reservedWords, "ELSE", $x];
[] _ SymTab.Insert[reservedWords, "END", $x];
[] _ SymTab.Insert[reservedWords, "ENDCASE", $x];
[] _ SymTab.Insert[reservedWords, "ENDLOOP", $x];
[] _ SymTab.Insert[reservedWords, "ERROR", $x];
[] _ SymTab.Insert[reservedWords, "EXIT", $x];
[] _ SymTab.Insert[reservedWords, "EXITS", $x];
[] _ SymTab.Insert[reservedWords, "EXPORTS", $x];
[] _ SymTab.Insert[reservedWords, "FALSE", $x];
[] _ SymTab.Insert[reservedWords, "FROM", $x];
[] _ SymTab.Insert[reservedWords, "GOTO", $x];
[] _ SymTab.Insert[reservedWords, "IMPORTS", $x];
[] _ SymTab.Insert[reservedWords, "INT", $x];
[] _ SymTab.Insert[reservedWords, "INTEGER", $x];
[] _ SymTab.Insert[reservedWords, "IF", $x];
[] _ SymTab.Insert[reservedWords, "LIST", $x];
[] _ SymTab.Insert[reservedWords, "LONG", $x];
[] _ SymTab.Insert[reservedWords, "LOOPHOLE", $x];
[] _ SymTab.Insert[reservedWords, "OF", $x];
[] _ SymTab.Insert[reservedWords, "NARROW", $x];
[] _ SymTab.Insert[reservedWords, "NEW", $x];
[] _ SymTab.Insert[reservedWords, "NIL", $x];
[] _ SymTab.Insert[reservedWords, "NULL", $x];
[] _ SymTab.Insert[reservedWords, "POINTER", $x];
[] _ SymTab.Insert[reservedWords, "PRIVATE", $x];
[] _ SymTab.Insert[reservedWords, "PROGRAM", $x];
[] _ SymTab.Insert[reservedWords, "PROC", $x];
[] _ SymTab.Insert[reservedWords, "PROCEDURE", $x];
[] _ SymTab.Insert[reservedWords, "PUBLIC", $x];
[] _ SymTab.Insert[reservedWords, "REAL", $x];
[] _ SymTab.Insert[reservedWords, "RECORD", $x];
[] _ SymTab.Insert[reservedWords, "REF", $x];
[] _ SymTab.Insert[reservedWords, "REJECT", $x];
[] _ SymTab.Insert[reservedWords, "RETURN", $x];
[] _ SymTab.Insert[reservedWords, "RETURNS", $x];
[] _ SymTab.Insert[reservedWords, "SELECT", $x];
[] _ SymTab.Insert[reservedWords, "SIGNAL", $x];
[] _ SymTab.Insert[reservedWords, "THEN", $x];
[] _ SymTab.Insert[reservedWords, "TRUE", $x];
[] _ SymTab.Insert[reservedWords, "TRUSTED", $x];
[] _ SymTab.Insert[reservedWords, "TO", $x];
[] _ SymTab.Insert[reservedWords, "TYPE", $x];
[] _ SymTab.Insert[reservedWords, "WITH", $x];
};
InitReservedWords[];
[] _ CDProperties.RegisterProperty[$MakeCallExpression, $chj];
CDSequencer.ImplementCommand[$MakeProgram, MakeProgramCommand,, doQueue];
TerminalIO.PutRope["make program command loaded\n"];
END.



*CDMakeProcCommands.mesa   (module for ChipNDale)
Copyright c 1985, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, May 9, 1985 1:58:40 pm PDT 
Last edited by: Christian Jacobi, January 5, 1987 8:12:52 pm PST



--make declarations
--make instances
--interest rect
--include in directory ???
r _ Rope.Cat["[] _ CDDirectory.Include[design: design, object: ob"];
IF cptr.name#NIL THEN 
r _ Rope.Cat[r, ", name: ", RopeToRope[cptr.name]];
r _ Rope.Cat[r, "];"];
PlaceStatement[env, r];
MakePreamble[env, "CDDirectory"];

Κ˜
codeš
œ0™0Kšœ
Οm
œ7™BKš
œ8™8K™@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š
œ˜—K˜šΟnœžœ
ž˜!Kšžœžœ„
žœV˜ό
Kšžœ˜—Kš
ž˜K˜Kšœ
žœžœ˜'šœžœžœ˜&Kšœžœ
˜Kš
œ˜K˜K˜K˜Kšœžœ
˜KšœΟc!˜@Kšœ! !˜BKšœ 5˜QKšœ +˜GKšœ +˜JKšœ  5˜UKšœ) ˜GKšœ$ œ˜NK˜Kšœž
œ
˜K˜Kšœ
žœ˜Kš
œ˜Kš
œ˜Kš
œžœ
žœžœžœžœ
žœ˜7Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšœžœžœ
˜K˜Kšœžœ˜Kšœžœ˜Kš
œ˜—K™Kšœžœ#˜=K˜šŸœžœ
žœžœžœžœ˜NKšžœ,˜2K˜—K˜š
Ÿœžœ
žœžœžœ˜JKš
œ.˜.K˜—K˜š
Ÿœžœžœ"žœžœ˜mšžœžœ
ž˜šœžœ˜Kšœ8žœ˜V—Kšœžœ!žœ&˜PKšžœž˜—Kš
œ˜—K˜šŸœžœžœ	žœ
žœžœ˜bKšœžœB˜Hšžœžœ
ž˜Kšœžœ+˜4Kšžœžœ
˜—Kš
œ˜—K˜šŸœžœ˜2Kš
žœžœžœ
žœžœ˜LKš
œ˜—K˜šŸœžœžœ˜4Kš
œ3˜3Kš
œ˜—K˜šŸœžœ
žœ!žœ
žœ
žœ˜VKš
œ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˜šŸœžœ
žœ	žœ˜GKšœžœžœ˜9Kš
œ[˜[Kšœžœ
žœ˜Kš
œ)˜)Kš
œ˜Kš
œ˜šœ8žœ˜>Kš
œH˜HKš
œ!˜!—š
œ;˜;Kš
œD˜DKš
œ!˜!—Kš
œ=˜=Kš
œ:˜:Kš
œ0˜0KšœžœΠfs-œžœ˜tKš
œ5˜5Kš
œ+˜+Kš
œ9˜9Kšœ,£Aœ˜pKš
œ]˜]Kš
œ"˜"Kš
œ ˜ Kš
œ˜Kš
œ'˜'Kš
œ(˜(Kš
œ˜Kš
œ˜—K™šŸœžœ˜%Kš
œ˜Kš
œ˜Kšœžœžœ
˜K˜Kš
œ˜Kš
œ2˜2Kš
œ6˜6K˜Kšœ(žœ˜.Kš
œH˜HK˜Kš	œžœ£!œžœžœ˜aKš
œ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šœ£Hœ˜dKš
œ
˜
—Kš
œ˜—K˜š
Ÿ
œžœ
žœžœžœ˜BKšœžœžœ
˜š‘œ˜Kšžœžœ
˜#Kšžœ
žœžœžœ
˜2Kšžœ
˜Kšœž˜
Kš
œ˜—Kš
œ0˜0Kšžœžœ
˜"Kšžœ'žœ˜IKš
œ˜—K˜šŸœžœ
žœ"žœžœ
žœžœžœ˜uKšœ/žœ˜5Kš
œ˜—K˜šŸœžœ
žœžœžœžœ˜TKšžœžœ˜&Kš
œ˜—K˜š
Ÿœžœžœ	žœ
žœ˜ZKš
œ˜šžœžœ˜Jšœžœ$˜3Kšžœžœ	£œ˜4Kš
œ$˜$K˜
—Kš
œ˜—K˜šŸœžœ#žœ
žœžœ
žœ
žœ
žœžœžœ˜…
Kšœžœžœžœ˜TKš
œ ˜ Kš
œ˜š
ž˜šžœ0žœ˜8Kšžœ	žœ
žœ+˜>Kšžœ
˜K˜—Kš
œ˜Kš	œžœ£œžœžœ˜BKš
ž˜—Kš
œ˜—K˜šŸœžœžœ
žœžœžœ
žœ˜YKšœžœžœžœ˜Qšžœ žœ
ž˜/Kšœžœžœ˜Kšžœžœ
˜—Kš
œ˜—K˜šŸœžœ
žœ
žœžœžœ˜;šžœžœžœ
ž˜9šžœ*˜0Kš
œ2˜2K˜——Kšžœ˜K˜—K˜š
Ÿœžœ
žœžœžœ˜9šžœžœžœ
ž˜9šžœ*˜0Kš
œ2˜2K˜——Kšžœ˜K˜—K˜š
Ÿœžœžœ	žœ
žœ˜YKšœžœ˜ šžœžœ
žœ˜Kšœžœžœ˜+šžœžœ˜Kš
œ)˜)K˜—Kšœ,žœ˜3K˜
—Kš
œ˜K˜—š
Ÿ	œžœžœžœ
žœ˜Dšžœžœ£˜"Kšžœ
˜Kšžœ˜Kš
œ˜—Kš
œ˜—K˜š
Ÿ
œžœžœžœ
žœ˜Bšžœžœ£"˜4Kšžœ˜Kšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—Kš
œ˜—K˜š
Ÿ	œžœžœžœ
žœ˜Qšžœžœ
žœ˜#Kšœžœ
˜
Kšœžœ+žœ˜LKš
œ˜šœžœ£5œ˜FKšžœ˜Kšžœžœ
˜Kš
œ˜—Kš
œ˜K˜—Kšžœ˜Kš
œ˜K˜—šŸœžœžœ˜CKš
œ˜Kš
œ4˜4Kš
œ%˜%Kš
œ˜—K˜š
Ÿœžœžœžœ
žœ˜Mšžœžœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœ
˜—K˜—K˜š
Ÿœžœ	žœžœ
žœ˜Wšœžœ£˜Kšžœ˜Kšžœ˜Kš
œ˜—Kšžœžœ9˜VKš
œ˜Kš
œ˜—K˜š
Ÿ
œžœžœžœžœ˜CšŸœ˜!Kšœžœ
žœ˜Kšžœ#žœ
žœžœ˜9Kšœž˜K˜—Kš
œ%˜%K˜K˜—šŸœžœžœžœ˜JKš
œ˜Kš
œK˜KKš
œ˜šžœžœ
ž˜#Kš
œ'˜'Kš
œ˜Kš
ž˜—K˜—K˜šŸ	œžœžœžœ˜HKš
œ%˜%Kšžœžœ&žœ˜Jšžœžœ
žœžœ˜'Kšœžœžœ˜&Kšœ7žœžœžœ˜UKšœžœ˜Kšœ	žœžœ
˜Kšœžœ˜
Kšœžœžœ
˜Kšœžœžœ˜,K˜%Kš
œ0˜0šŸœ˜'Kšœžœ%˜+Kš
œ˜šžœžœ
žœ˜Kš
œ
˜
Kš
œ+˜+K˜
—šžœ
žœžœ˜Kšœžœ%˜1Kš
œ
˜
Kš
œ/˜/Kšœ!£œ˜1Kš
œ˜—Kšžœ
žœ
˜
K˜—KšœK£œ˜kKš
œ?˜?Kšœ+£œ˜3Kš
œ™Kš
œ1˜1Kšžœžœ£œ˜7Kšœ£%œ˜=Kšœ£œ˜7Kš
œ™šžœžœ
žœž˜.Kšœžœžœ˜5K˜šŸœžœžœ˜&Kšœ
žœžœ
˜Kšœžœ£œ˜Kš
œ&˜&šžœ#ž˜-š
œ˜Kš
œ.˜.Kš
œ2˜2Kšœ£œ£˜'Kš
œ˜Kšžœ
žœ:˜JKšžœ.˜2Kš
œ˜—š
œ˜Kš
œ.˜.Kšœžœ
˜K˜—š
œ˜Kš
œ.˜.Kšœžœ
˜K˜—šžœ˜Kš
œ˜Kš
œ2˜2Kšœ£œ£˜'Kš
œ˜K˜——Kšžœ1žœ
žœ3žœ
žœžœ
˜…
šžœ
žœ˜Kšœ
žœ
˜š
œ
˜
Kšžœ£R˜\Kšžœ˜Kšžœ#˜%Kš
œ˜—K˜
—šžœ˜š
œ
˜
Kšžœ£H˜RKšžœ˜Kšžœ#˜%Kš
œ˜—K˜—Kš
œ˜Kšžœ
žœ˜.Kš
œ˜—K˜Kš
œ˜Kšžœ
˜	—K˜K˜š
œ™Kšœžœ˜Kšœ£!œ£œ˜HKš
œ˜—š
œ™Kšœ£3œ™Dšžœžœ
žœ
™KšœΟsœ™3—Kšœ£œ™Kš
œ™—Kšœ£œ˜Kš
œ˜šžœ	žœ˜Kš
œ;˜;Kšœ+£œ˜@K˜—Kšœ	žœ
˜
Kš
œ
˜
—šžœ˜Kš
œ4˜4Kšžœ
ž˜K˜
—Kš
œ˜—K˜š
Ÿ
œžœ
žœžœžœ˜>Kšžœ˜!Kš
œ˜—K˜š
Ÿ
œžœžœžœžœ˜KKšœžœ˜ Kšœžœ˜Kšœžœ
˜šžœžœ
žœž˜Kšœžœ˜Kš
žœžœžœ
žœžœ
˜EKšžœ
˜—Kšžœžœ
žœ˜-Kš
œ˜Kšžœ
£œ£
œ˜DKš
œ˜—K˜šŸœžœžœ˜@Kšœžœ
žœ
˜K˜šŸ
œžœžœ˜ Kšœ
žœ9˜Gšžœžœ˜šœžœ˜Kšœ
£#œ˜'Kš
œ˜Kšœ
£œ˜Kš
œ˜Kšœ
£œ
˜Kš
œ˜—Kš
œ"˜"Kš
œ˜K˜—Kš
œ˜—K˜šžœ)žœ˜1Kšœžœ˜Kšœžœ
˜Kšœžœ$˜3šžœžœ˜Kšœ£€œ€œ˜IKš
œ˜K˜—Kš
œ%˜%šžœž
œ
žœ˜Kšœ£€œ€œ˜KKš
œ˜K˜—Kš
œ*˜*šžœžœ
žœ˜Kšœ£€œ€œ˜PKš
œ˜K˜—Kš
œ
˜
—šžœ˜Kš
œ˜Kš
œ˜K˜
—Kš
œ˜—K˜šŸœ˜$Kšœžœ6žœ˜HKšœžœ6žœ˜HKšžœ	žœžœ
žœ˜0Kšžœžœ
žœ˜$Kšžœ
˜K˜—K˜šŸœžœžœ	žœ
žœžœžœžœ˜}Kš
œ&˜&šžœžœ˜šžœžœ˜šžœ(žœ˜0Kš
œ˜Kšœ£*œ/£œ
£˜mK˜
—šžœ˜Kš
œ%˜%Kš
œ&˜&Kšœ£œ£œ˜/K˜
—K˜
—šžœ
žœ žœ˜-Kš
œ%˜%Kš
œ0˜0Kš
œD˜DKšœžœ˜6Kšœ£œ£
œ˜FKš
œ
˜
—šžœ
žœžœ˜*Kš
œ'˜'Kš	œžœ£œ£
œžœ'˜YKšœž˜Kš
œ
˜
—šžœ
žœ!žœ˜.Kš
œ'˜'Kšœžœ£(œ£œ£
œžœ£žœ˜Š
Kšœžœ
˜Kš
œ
˜
—šžœ
žœžœ˜+Kš
œ'˜'Kš	œžœ£(œ£
œžœ˜[Kšœžœ
˜Kš
œ
˜
—šžœ
žœžœ˜!Kš
œ˜Kšœ£œ˜ Kšœžœ˜0Kšœ£œ£
œ˜8Kš
œ
˜
—šžœ˜Kšœ£œ˜Kš
œ˜Kšœ£œ˜-Kšœžœ˜0Kšœ£œ£
œ˜+Kš
œ˜—Kš
œ˜—Kš
œ˜—K˜šŸœžœ ˜8KšœžœB˜Jšžœžœ
žœ˜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š
œ/˜/Kš
œ.˜.Kš
œ1˜1Kš
œ.˜.Kš
œ0˜0Kš
œ0˜0Kš
œ2˜2Kš
œ/˜/Kš
œ2˜2Kš
œ3˜3Kš
œ,˜,Kš
œ.˜.Kš
œ-˜-Kš
œ1˜1Kš
œ1˜1Kš
œ/˜/Kš
œ.˜.Kš
œ/˜/Kš
œ1˜1Kš
œ/˜/Kš
œ.˜.Kš
œ.˜.Kš
œ1˜1Kš
œ-˜-Kš
œ1˜1Kš
œ,˜,Kš
œ.˜.Kš
œ.˜.Kš
œ2˜2Kš
œ,˜,Kš
œ0˜0Kš
œ-˜-Kš
œ-˜-Kš
œ.˜.Kš
œ1˜1Kš
œ1˜1Kš
œ1˜1Kš
œ.˜.Kš
œ3˜3Kš
œ0˜0Kš
œ.˜.Kš
œ0˜0Kš
œ-˜-Kš
œ0˜0Kš
œ0˜0Kš
œ1˜1Kš
œ0˜0Kš
œ0˜0Kš
œ.˜.Kš
œ.˜.Kš
œ1˜1Kš
œ,˜,Kš
œ.˜.Kš
œ.˜.K˜—K™Kš
œ˜Kš
œ>˜>Kš
œI˜IKš
œ4˜4Kšžœ
˜K˜K˜K˜—…—Z>wx