DIRECTORY
Atom,
BasicTime,
Commander,
CD,
CDCells,
CDBasics,
CDDirectory,
CDEvents,
CDInstances,
CDIO,
CDOps USING [CreateDesign],
CDOrient,
CDPrivate,
CDProperties,
CDRects,
CDValue,
CommandTool,
Convert,
FileNames,
FS,
IO,
List,
PropertyLists,
ProcessProps,
Rope,
RuntimeError  USING [UNCAUGHT],
TerminalIO,
TokenIO,
CDOldInterestRects,
UserProfile;

CDIn: CEDAR MONITOR
IMPORTS Atom, BasicTime, Commander, Convert, CD, CDBasics, CDCells, CDDirectory, CDEvents, CDInstances, CDIO, CDOps, CDOrient, CDPrivate, CDProperties, CDRects, CDValue, CommandTool, FileNames, FS, IO, List, PropertyLists, ProcessProps, Rope, RuntimeError, TerminalIO, TokenIO, UserProfile, CDOldInterestRects
EXPORTS CDIO
SHARES CD, CDDirectory, CDOldInterestRects =
BEGIN

xChipndaleFile: INT = 12121983;
xVersion: INT = 13;

versionKey: PUBLIC INT;
designInReadOperation: PUBLIC CD.Design _ NIL;
designVersionKey: Rope.ROPE _ NIL;
binfile: IO.STREAM;

IndexTable: TYPE = RECORD[table: SEQUENCE max: CARDINAL OF CD.Object];
TableTable: TYPE = RECORD[tt: SEQUENCE max: CARDINAL OF REF IndexTable];
fileName: Rope.ROPE;

indexTable: REF IndexTable _ NIL;
tableTable: REF TableTable _ NIL;

maxTableSize: INT = 32000;

GetTableEntry: PROC[i: INT] RETURNS [CD.Object] = INLINE
BEGIN
IF i<maxTableSize THEN RETURN[indexTable.table[i]]
ELSE RETURN [tableTable.tt[i/maxTableSize-1].table[i MOD maxTableSize]]
END;

SetTableEntry: PROC[i: INT, ob: CD.Object] = INLINE
BEGIN
IF i<maxTableSize THEN indexTable.table[i] _ ob
ELSE tableTable.tt[i/maxTableSize-1].table[i MOD maxTableSize] _ ob
END; 

AllocateTables: PROC[i: INT] = 
BEGIN
indexTable _ NEW[IndexTable[MIN[i, maxTableSize]]]; 
IF i>=maxTableSize THEN {
tableTable _ NEW[TableTable[i/maxTableSize]];
FOR n: INT IN [0..i/maxTableSize) DO  -- don't be picky with size if it is anyway as big
tableTable.tt[n] _ NEW[IndexTable[maxTableSize]]
ENDLOOP
};
END;

signalOnPropertyProblem: BOOL _ TRUE; --set variable with debugger

ReadProperties: PUBLIC PROC [] RETURNS [props: CD.PropList_NIL] =
BEGIN

PropertyProblem: PROC [skip: BOOL_FALSE] = {
TerminalIO.WriteRope["**** property not readable"];
IF key#NIL THEN {
TerminalIO.WriteRopes["; probably ", Atom.GetPName[key]];
};
TerminalIO.WriteLn[];
IF signalOnPropertyProblem THEN SIGNAL TokenIO.EncodingError;
IF skip THEN SkipThrough;
};

key: ATOM;
propProcs: CDProperties.PropertyProcs;
token: TokenIO.Token;
DO
token _ TokenIO.ReadToken[];
SELECT token.ref FROM
$Property => { --with a write proc
key _ TokenIO.ReadPushFlag[];
propProcs _ CDProperties.FetchProcs[key];
IF propProcs#NIL AND propProcs.internalRead#NIL THEN {
props _ PropertyLists.PutProp[propList: props, prop: key, val: propProcs.internalRead[key]];
}
ELSE IF versionKey>=12 THEN {
n: Rope.ROPE _ Atom.GetPName[key];
TerminalIO.WriteRopes["**** property ", n, " not registered\n"];
LoadEntry[n, designInReadOperation.technology];
propProcs _ CDProperties.FetchProcs[key];
IF propProcs#NIL AND propProcs.internalRead#NIL THEN {
props _ PropertyLists.PutProp[propList: props, prop: key, val: propProcs.internalRead[key]];
}
ELSE {
TerminalIO.WriteRope["failed"];
IF signalOnPropertyProblem THEN SIGNAL TokenIO.EncodingError;
};
}
ELSE {
token _ TokenIO.ReadToken[];
IF token.kind=rope OR token.kind=atom OR token.kind=int THEN
props _ PropertyLists.PutProp[propList: props, prop: key, val: token.ref]
ELSE IF token.kind=popFlag THEN {
TokenIO.ReadAgain[];
props _ PropertyLists.PutProp[propList: props, prop: key, val: key]
}
ELSE IF token.kind=pushFlag THEN {
IF token.ref=NIL OR token.ref=$properties THEN {
propertieProps: CD.PropList _ ReadProperties[];
props _ PropertyLists.PutProp[propList: props, prop: key, val: propertieProps];
}
ELSE IF token.ref=$layer THEN {
lev: CD.Layer _ ReadLayer[];
props _ PropertyLists.PutProp[propList: props, prop: key, val: CDPrivate.layers[lev]]
}
ELSE PropertyProblem[skip: FALSE];
token _ TokenIO.ReadToken[];
IF token.kind#popFlag THEN PropertyProblem[skip: TRUE]
}
ELSE PropertyProblem[]
};
token _ TokenIO.ReadToken[];
IF token.kind#popFlag THEN PropertyProblem[skip: TRUE];
};
$DefaultProperty => {
token _ TokenIO.ReadToken[];
key _ NARROW[token.ref];
propProcs _ CDProperties.FetchProcs[key];
IF propProcs#NIL AND propProcs.internalRead#NIL THEN {
TerminalIO.WriteRope["**** property registered and not readable"];
PropertyProblem[];
};
IF token.kind=rope OR token.kind=atom OR token.kind=int THEN {
token _ TokenIO.ReadToken[];
IF token.kind=rope OR token.kind=atom OR token.kind=int THEN
props _ PropertyLists.PutProp[propList: props, prop: key, val: token.ref]
ELSE PropertyProblem[];
}
ELSE IF token.kind=pushFlag THEN {
kind: ATOM _ TokenIO.ReadAtom[];
IF kind=$properties THEN {
propertieProps: CD.PropList _ ReadProperties[];
props _ PropertyLists.PutProp[propList: props, prop: key, val: propertieProps];
}
ELSE IF kind=$layer THEN {
lev: CD.Layer _ ReadLayer[];
props _ PropertyLists.PutProp[propList: props, prop: key, val: CDPrivate.layers[lev]]
}
ELSE IF kind=$ropeList THEN {
rList: LIST OF Rope.ROPE _ NIL;
token _ TokenIO.ReadToken[];
WHILE token.kind=rope DO
rList _ CONS[NARROW[token.ref, Rope.ROPE], rList];
token _ TokenIO.ReadToken[];
ENDLOOP; 
TokenIO.ReadAgain[];
props _ PropertyLists.PutProp[propList: props, prop: key, val: rList]
}
ELSE PropertyProblem[skip: FALSE];
token _ TokenIO.ReadToken[];
IF token.kind#popFlag THEN PropertyProblem[skip: TRUE]
}
ELSE PropertyProblem[]
};
ENDCASE => {
TokenIO.ReadAgain[];
RETURN [props];
};
ENDLOOP;
END;

SkipThrough: PROC [] =
BEGIN
token: TokenIO.Token;
layer: INT _ 0;
DO
token _ TokenIO.ReadToken[];
IF token.kind=pushFlag THEN layer _ layer+1
ELSE IF token.kind=popFlag THEN layer _ layer-1;
IF layer<0 THEN EXIT;
ENDLOOP;
END;

SetName: PROC[me: CD.Object, r: Rope.ROPE] ~ INLINE {
IF me.class.inDirectory THEN CDDirectory.ObToDirectoryProcs[me].setName[me, r]
};

ReadObjectDefinition: PROC [] RETURNS [obj: CD.Object_NIL] =
BEGIN
token: TokenIO.Token;
atom: ATOM = TokenIO.ReadPushFlag[];
class: CD.ObjectClass _ CD.FetchObjectClass[atom, designInReadOperation.technology];
IF class=NIL OR class.internalRead=NIL THEN {
n: Rope.ROPE _ Atom.GetPName[atom];
TerminalIO.WriteRopes["object class ", n, " not registered\n"];
LoadEntry[n, designInReadOperation.technology];
class _ CD.FetchObjectClass[atom, designInReadOperation.technology];
};
IF class=NIL OR class.internalRead=NIL THEN {
TerminalIO.WriteRopes["reading object class", Atom.GetPName[atom], " failed\n"];
SkipThrough[];
obj _ CDRects.CreateBareRect[[10, 10], CD.errorLayer]; 
RETURN
};
obj _ class.internalRead[];
IF obj=NIL OR obj.class=NIL THEN 
obj _ NEW[CD.ObjectRep _ CDRects.CreateRect[[10, 10], CD.errorLayer]^];
IF versionKey>0 THEN {
IF class.inDirectory THEN {
name: Rope.ROPE _ TokenIO.ReadRope[];
SetName[obj, name];
IF versionKey<=4 THEN [] _ TokenIO.ReadRope[]; --ignore an old versionkey feature
};
};
token _ TokenIO.ReadToken[];
IF token.kind#popFlag THEN {
TokenIO.ReadAgain[];
obj.properties _ ReadProperties[]; 
TokenIO.ReadPopFlag[];
IF versionKey<8 THEN CDOldInterestRects.AdjustInterest[obj];
IF versionKey=12 THEN { 
IF CDCells.IsCell[obj] AND CDProperties.GetObjectProp[obj, $border]#NIL THEN {
CDProperties.PutProp[obj, $border, NIL];
CDCells.SetBorder[obj, TRUE];
}
}
};
END;

ReadObject: PUBLIC PROC [] RETURNS [CD.Object] =
BEGIN
t: TokenIO.Token = TokenIO.ReadToken[];
IF t.kind=int THEN { -- instance
ins: INT _ NARROW[t.ref, REF INT]^;
RETURN [GetTableEntry[ins]]
};
TokenIO.ReadAgain;
RETURN [ReadObjectDefinition[]]
END;

setManually: INT _ 0; --used for saving old designs
specialForVersion4: BOOL _ FALSE;

ReadInstance: PUBLIC PROC [] RETURNS [CD.Instance] =
BEGIN
inst: CD.Instance;
location: CD.Position _ ReadPos[];
orientation: CD.Orientation _ CDIO.ReadOrientation[];
properties: CD.PropList _ ReadProperties[];
ob: CD.Object _ ReadObject[]; 
IF versionKey>=9 THEN  --this is the current truth and normal case
inst _ NEW[CD.InstanceRep _ [
location: location, 
orientation: orientation, 
properties: properties, 
ob: ob
]]
ELSE { 

OldNewInstIX: PROC [ob: CD.Object_NIL, location: CD.Position_[0,0], orientation: CD.Orientation_0, selected: BOOLEAN _ FALSE, properties: CD.PropList_NIL] RETURNS [CD.Instance] = 
BEGIN
off: CD.Position = CDBasics.BaseOfRect[
CDOrient.MapRect[
itemInCell: CDOldInterestRects.InsideRect[ob],
cellSize: ob.size,
cellInstOrient: orientation,
cellInstPos: [0, 0]
]];
a: CD.Instance = NEW[CD.InstanceRep _ CD.InstanceRep[
ob: ob,
location: CDBasics.SubPoints[location, off],
orientation: orientation,
selected: selected,
properties: properties
]];
RETURN [a]
END;

IF versionKey>=8 THEN  
inst _ NEW[CD.InstanceRep _ [
location: location, 
orientation: orientation, 
properties: properties, 
ob: ob
]]
ELSE IF versionKey>=5 THEN  
inst _ OldNewInstIX[ob: ob, location: location, orientation: orientation, properties: properties]
ELSE { --ancient cases
absoluteMode: BOOL _ TRUE;
IF versionKey<3 THEN absoluteMode_TRUE 
ELSE IF versionKey=4 THEN { 
IF specialForVersion4 THEN 
IF ob.class.inDirectory THEN absoluteMode_TRUE ELSE absoluteMode_FALSE
ELSE absoluteMode_FALSE
}
ELSE IF versionKey=3 THEN { 
IF ob.class.inDirectory THEN absoluteMode_TRUE ELSE absoluteMode_FALSE
};
IF setManually=1 THEN absoluteMode_TRUE
ELSE IF setManually=2 THEN absoluteMode_FALSE
ELSE IF setManually=3 THEN absoluteMode_ob.class.inDirectory;
IF absoluteMode THEN inst _ NEW[CD.InstanceRep _ [
location: location, orientation: orientation, properties: properties, ob: ob, selected: FALSE]]
ELSE inst _ OldNewInstIX[ob: ob, location: location, 
orientation: orientation, properties: properties];
};
};
RETURN [inst];
END;

ReadInstanceList: PUBLIC PROC [] RETURNS [list: CD.InstanceList_NIL] =
BEGIN
num: INT = TokenIO.ReadInt[];
THROUGH [0..num) DO
list _ CONS[ReadInstance[], list];
ENDLOOP
END;

ReadPos: PUBLIC PROC [] RETURNS [p: CD.Position] =
BEGIN
p.x _ TokenIO.ReadInt[];
p.y _ TokenIO.ReadInt[];
END;

ReadRect: PUBLIC PROC [] RETURNS [r: CD.Rect] =
BEGIN
r.x1 _ TokenIO.ReadInt[];
r.y1 _ TokenIO.ReadInt[];
r.x2 _ TokenIO.ReadInt[];
r.y2 _ TokenIO.ReadInt[];
END;

ReadPushRec: PROC [] RETURNS [pr: CD.PushRec] =
BEGIN
token: TokenIO.Token _ TokenIO.ReadToken[];
dummy: CD.Object;
IF token.ref=$Nil THEN pr.mightReplace_NIL
ELSE {
TokenIO.ReadAgain[];
pr.mightReplace _ ReadInstance[];
};
dummy _ ReadObjectDefinition[];
pr.changed _ pr.indirectlyChanged _ TRUE;
pr.specific _ NARROW[dummy.specificRef, CD.CellPtr];
IF versionKey>=11 THEN {
pr.specific.dIr _ ReadRect[];
IF pr.specific.useDIr THEN pr.specific.ir _ pr.specific.dIr;
};
pr.dummyCell _ CDInstances.NewInst[ob: dummy];
END;

ReadLayer: PUBLIC PROC [] RETURNS [CD.Layer] =
BEGIN
key: ATOM _ TokenIO.ReadAtom[];
IF CDIO.VersionKey[]<=12 THEN	-- New layer keys for CD 2.3
SELECT key FROM
$combined => key _ $undefLayer;
$highLightShade => key _ $shadeLayer;
$highLightError => key _ $errorLayer;
$backGround => key _ $backGround;
ENDCASE => NULL;
RETURN [CD.FetchLayer[designInReadOperation.technology, key]];
END;

IsOwner: PROC [ob: CD.Object, d: CD.Design] RETURNS [BOOL] = {
x: REF ~ (IF d=NIL THEN NIL ELSE d.reserved);
RETURN [ CDProperties.GetObjectProp[ob, $OwnerDesign]=x ];
};

ReadDesignData: PROC [] =
BEGIN
index, directoryCount: INT;
token: TokenIO.Token;
obj: CD.Object;
directoryCount _ TokenIO.ReadInt[];
AllocateTables[directoryCount+1]; 
FOR n: INT IN [1..directoryCount] DO
index _ TokenIO.ReadInt[];
obj _ ReadObject[];
SetTableEntry[index, obj];
IF versionKey=0 THEN {
token _ TokenIO.ReadToken[];
WHILE token.kind=rope DO
name: Rope.ROPE = NARROW[token.ref];
obx: INT = TokenIO.ReadInt[];
[] _ CDDirectory.Include[designInReadOperation, GetTableEntry[obx], name];
token _ TokenIO.ReadToken[];
ENDLOOP;
TokenIO.ReadAgain[];
}
ELSE IF obj.class.inDirectory THEN { 
IF ~IsOwner[obj, designInReadOperation] THEN {
name: Rope.ROPE = CDDirectory.Name[obj];
[] _ CDDirectory.Include[designInReadOperation, obj, name];
}
}
ENDLOOP;
designInReadOperation.properties _ NEW[CD.PropList_ReadProperties[]];
CDProperties.PutDesignProp[designInReadOperation, $FileVersion, designVersionKey];
designInReadOperation.actual _ NIL;
DO
token _ TokenIO.ReadToken[];
IF token.ref#$Push THEN {
TokenIO.ReadAgain[];
EXIT;
};
designInReadOperation.actual _ CONS[ReadPushRec[], designInReadOperation.actual];
ENDLOOP;
token _ TokenIO.ReadToken[];
IF token.ref#$EndOfDesign THEN SIGNAL TokenIO.EncodingError; 
END;

ReadDesign: PUBLIC ENTRY PROC [from: REF_NIL, check: PROC [CD.Design] RETURNS [BOOL] _ NIL, wDir: Rope.ROPE _ NIL] RETURNS [CD.Design] = 
BEGIN
ENABLE UNWIND => {
indexTable _ NIL;
tableTable _ NIL;
designInReadOperation _ NIL;
};

design: CD.Design; -- is initialized before return only

DoReadDesign: INTERNAL PROC [check: PROC [CD.Design] RETURNS [BOOL]] =
BEGIN
ENABLE {
UNWIND => designInReadOperation _ NIL;
TokenIO.EncodingError => {
TerminalIO.WriteRope["** TokenIO encoding problem\n"];
REJECT;
};
RuntimeError.UNCAUGHT => {
TerminalIO.WriteRope["** problem while reading; abort or proceed\n"];
REJECT
};
};

DoWhileAttached: INTERNAL PROC [] =
BEGIN
ENABLE UNWIND => {
designInReadOperation _ NIL;
TokenIO.ReleaseReader[];
};

TechnologyCheck: INTERNAL PROC [] =
BEGIN
ENABLE UNWIND => {designInReadOperation _ NIL};
dont: BOOL _ CDEvents.ProcessEvent[
ev: readEvent, 
design: designInReadOperation, 
x: NIL, 
listenToDont: TRUE
].dont; 
IF dont THEN {
designInReadOperation _ NIL; 
TerminalIO.WriteRope["Technology rejects read\n"];
}
END;

VersionAndSealCheck: INTERNAL PROC [] =
BEGIN
IF TokenIO.ReadInt[]#xChipndaleFile THEN {
TerminalIO.WriteRope["File is not a ChipNDale design\n"];
ERROR TokenIO.Error[other, "ChipNDale filekey"];
};
versionKey _ TokenIO.ReadInt[];
IF versionKey#xVersion THEN {
IF versionKey>xVersion THEN { -- too new
TerminalIO.WriteRope["design was written with newer chipndaleversion\n"];
TerminalIO.WriteRope["get a new ChipNDale version\n"];
ERROR TokenIO.Error[other, "ChipNDale versionkey"];
}
ELSE IF versionKey IN [10..xVersion] THEN { -- not new but dont tell it
NULL
}
ELSE IF versionKey IN [5..xVersion] THEN { -- not new but everything ok
TerminalIO.WriteRope["design was written with older chipndaleversion\n"];
}
ELSE IF versionKey=4 THEN { -- known problem versions
TerminalIO.WriteRope["********\n"];
TerminalIO.WriteRope["design was written with older chipndaleversion; filekey = 4\n"];
TerminalIO.WriteRope["Please convert also your other designs (by reading and subsequent writing)\n"];
TerminalIO.WriteRope["Check carefully the alignment of cells which have n-well\n"];

TerminalIO.WriteRope["   IF alignment is wrong THEN { try with a commandtool:\n"];
TerminalIO.WriteRope["     CD18InputToggle\n"];
TerminalIO.WriteRope["     }\n"];

TerminalIO.WriteRope["If the design looked bad, call Jacobi.pa, (I might help you, but also I'd like to know about the problem, and, whether the proposed fix helped)\n"];
TerminalIO.WriteRope["********\n"];
}
ELSE IF versionKey=3 THEN { -- known problem versions
TerminalIO.WriteRope["********\n"];
TerminalIO.WriteRope["design was written with older chipndaleversion; filekey = 3\n"];
TerminalIO.WriteRope["Please convert also your other designs (by reading and subsequent writing)\n"];
TerminalIO.WriteRope["Check carefully the alignment of cells which have n-well"];
TerminalIO.WriteRope["If the design looked bad, call Jacobi.pa, (I might help you, but also I'd like to know about the problem)\n"];
TerminalIO.WriteRope["********\n"];
}
ELSE IF versionKey IN [0..xVersion] THEN { -- not new but please convert
TerminalIO.WriteRope["********\n"];
TerminalIO.WriteRope["Design was written with older chipndaleversion\n"];
TerminalIO.WriteRope["Please convert also your other designs (by reading and subsequent writing)\n"];
TerminalIO.WriteRope["********\n"];
}
ELSE { -- too old
TerminalIO.WriteRope["design was written with older chipndaleversion\n"];
TerminalIO.WriteRope["This version is no more supported\n"];
ERROR TokenIO.Error[other, "ChipNDale versionkey"];
};
};
IF versionKey>0 THEN {
IF TokenIO.ReadInt[]#-1 THEN {
TerminalIO.WriteRope["File had not been properly closed; has bad seal\n"];
ERROR TokenIO.Error[other, "file had not been properly closed"];
};
};
END;

ReadVersionKeys: PROC [design: CD.Design] =
BEGIN
IF versionKey>=7 THEN { 
designVersionKey _ TokenIO.ReadRope[];
};
IF Rope.IsEmpty[designVersionKey] THEN 
designVersionKey _ Convert.RopeFromTime[from: BasicTime.Now[], end: seconds];
CDProperties.PutDesignProp[design, $FileVersion, designVersionKey];
END;

ReadDesignName: PROC [] RETURNS [name: Rope.ROPE] = 
BEGIN
name _ TokenIO.ReadRope[];
IF Rope.IsEmpty[name] THEN { 
name _ FileNames.GetShortName[fileName, TRUE]; 
name _ Rope.Substr[name, 0, Rope.Index[name, 0, ".dale", FALSE]]
}
END;

VersionAndSealCheck[];
technologyKey _ TokenIO.ReadAtom[];
technologyName _ TokenIO.ReadRope[];
technology _ CD.FetchTechnology[technologyKey];
IF technology=NIL THEN {
TerminalIO.WriteRopes["technology '", technologyName, "' not loaded\n"];
GOTO NotDoneAndRelease
};
designInReadOperation _ CDOps.CreateDesign[technology];
TechnologyCheck[];
IF designInReadOperation=NIL THEN GOTO NotDoneAndRelease;
designInReadOperation.name _ ReadDesignName[];
ReadVersionKeys[designInReadOperation]; --read before check, fixed again later
IF check#NIL THEN {
IF NOT check[designInReadOperation] THEN GOTO NotDoneAndRelease;
};
ReadDesignData[];
CDValue.Store[boundTo: designInReadOperation, key: $CDxFromFile, value: fileName];
CDValue.Store[boundTo: designInReadOperation, key: $CDxLastFile, value: fileName];
TokenIO.ReleaseReader[];
EXITS
NotDoneAndRelease => {
designInReadOperation _ NIL;
TokenIO.ReleaseReader[];
};
END;

technology: CD.Technology;
technologyKey: ATOM;
technologyName: Rope.ROPE;
designInReadOperation _ NIL; 
TokenIO.AttachReader[binfile ! 
TokenIO.Error => {
r: Rope.ROPE _ "bad explanation";
IF ISTYPE[explanation, Rope.ROPE] THEN r_NARROW[explanation];
TerminalIO.WriteRopes[r, "...  not attached\n"]; 
GOTO NotAttached
}
];
DoWhileAttached[];
EXITS
NotAttached => RETURN
END;

iDidTheOpen: BOOL _ FALSE;
name: Rope.ROPE;
IF wDir=NIL THEN wDir _ FileNames.CurrentWorkingDirectory[];
IF from#NIL AND ISTYPE[from, IO.STREAM] THEN {
fileName _ NIL;
binfile _ NARROW[from, IO.STREAM]
}
ELSE {
ReadName: PROC [wDir: Rope.ROPE] RETURNS [name: Rope.ROPE] = {
TerminalIO.WriteRope[Rope.Cat[" input file (", wDir, ")"]];
name _ TerminalIO.RequestRope[" >  "];
};
IF from=NIL THEN name _ ReadName[wDir]
ELSE IF ISTYPE[from, Rope.ROPE] THEN {
name _ NARROW[from, Rope.ROPE];
IF Rope.IsEmpty[name] THEN name _ ReadName[wDir];
}
ELSE {
TerminalIO.WriteRope["ReadDesign does not support type of 'from' parameter\n"];
GOTO NotOpened;
};
fileName _ MakeName[name, "dale", wDir];
binfile _ FS.StreamOpen[fileName ! FS.Error => 
IF error.group # bug THEN {
TerminalIO.WriteRope[Rope.Cat[fileName, " not opened: ", error.explanation, "\n"]];
GOTO NotOpened; 
}];
iDidTheOpen _ TRUE;
TerminalIO.WriteRope[Rope.Cat[fileName, " opened \n"]];
};

DoReadDesign[check];
design _ designInReadOperation;

designInReadOperation _ NIL;
indexTable _ NIL;
tableTable _ NIL;
IF iDidTheOpen THEN IO.Close[binfile];
[] _ CDEvents.ProcessEvent[ev: afterInputEvent, design: design, x: NIL, listenToDont: FALSE]; 
RETURN [design];
EXITS
NotOpened => {
indexTable _ NIL;
tableTable _ NIL;
designInReadOperation _ NIL;
TerminalIO.WriteRope["Read not done\n"];
RETURN [NIL];
}
END;

ReadOrientation: PUBLIC PROC [] RETURNS [orientation: CD.Orientation] = 
BEGIN
i: INT = TokenIO.ReadInt[];
IF versionKey<=3 THEN {
IF i IN [0..15] THEN orientation _ i/4*2 + i MOD 2 ELSE SIGNAL TokenIO.EncodingError; 
}
ELSE 
IF i IN [0..7] THEN orientation _ i ELSE SIGNAL TokenIO.EncodingError
END;

CheckWorkingDirectory: PROC [wDir: Rope.ROPE] RETURNS [slashWDir: Rope.ROPE] =
INLINE BEGIN
IF FileNames.IsADirectory[wDir] AND NOT FileNames.IsAPattern[wDir] THEN {
length: INT;
slashWDir _ FileNames.ConvertToSlashFormat[wDir];
length _ slashWDir.Length[];
IF slashWDir = wDir AND length > 0 AND slashWDir.Fetch[length - 1] = '/ THEN {
RETURN [slashWDir];
}
};
RETURN [NIL]
END;

SetWorkingDirectory: PUBLIC PROC [design: REF, wDir: Rope.ROPE] =
BEGIN
wDir _ CheckWorkingDirectory[wDir].slashWDir;
CDValue.Store[boundTo: design, key: $WorkingDirectory, value: wDir];
END;

wDirAtStart: Rope.ROPE = FileNames.CurrentWorkingDirectory[];

GetWorkingDirectory: PUBLIC PROC [design: REF] RETURNS [wDir: Rope.ROPE_NIL] =
BEGIN
WITH design SELECT FROM 
des: CD.Design => {
WITH CDValue.Fetch[boundTo: design, key: $WorkingDirectory, propagation: global] SELECT FROM
r: Rope.ROPE => wDir _ CheckWorkingDirectory[r];
ENDCASE => NULL;
};
tech: CD.Technology => {
techName: Rope.ROPE _ tech.name;
IF techName=NIL THEN techName _ Atom.GetPName[tech.key];
wDir _ CheckWorkingDirectory[UserProfile.Token[
key: Rope.Cat["ChipNDale.", techName, ".BaseDirectory"], 
default: NIL
]];
IF wDir=NIL THEN wDir _ GetWorkingDirectory[NIL];
IF wDir=NIL THEN wDir _ wDirAtStart;
};
ENDCASE => {
IF design=NIL THEN {
wDir _ CheckWorkingDirectory[
UserProfile.Token[key: "ChipNDale.BaseDirectory", default: NIL]];
IF wDir=NIL THEN wDir _ wDirAtStart;
};
};
END;

SetProcessWDir: PROC [wDir: Rope.ROPE] = {
[] _ List.PutAssoc[key: $WorkingDirectory, val: wDir, aList: ProcessProps.GetPropList[]];
};

UseWorkingDirectory: PUBLIC PROC [design: REF] RETURNS [wDir: Rope.ROPE] =
BEGIN
wDir _ GetWorkingDirectory[design];
IF wDir#NIL THEN SetProcessWDir[wDir]
ELSE wDir _ FileNames.CurrentWorkingDirectory[]
END;

TrailingChar: PROC [base: Rope.ROPE, char: CHAR] RETURNS [INT] = {
len: INT _ Rope.Length[base];
pos: INT _ len;
WHILE pos > 0 DO
SELECT Rope.Fetch[base, pos _ pos - 1] FROM
char => RETURN [pos];
'!, '], '>, '/ => EXIT;
ENDCASE;
ENDLOOP;
RETURN [len];
};

MakeName: PUBLIC PROC [base: Rope.ROPE, 
ext: Rope.ROPE_NIL, wDir: Rope.ROPE_NIL, modifier: Rope.ROPE_NIL] RETURNS [Rope.ROPE] =
BEGIN
bang: INT = TrailingChar[base, '!];
r: Rope.ROPE _ base.Substr[len: bang];
IF ~modifier.IsEmpty[] THEN r _ r.Concat[modifier];
IF ~ext.IsEmpty[] AND (TrailingChar[r, '.]>=r.Length[]) THEN {
dot2: INT _ TrailingChar[ext, '.];
IF dot2>=ext.Length[] THEN r _ r.Cat[".", ext]
ELSE r _ r.Concat[ext.Substr[dot2]]
};
IF wDir#NIL THEN {
IF r.IsEmpty[] OR (r.Fetch[]#'/ AND r.Fetch[]#'[) THEN
r _ FileNames.Directory[wDir].Concat[r]
};
IF bang<Rope.Length[base] THEN {
r _ r.Concat[base.Substr[bang]]
};
RETURN [r]
END;

MakeShortName: PUBLIC PROC [design: CD.Design] RETURNS [name: Rope.ROPE _ NIL] =
BEGIN

TrailingDot: PROC [base: Rope.ROPE] RETURNS [INT] = {
len: INT _ Rope.Length[base];
pos: INT _ len;
WHILE pos > 0 DO
SELECT Rope.Fetch[base, pos _ pos - 1] FROM
'. => RETURN [pos];
'!, '], '>, '/ => EXIT;
ENDCASE;
ENDLOOP;
RETURN [len];
};

SuggestedModule: PROC [base: Rope.ROPE] RETURNS [Rope.ROPE] = {
len, dot: INT;
base _ FileNames.GetShortName[base];
len _ Rope.Length[base];
dot _ TrailingDot[base];
IF len>dot AND Rope.Equal[Rope.Substr[base, dot+1], "dale", FALSE] THEN 
base _ Rope.Substr[base, 0, dot];
RETURN [base]
};

WITH CDValue.Fetch[boundTo: design, key: $CDxFromFile] SELECT FROM 
r: Rope.ROPE => name _ SuggestedModule[r];
ENDCASE => NULL;
IF name=NIL THEN name _ design.name;
IF name=NIL THEN name _ "noname"
END;

NewDesignHasBeenCreated: CDEvents.EventProc =
BEGIN
SetWorkingDirectory[design, FileNames.CurrentWorkingDirectory[]];
END;
CD18Input: Commander.CommandProc = 
BEGIN
specialForVersion4 _ ~specialForVersion4;
IF specialForVersion4 THEN
cmd.out.PutRope["Fileformat: switch to old version of cd18\n"]
ELSE
cmd.out.PutRope["Fileformat: switch to last version of cd18\n"];
END;


GetEntry: PROC [fileName: Rope.ROPE, key: Rope.ROPE] RETURNS [entry: Rope.ROPE_NIL] = 
BEGIN
found: BOOL _ FALSE;

OneLine: PROC [line: Rope.ROPE, key: Rope.ROPE] = {
stream: IO.STREAM _ IO.RIS[line];
keyFound: Rope.ROPE _ IO.GetID[stream];
IF Rope.Equal[keyFound, key] THEN {
found _ TRUE;
[] _ IO.SkipWhitespace[stream];
entry _ IO.GetLineRope[stream];
}
};

file: IO.STREAM _ FS.StreamOpen[fileName ! FS.Error => GOTO thatsIt];
WHILE ~found DO
line: Rope.ROPE _ IO.GetLineRope[file ! IO.EndOfStream => GOTO thatsIt];
IF ~Rope.IsEmpty[line] THEN
OneLine[line, key ! 
IO.EndOfStream => GOTO thatsIt;
IO.Error => {
TerminalIO.WriteF["**error reading entry file: %g line: %g\n", [rope[fileName]], [rope[line]]];
CONTINUE
};
];
ENDLOOP;
EXITS thatsIt => NULL;
END;

LoadEntry: PROC [key: Rope.ROPE, technology: CD.Technology_NIL, modifier: Rope.ROPE_NIL]  =
BEGIN
wDir, entry, oldWDir, out: Rope.ROPE;

Fetch: PROC [mod: Rope.ROPE] = {
IF modifier#NIL THEN mod _ Rope.Cat[mod, "-", modifier];
mod _ CDIO.MakeName["ChipNDale-", "CDLoadList", wDir, mod];
entry _ GetEntry[mod, key];
};

searchPath: LIST OF Rope.ROPE _ LIST[CDIO.GetWorkingDirectory[NIL], "///Commands/"];
IF technology#NIL THEN {
wDir _ CDIO.GetWorkingDirectory[technology];
searchPath _ CONS[wDir, searchPath];
Fetch[technology.name];
};
IF entry=NIL THEN {
wDir _ CDIO.GetWorkingDirectory[NIL];
Fetch["CD"];
}; 
IF entry=NIL THEN TerminalIO.WriteRopes["command line for ", key, " not found\n"]
ELSE {
cmd: Commander.Handle _ NEW[Commander.CommandObject _ [
out:  TerminalIO.TOS[],
err:  TerminalIO.TOS[],
in:  IO.noInputStream,
propertyList: List.PutAssoc[key: $SearchRules, val: searchPath, aList: NIL]
]];
oldWDir _ FileNames.CurrentWorkingDirectory[];
SetProcessWDir[wDir];
TerminalIO.WriteRopes["tries to execute: ", entry, "\n"];
out _ CommandTool.DoCommandRope[commandLine: entry, parent: cmd].out;
TerminalIO.WriteRopes["\n{", out, "}\n"];
SetProcessWDir[oldWDir];
};
END;

readEvent: CDEvents.EventRegistration = CDEvents.RegisterEventType[$ReadTechnologyPrivate];
afterInputEvent: CDEvents.EventRegistration = CDEvents.RegisterEventType[$AfterInput];
CDValue.RegisterKey[key: $WorkingDirectory];
CDEvents.RegisterEventProc[$CreateNewDesign, NewDesignHasBeenCreated];
Commander.Register[  
key: "///Commands/CD18InputToggle", 
proc: CD18Input,
doc: "toggle input mode of cd18"
];
CDProperties.PutAtomProp[$CDIOPrivate, $CDIOPrivate, NEW[PROC[Rope.ROPE, CD.Technology, Rope.ROPE]_LoadEntry]];
END.

CDIn.mesa
Copyright c 1983, 1986 by Xerox Corporation.  All rights reserved.
Last Edited by: Kimr, November 28, 1983 10:22 am
Last Edited by: Jacobi, February 8, 1984 9:41 am
Last Edited by: Jacobi, March 29, 1986 5:53:02 pm PST 
gbb April 4, 1986 3:21:48 pm PST


--RELEASE: search for the string "RELEASE"
-- global vars
--border was'nt a very public feature in 12; might be removed
The layer keys have changed from ChipNDale 2.2 to ChipNDale 2.3.  The following is a nasty hack to fix it.  Note that this is only a translation of the leyer keys.  It does not contemplate the conversion from whatever to the new comment layer
--hack to simplify some read procedures... 
--this overwrites an previous $FileVersion property read in the normal (wrong) way
--from is either a IO.STREAM, a Rope.ROPE, or NIL
--check: (called if non NIL), is called after technology and design-name is initialized
--		read proceeds only if check returns TRUE 
--returns NIL if design not read in successfully
--viewer is not opened
-- all internal routines use designInReadOperation in place of design
-- result design returned in designInReadOperation
-- handles all the TokenIO business
--and always Release
--Side-effect: if bad, designInReadOperation is set to NIL
--ChipNDale check
--version check
--seal check
-- DoWhileAttached
-- DoReadDesign
-- begin ReadDesign

-- open file; assign fileName and binfile
-- do the actual work
-- finalize

-- Working directories ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--if wDir is a directory, assign it to slashWDir
--else slashWDir _ nil
--set's it for the running process
--return's it
--position of last "char", only before '!, '], '>, '/ considered 
--remove version number
--include modifier
--include extension
--include working directory
--put version number back
--position of last dot
--given a filename, suggests a modulename
--MakeShortName
-- PROC [event: REF, design: CD.Design, x: REF] -- 
--repaint captions and sometimes the contents

-- Loader ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


-- Module Initialization ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--fix a problem in CD18
--hack hack, so I don't have to make an Interface change
Version history

versionKey 0
versionKey 1:  
objects with children carry names
versionKey 2: 
versionKey 3:  June 15, 1984 3:46:13 pm PDT;  
instances position is its innerrect; this allows to shrink or grow the nwell from cmos
versionKey 4:  October 20, 1984 9:36:34 am PDT; 
orientation changed
probably while lifetime of 4: 
properties which are propertylists are automatically included
versionKey 5:  December 14, 1984 10:07:59 am PST; 
insiderect for cells no more done with properties; key is removed
versionKey 6:  February 1, 1985 4:43:29 pm PST; 
properties which are layers are automatically included
versionKey 7:  March 26, 1985 12:33:22 pm PST; 
file versionkey property included
versionKey 8:  April 15, 1985 3:26:35 pm PST; 
cd-coords base to file again...
cells get origin and interestrect
imports get interestrect
versionKey 9:  May 29, 1985 7:51:45 pm PDT; 
CD21
versionKey 10:  May 29, 1985 7:51:45 pm PDT; 
CD22
Atomicobject have the interest rect on the file
versionKey 11:  May 29, 1985 7:51:45 pm PDT; 
(CD22)
pushed records get the default interest rect
versionKey 12:  January 28, 1986 2:23:27 pm PST; 
(CD22)
default properties get $DefaultProperty key
versionKey 13:  March 11, 1986 4:17:16 pm PST; 
(CD23)
cells may have drawBorder field
gbb April 4, 1986 3:19:31 pm PST
The atoms for the keys of the technology independent layers have changed.
changes to: ReadLayer: if versionKey[]<=12 translate atoms.

Κ%K–

"cedar" style˜
code™	Kšœ
Οm
œ7™BK™0K™0K™6K™ 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š
œ˜Kšœžœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šΠblœžœ
ž˜Kš
žœ&žœ9žœVžœžœm˜΅Kšžœ
ž˜Kšžœ&˜,—Kš
ž˜K™Kš
œ*™*K˜Kšœžœ˜Kšœ
žœ˜K˜K™Kšœžœ
žœ
˜Kšœžœ
žœ
žœ
˜.Kšœžœžœ
˜"Kšœ	žœ
žœ
˜K˜Kš
œžœžœžœžœ
žœ
žœ	˜FKš
œžœžœžœžœ
žœ
žœ
˜HKšœžœ
˜K˜Kšœžœžœ
˜!Kšœžœžœ
˜!K˜Kšœžœ	˜K˜šΟn
œžœžœžœžœž˜8Kš
ž˜Kšžœžœ
žœ˜2Kšžœ
žœ*žœ˜GKšžœ
˜—K˜š	 
œžœžœžœž˜3Kš
ž˜Kšžœžœ˜/Kšžœ)žœ˜CKšžœ˜—K˜š œžœžœ˜Kš
ž˜Kšœ
žœžœ˜4šžœžœ˜Kšœ
žœ˜-š	žœžœ
žœžœΟc2˜XKšœžœ˜0Kš
ž˜—Kš
œ˜—Kšžœ
˜K˜—Kšœžœžœ‘˜BK˜š œžœ
žœžœ	žœ
žœ˜AKš
ž˜K˜š œžœžœ
žœ˜,Kš
œ3˜3šžœžœ
žœ˜Kš
œ9˜9K˜—Kš
œ˜Kšžœžœ
žœ˜=Kšžœžœ
˜K˜—K˜Kšœžœ
˜
K˜&Kš
œ˜š
ž˜Kš
œ˜šžœ	ž˜šœ‘˜"K˜K˜)š
žœžœ
žœžœ
žœ˜6Kš
œ\˜\K˜
—šžœ
žœžœ˜Kšœžœ˜"Kš
œ@˜@Kš
œ/˜/K˜)š
žœžœ
žœžœ
žœ˜6Kš
œ\˜\K˜
—šžœ˜Kš
œ˜Kšžœžœ
žœ˜=K˜—K˜
—šžœ˜Kš
œ˜šžœžœžœž˜<Kš
œI˜I—šžœ
žœžœ˜!Kš
œ˜Kš
œC˜CK˜
—šžœ
žœžœ˜"šžœžœ
žœžœ˜0Kšœžœ˜/Kš
œO˜OK˜
—šžœ
žœžœ˜Kšœžœ˜Kš
œU˜UK˜
—Kšžœžœ˜"Kš
œ˜Kšžœžœžœ
˜6K˜
—Kšžœ˜K˜—Kš
œ˜Kšžœžœžœ˜7K˜—š
œ˜Kš
œ˜Kšœžœ˜K˜)š
žœžœ
žœžœ
žœ˜6Kš
œB˜BKš
œ˜K˜—šžœžœžœžœ˜>Kš
œ˜šžœžœžœž˜<Kš
œI˜I—Kšžœ˜Kš
œ
˜
—šžœ
žœžœ˜"Kšœžœ˜ šžœžœ˜Kšœžœ˜/Kš
œO˜OK˜
—šžœ
žœ
žœ˜Kšœžœ˜Kš
œU˜UK˜
—šžœ
žœžœ˜Kš	œžœ
žœžœžœ
˜Kš
œ˜šžœž˜Kšœžœ
žœžœ
˜2Kš
œ˜Kšžœ˜	—Kš
œ˜Kš
œE˜EK˜
—Kšžœžœ˜"Kš
œ˜Kšžœžœžœ
˜6K˜
—Kšžœ˜K˜—šžœ˜Kš
œ˜Kšžœ	˜K˜——Kšžœ
˜—Kšžœ
˜—K˜š œžœ˜Kš
ž˜K˜Kšœžœ˜š
ž˜Kš
œ˜Kšžœžœ˜+Kšžœ
žœžœ˜0Kšžœ	žœ
žœ
˜Kšžœ
˜—Kšžœ
˜—K˜š
 œžœžœžœžœ˜5Kšžœžœ2˜NK˜K˜—š
 œžœžœžœžœ˜<Kš
ž˜K˜Kšœžœ˜$Kšœžœžœ:˜Tš
žœžœ
žœžœ
žœ˜-Kšœžœ˜#Kš
œ?˜?Kš
œ/˜/Kšœžœ:˜DK˜—š
žœžœ
žœžœ
žœ˜-Kš
œP˜PKš
œ˜Kšœ'žœ˜7Kš
ž˜K˜—K˜š
žœžœ
žœžœ
žœ
˜!Kšœžœ
žœ*žœ˜G—šžœžœ˜šžœžœ˜Kšœžœ˜%Kš
œ˜Kšžœžœ‘"˜QK˜—K˜—Kš
œ˜šžœžœ˜Kš
œ˜Kš
œ#˜#Kš
œ˜Kšžœžœ(˜<K™=šžœž˜šžœžœ*žœ
žœ˜NJšœ#žœ˜(Jšœžœ˜Jš
œ
˜
—J˜
—Kš
œ˜—Kšžœ
˜—K˜š
 
œžœ
žœžœžœ
˜0Kš
ž˜K˜'šžœžœ‘˜ Kš	œžœžœžœ
žœ˜#Kšžœ˜K˜—K˜Kšžœ˜Kšžœ
˜K˜—Kšœ
žœ‘˜3Kšœžœžœ
˜!K˜š
 œžœ
žœžœžœ˜4Kš
ž˜Kšœžœ
˜Kšœ
žœ˜"Kšœ
žœžœ˜5Kšœžœ˜+Kšœžœ˜šžœžœ‘+˜Bšœžœ
žœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜——šžœ˜K˜š œžœžœžœžœžœžœžœžœ
žœžœžœ
˜³
Kš
ž˜šœžœ ˜'š
œ˜Kš
œ.˜.K˜K˜K˜K˜——š	œžœžœ
žœžœ
˜5K˜K˜,K˜K˜K˜K˜—Kšžœ˜
Kšžœ
˜K˜—šžœžœ˜šœžœ
žœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜——šžœ
žœžœ˜Kš
œa˜a—šžœ‘˜Kšœžœžœ
˜Kšžœžœžœ
˜'šžœ
žœžœ˜šžœžœ
˜Kš	žœžœžœ
žœž˜F—Kšžœž˜K˜
—šžœ
žœžœ˜Kš	žœžœžœ
žœž˜FK˜—Kšžœžœž˜'Kšžœ
žœžœž˜-Kšžœ
žœžœ#˜=šžœžœžœ
žœ˜2KšœXžœ˜_—šžœ1˜5Kš
œ2˜2—K˜—K˜—Kšžœ˜Kšžœ
˜K˜—š œžœ
žœžœžœžœ˜FKš
ž˜Kšœžœ˜šžœ
ž˜Kšœžœ˜"Kš
ž˜—Kšžœ
˜—K˜š
 œžœ
žœžœžœ˜2Kš
ž˜K˜K˜Kšžœ
˜—K˜š
 œžœ
žœžœžœ˜/Kš
ž˜K˜K˜K˜K˜Kšžœ
˜—K˜š œžœžœžœ˜/Kš
ž˜Kš
œ+˜+Kšœžœ˜Kšžœžœž˜*šžœ˜Kš
œ˜Kš
œ!˜!K˜—Kš
œ˜Kšœ$žœ
˜)Kšœžœžœ
˜4šžœžœ˜Kš
œ˜Kšžœžœ"˜<Kš
œ˜—Kš
œ.˜.Kšžœ
˜—K˜š
 	œžœ
žœžœžœ	˜.Kš
ž˜Kšœžœ˜Kšœ­
ΟbœB™ς
šžœ
žœžœ
‘˜:šžœž˜Kš
œ˜Kš
œ%˜%Kš
œ%˜%Kš
œ!˜!Kšžœžœ
˜——Kšžœžœ4˜>Kšžœ
˜—K˜š œžœžœžœ	žœžœ˜>Kš
œžœžœžœ
žœ
žœ
žœ
˜-Kšžœ4˜:K˜—K˜š œžœ˜Kš
ž˜Kšœžœ
˜K˜Kšœžœ˜Kš
œ#˜#Kš
œ"˜"šžœžœ
žœž˜$Kš
œ˜Kš
œ˜Kš
œ˜šžœžœ˜Kš
œ˜šžœž˜Kšœžœžœ˜$Kšœžœ˜Kš
œJ˜JKš
œ˜Kšžœ
˜—Kš
œ˜K˜
—šžœ
žœžœ˜%Kš
œ+™+šžœ&žœ˜.Kšœžœ˜(Kš
œ;˜;K˜
—K˜
—Kšžœ
˜—Kšœ#žœ
žœ˜EKš
œR™RKš
œR˜RKšœžœ
˜#š
ž˜Kš
œ˜šžœžœ˜K˜Kšžœ
˜K˜—Kšœžœ.˜QKšžœ
˜—Kš
œ˜Kšžœžœ
žœ˜=Kšžœ
˜—K˜š 
œžœ
žœ
žœžœ
žœ	žœžœ	žœžœžœ
žœžœžœžœ˜‰
K™1Kš
œW™WKš
œ-™-K™0Kš
œ™Kš
ž˜šžœ
žœ˜Kšœ
žœ
˜Kšœ
žœ
˜Kšœžœ
˜Kš
œ˜—K˜Kšœžœ	‘$˜7Kš
œE™EK˜š œžœ
žœ	žœžœ	žœžœ˜FKš
œ2™2K™#š
ž˜šžœ˜Kšžœžœ
˜&š
œ˜Kš
œ6˜6Kšžœ
˜Kš
œ˜—šœ
žœ˜Kš
œE˜EKš
ž˜Kš
œ˜—K˜—K˜—š œžœ
žœ˜#Kš
œ™Kš
ž˜šžœ
žœ˜Kšœžœ
˜Kš
œ˜K˜—K˜š œžœ
žœ˜#Kš
œ:™:Kš
ž˜Kšžœ
žœžœ˜/šœžœ˜#Kš
œ˜Kš
œ˜Kšœžœ˜Kšœž˜Kš
œ˜—šžœžœ˜Kšœžœ˜Kš
œ2˜2K˜
—Kšžœ
˜—K˜š œžœ
žœ˜'Kš
ž˜Kš
œ™šžœ"žœ˜*Kš
œ9˜9Kšžœ.˜3—Kš
œ™Kš
œ˜šžœžœ˜šžœžœ‘
˜(Kš
œI˜IKš
œ6˜6Kšžœ.˜3Kš
œ
˜
—š	žœ
žœžœžœ‘˜GKš
ž˜K˜
—š	žœ
žœžœžœ‘˜GKš
œI˜IK˜
—šžœ
žœžœ‘˜5Kš
œ#˜#Kš
œV˜VKš
œe˜eKš
œS˜SK˜Kš
œR˜RKš
œ/˜/Kš
œ!˜!K˜Kš
œͺ
˜ͺ
Kš
œ#˜#K˜
—šžœ
žœžœ‘˜5Kš
œ#˜#Kš
œV˜VKš
œe˜eKš
œQ˜QKš
œ„
˜„
Kš
œ#˜#K˜
—š	žœ
žœžœžœ‘˜HKš
œ#˜#Kš
œI˜IKš
œe˜eKš
œ#˜#K˜
—šžœ‘
˜Kš
œI˜IKš
œ<˜<Kšžœ.˜3K˜—Kš
œ˜—Kš
œ™šžœžœ˜šžœžœ˜Kš
œJ˜JKšžœ;˜@Kš
œ˜—K˜—Kšžœ
˜K˜š œžœ
žœ
˜+Kš
ž˜šžœžœ˜Kš
œ&˜&K˜—šžœ žœ
˜'Kš
œM˜M—Kš
œC˜CKšžœ
˜—K˜š œžœžœ
žœ˜4Kš
ž˜Kš
œ˜šžœžœ˜Kšœ(žœ˜/Kšœ9žœ˜@K˜
—Kšžœ
˜—K˜—Kš
œ™Kš
œ˜Kš
œ#˜#Kš
œ$˜$Kšœ
žœ ˜/šžœžœ
žœ˜Kš
œH˜HKšžœ˜K˜—Kš
œ7˜7Kš
œ˜Kšžœžœ
žœ
žœ˜9Kš
œ.˜.Kšœ(‘&˜Nšžœžœ
žœ˜Kšžœ
žœžœ
žœ˜@K˜—Kš
œ˜Kš
œR˜RKš
œR˜RKš
œ˜š
ž˜š
œ˜Kšœžœ
˜Kš
œ˜K˜——Kšžœ
˜K˜—Kš
œ™Kšœžœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜š
œ˜š
œ˜Kšœžœ˜!Kš
žœ
žœžœžœžœ˜=Kš
œ1˜1Kšžœ˜Kš
œ
˜
—Kš
œ˜—Kš
œ˜š
ž˜Kšœž˜—Kšžœ
˜—K˜Kš
œ™Kšœ
žœžœ
˜Kšœžœ
˜K™Kš
œ)™)Kšžœžœ
žœ,˜<šžœžœ
žœ
žœžœ
žœžœ˜.Kšœžœ
˜Kšœ
žœžœ
žœ
˜!K˜
—šžœ˜š
 œžœ
žœžœ
žœ˜>Kš
œ;˜;Kš
œ&˜&Kš
œ˜—Kšžœžœ
žœ˜&š
žœ
žœ
žœžœžœ˜&Kšœžœžœ˜Kšžœžœ˜1K˜
—šžœ˜Kš
œO˜OKšžœ˜K˜—Kš
œ(˜(šœ
žœžœ
˜/šžœžœ˜Kš
œS˜SKšžœ˜Kš
œ˜——Kšœžœ
˜Kš
œ7˜7K˜—K˜Kš
œ™K˜Kš
œ˜K˜Kš
œ™Kšœžœ
˜Kšœ
žœ
˜Kšœ
žœ
˜Kšžœ
žœ
žœ˜&KšœCžœžœ˜^Kšžœ
˜š
ž˜š
œ˜Kšœ
žœ
˜Kšœ
žœ
˜Kšœžœ
˜Kš
œ(˜(Kšžœžœ˜
K˜
——Kšžœ
˜—K˜š
 œžœ
žœžœžœ˜HKš
ž˜Kšœžœ˜šžœžœ˜Kšžœžœ	žœžœžœ
žœ˜VK˜
—šžœ
˜Kš
žœžœžœžœ
žœ˜E—Kšžœ
˜—K™Kš
œ8™8K˜š
 œžœ
žœžœžœ˜NKš
œ0™0Kš
œ™Kšžœ
ž˜šžœžœ
žœžœ˜IKšœžœ
˜Kš
œ1˜1Kš
œ˜šžœžœžœ"žœ˜NKšžœ
˜K˜
—K˜—Kšžœžœ
˜Kšžœ
˜—K˜š
 œžœ
žœ
žœ
žœ˜AKš
ž˜Kš
œ-˜-Kš
œD˜DKšžœ
˜K˜—Kšœžœ'˜=K˜š œžœ
žœ
žœžœ
žœ
žœ˜NKš
ž˜šžœžœ
žœ
˜šœžœ˜šžœMžœ
ž˜\Kšœžœ$˜0Kšžœžœ
˜—K˜—šœžœ˜Kšœžœ
˜ Kšžœ
žœ
žœ$˜8š
œ/˜/Kš
œ9˜9Kšœ	ž˜Kš
œ˜—Kšžœžœ
žœžœ˜1Kšžœžœ
žœ˜$Kš
œ˜—šžœ˜šžœžœ
žœ˜š
œ˜Kšœ;žœ˜A—Kšžœžœ
žœ˜$Kš
œ˜—K˜——Kšžœ
˜—K˜š œžœ
žœ˜*Kš
œY˜YK˜—K˜š œžœ
žœ
žœžœ
žœ˜JKš
œ"™"K™
Kš
ž˜Kš
œ#˜#Kšžœžœ
žœ˜%Kšžœ+˜/Kšžœ
˜K˜—š œžœ
žœžœžœžœ˜BKš
œA™AKšœžœ˜Kšœžœ˜šžœ	ž˜šžœ!ž˜+Kšœžœ˜Kšœžœ
˜Kšžœ
˜—Kšžœ
˜—Kšžœ˜
K˜K˜—š œžœ
žœ
žœ˜(Kšœ
žœ
žœ
žœ
žœžœ
žœžœžœ˜WKš
ž˜Kšœžœ˜#Kš
œ™Kšœžœ˜&Kš
œ™Kšžœžœ˜3Kš
œ™šžœžœ#žœ˜>Kšœžœ˜"Kšžœžœ˜.Kšžœ˜#K˜—Kš
œ™šžœžœ
žœ˜Kšžœ
žœžœž˜6Kš
œ'˜'K˜—Kš
œ™šžœžœ˜ Kš
œ˜K˜—Kšžœ˜
Kšžœ
˜—K˜š 
œžœ
žœ
žœ	žœ
žœžœ˜PKš
ž˜K˜š
 œžœ
žœžœžœ˜5Kš
œ™Kšœžœ˜Kšœžœ˜šžœ	ž˜šžœ!ž˜+Kšœžœ˜Kšœžœ
˜Kšžœ
˜—Kšžœ
˜—Kšžœ˜
K˜K˜—š
 œžœ
žœžœžœ˜?Kš
œ)™)Kšœ
žœ
˜Kš
œ$˜$Kš
œ˜Kš
œ˜šžœ	žœ.žœžœ
˜HKš
œ!˜!—Kšžœ˜
K˜—K˜Kš
œ™šžœ3žœ
žœ
˜CKšœžœ˜*Kšžœžœ
˜—Kšžœžœ
žœ˜$Kšžœžœ
žœ˜ Kšžœ
˜K˜—š’œ˜-Kš
œ3™3Kš
œ-™-Kš
ž˜Kš
œA˜AKšžœ
˜—K™š’	œ˜#Kš
ž˜Kš
œ)˜)šžœž˜Kš
œ>˜>—š
ž˜Kš
œ@˜@—Kšžœ
˜—K˜Kš‘
œ!™+K˜šΠbnœžœžœžœžœžœ˜VKš
ž˜Kšœžœž˜K˜š œžœ
žœžœ˜3Kš	œžœ
žœžœ
žœ˜!Kšœžœžœ˜'šžœžœ˜#Kšœžœ
˜
Kšœžœ˜Kšœžœ˜K˜
—Kš
œ˜—K˜Kšœžœ
žœžœžœ
žœ
˜Ešžœž˜KšœžœžœΟr
Πkr€œžœ
˜Hšžœž˜š
œ˜Kšžœžœ	˜šžœ˜
Kš
œ_˜_Kš
ž˜Kš
œ˜—Kš
œ˜——Kšžœ
˜—Kšžœžœ
˜Kšžœ
˜—J˜š 	œžœžœžœžœ
žœ˜[Jš
ž˜Kšœ žœ
˜%K˜š œžœžœ˜ Kšžœ
žœ
žœ$˜8Kšœžœ1˜;Kš
œ˜K˜—K˜Kš
œžœ
žœžœžœ
žœžœ˜Tšžœžœ˜Kšœžœ!˜,Kšœ
žœ˜$Kš
œ˜K˜—šžœžœ
žœ˜Kšœžœžœ˜%Kš
œ˜Kš
œ˜—Kšžœžœ
žœ@˜Qšžœ˜šœžœ˜7Kšœžœ˜Kšœžœ˜Kšœžœ˜KšœGžœ
˜KKš
œ˜—Kš
œ.˜.Kš
œ˜Kš
œ9˜9Kš
œE˜EKš
œ)˜)Kš
œ˜Kš
œ˜—Kšžœ
˜—K™K™Kš‘œ!™:K˜Kš
œ[˜[Kš
œV˜VKš
œ,˜,K˜Fš
œ™š
œ˜K˜$K˜K˜ Kš
œ˜——Kš
œ8™8Kš
œ5žœ
žœžœžœžœžœ˜oKšžœ
˜K˜š
’™K™Kš
œ™š
œ™Kš
œ!™!—Kš
œ™š
œ.™.Kš
œV™V—š
œ0™0Kš
œ™—š
œ™Kš
œ=™=—š
œ2™2Kš
œA™A—š
œ0™0Kš
œ6™6—š
œ/™/K™!—š
œ.™.K™K™!K™—š
œ,™,K™—š
œ-™-K™K™/—š
œ-™-K™K™,—š
œ1™1K™Kš
œ+™+—š
œ/™/K™J™——™ K™IKšœ€	œΟeœ™;—K™—…—eŽ˜ε