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

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

xChipndaleFile: INT = 12121983;
xVersion: INT = 8;

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

IndexTable: TYPE = RECORD[table: SEQUENCE max: CARDINAL OF CD.ObPtr];
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.ObPtr] = INLINE
BEGIN
RETURN[indexTable.table[i]];
END;

SetTableEntry: PROC[i: INT, ob: CD.ObPtr] = INLINE
BEGIN
indexTable.table[i] _ ob;
END; 

AllocateTables: PROC[i: INT] = 
BEGIN
indexTable _ NEW[IndexTable[MIN[i, maxTableSize]]]; 
IF i>=maxTableSize THEN {
TerminalIO.WriteRope["****design to big\n"];
ERROR
};
END;

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

ReadProperties: PUBLIC PROC [] RETURNS [props: CD.Properties_NIL] =
BEGIN
PropertyProblem: PROC [skip: BOOL_FALSE] = {
TerminalIO.WriteRope["**** property not readable"];
IF key#NIL THEN {
TerminalIO.WriteRope["; probably "];
TerminalIO.WriteRope[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[];
IF token.ref#$Property THEN {
TokenIO.ReadAgain[];
RETURN [props];
};
key _ TokenIO.ReadPushFlag[];
propProcs _ CDProperties.FetchProcs[key];
IF propProcs#NIL AND propProcs.internalRead#NIL THEN {
props _ Atom.PutPropOnList[propList: props, prop: key, val: propProcs.internalRead[key]];
}
ELSE {
token _ TokenIO.ReadToken[];
IF token.kind=rope OR token.kind=atom OR token.kind=int THEN
props _ Atom.PutPropOnList[propList: props, prop: key, val: token.ref]
ELSE IF token.kind=popFlag THEN {
TokenIO.ReadAgain[];
props _ Atom.PutPropOnList[propList: props, prop: key, val: key]
}
ELSE IF token.kind=pushFlag THEN {
IF token.ref=NIL OR token.ref=$properties THEN {
propertieProps: CD.Properties _ ReadProperties[];
props _ Atom.PutPropOnList[propList: props, prop: key, val: propertieProps];
}
ELSE IF token.ref=$layer THEN {
lev: CD.Layer _ ReadLayer[];
props _ Atom.PutPropOnList[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];
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.ObPtr, r: Rope.ROPE] ~ INLINE {
IF me.p.inDirectory THEN CDDirectory.ObToDirectoryProcs[me].setName[me, r]
};

ReadObjectDefinition: PROC [] RETURNS [obj: CD.ObPtr_NIL] =
BEGIN
token: TokenIO.Token;
atom: ATOM = TokenIO.ReadPushFlag[];
p: REF READONLY CD.ObjectProcs _ CD.FetchObjectProcs[atom, designInReadOperation.technology];
IF p=NIL OR p.internalRead=NIL THEN {
TerminalIO.WriteRope["unknown object  "];
TerminalIO.WriteRope[Atom.GetPName[atom]];
TerminalIO.WriteLn[];
SkipThrough[];
obj _ CDRects.CreateBareRect[[10, 10], CD.highLightError]; 
}
ELSE {
obj _ p.internalRead[];
IF obj=NIL OR obj.p=NIL THEN 
obj _ NEW[CD.ObjectDefinition _ CDRects.CreateRect[[10, 10], CD.highLightError]^];
IF versionKey>0 THEN {
IF p.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 CDInterestRects.AdjustInterest[obj]
}
};
END;

ReadObject: PUBLIC PROC [] RETURNS [CD.ObPtr] =
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;

ReadApplicationPtr: PUBLIC PROC [] RETURNS [CD.ApplicationPtr] =
BEGIN
ap: CD.ApplicationPtr;
location: CD.DesignPosition _ ReadPosition[];
orientation: CD.Orientation _ CDIO.ReadOrientation[];
properties: CD.Properties _ ReadProperties[];
ob: CD.ObPtr _ ReadObject[]; 
IF versionKey>=8 THEN  --this is the current truth and normal case
ap _ NEW[CD.Application _ [
location: location, 
orientation: orientation, 
properties: properties, 
ob: ob
]]
ELSE { 

NewApplicationIX: PROC [ob: CD.ObPtr_NIL, location: CD.DesignPosition_[0,0], orientation: CD.Orientation_0,
selected: BOOLEAN _ FALSE, properties: CD.Properties_NIL] RETURNS [CD.ApplicationPtr] = 
BEGIN
off: CD.DesignPosition = CDBasics.BaseOfRect[
CDOrient.MapRect[
itemInCell: ob.p.oldInsideRect[ob],
cellSize: ob.size,
cellInstOrient: orientation,
cellInstPos: [0, 0]
]];
a: CD.ApplicationPtr = NEW[CD.Application _ CD.Application[
ob: ob,
location: CDBasics.SubPoints[location, off],
orientation: orientation,
selected: selected,
properties: properties
]];
RETURN [a]
END;

IF versionKey>=5 THEN  
ap _ NewApplicationIX[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.p.inDirectory THEN absoluteMode_TRUE ELSE absoluteMode_FALSE
ELSE absoluteMode_FALSE
}
ELSE IF versionKey=3 THEN { 
IF ob.p.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.p.inDirectory;
IF absoluteMode THEN ap _ NEW[CD.Application _ [
location: location, orientation: orientation, properties: properties, ob: ob, selected: FALSE]]
ELSE ap _ NewApplicationIX[ob: ob, location: location, 
orientation: orientation, properties: properties];
};
};
RETURN [ap];
END;

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

ReadPushRec: PROC [] RETURNS [pr: CD.PushRec] =
BEGIN
token: TokenIO.Token _ TokenIO.ReadToken[];
dummy: CD.ObPtr;
IF token.ref=$Nil THEN pr.mightReplace_NIL
ELSE {
TokenIO.ReadAgain[];
pr.mightReplace _ ReadApplicationPtr[];
};
dummy _ ReadObjectDefinition[];
pr.changed _ pr.indirectlyChanged _ TRUE;
pr.specific _ NARROW[dummy.specificRef, CD.CellPtr];
pr.dummyCell _ CDApplications.NewApplicationI[ob: dummy];
END;

ReadPosition: PROC [] RETURNS [pos: CD.DesignPosition] =
BEGIN
pos.x _ TokenIO.ReadInt[];
pos.y _ TokenIO.ReadInt[];
END;

ReadLayer: PUBLIC PROC [] RETURNS [CD.Layer] =
BEGIN
key: ATOM = TokenIO.ReadAtom[];
RETURN [CD.FetchLayer[designInReadOperation.technology, key]];
END;

ReadDesignData: PROC [] =
BEGIN
index, directoryCount: INT;
token: TokenIO.Token;
obj: CD.ObPtr;
directoryCount _ TokenIO.ReadInt[];
AllocateTables[directoryCount+1]; -- ???
FOR n: INT IN [1..directoryCount] DO
index _ TokenIO.ReadInt[];
obj _ ReadObjectDefinition[];
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.p.inDirectory THEN { 
name: Rope.ROPE = CDDirectory.Name[obj];
[] _ CDDirectory.Include[designInReadOperation, obj, name];
}
ENDLOOP;
designInReadOperation.properties _ ReadProperties[];
CDProperties.PutPropOnDesign[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] 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;
CDPrivate.DebugCall => REJECT;
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 [6..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.PutPropOnDesign[design, $FileVersion, designVersionKey];
END;

VersionAndSealCheck[];
technologyKey _ TokenIO.ReadAtom[];
technologyName _ TokenIO.ReadRope[];
technology _ CD.FetchTechnology[technologyKey];
IF technology=NIL THEN {
TerminalIO.WriteRope["technology '"];
TerminalIO.WriteRope[technologyName];
TerminalIO.WriteRope["' not loded\n"];
GOTO NotDoneAndRelease
};
designInReadOperation _ CDOps.CreateDesign[technology];
TechnologyCheck[];
IF designInReadOperation=NIL THEN GOTO NotDoneAndRelease;
designInReadOperation.name _ TokenIO.ReadRope[];
IF Rope.IsEmpty[designInReadOperation.name] THEN designInReadOperation.name _ fileName; 
ReadVersionKeys[designInReadOperation]; --read before check, fixed again later
IF check#NIL THEN {
IF NOT check[designInReadOperation] THEN GOTO NotDoneAndRelease;
};
ReadDesignData[];
TokenIO.ReleaseReader[];
CDValue.Store[boundTo: designInReadOperation, key: $CDxFromFile, value: fileName];
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.WriteRope[r]; 
TerminalIO.WriteRope["...  not attached\n"];
GOTO NotAttached
}
];
DoWhileAttached[];
EXITS
NotAttached => RETURN
END;

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

DoReadDesign[check];
design _ designInReadOperation;

designInReadOperation _ NIL;
indexTable _ NIL;
tableTable _ NIL;
IF iDidTheOpen THEN IO.Close[binfile];
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;

UseWorkingDirectory: PUBLIC PROC [design: REF] RETURNS [wDir: Rope.ROPE] =
BEGIN
wDir _ GetWorkingDirectory[design];
IF wDir#NIL THEN {
[] _ List.PutAssoc[key: $WorkingDirectory, val: wDir, aList: ProcessProps.GetPropList[]];
RETURN [wDir];
};
RETURN [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;

readEvent: CDEvents.EventRegistration = CDEvents.RegisterEventType[$ReadTechnologyPrivate];
CDValue.EnregisterKey[key: $WorkingDirectory];
CDEvents.RegisterEventProc[$CreateNewDesign, NewDesignHasBeenCreated];
Commander.Register[  
key: "CD18InputToggle", 
proc: CD18Input,
doc: "toggle input mode of cd18"
];
END.


ˆCDIn.mesa
Copyright c 1983, 1985 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, April 11, 1985 3:15:36 pm PST 


--RELEASE: search for the string "RELEASE"
-- global vars
IF i<maxTableSize THEN RETURN[indexTable.table[i]]
ELSE RETURN [tableTable.tt[i/maxTableSize-1].table[i MOD maxTableSize]]
IF i<maxTableSize THEN indexTable.table[i] _ ob
ELSE tableTable.tt[i/maxTableSize-1].table[i MOD maxTableSize] _ ob
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
};
--this overwrites an old $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
server: Rope.ROPE = "indigo"; --RELEASE--
release: Rope.ROPE = "19";
main: Rope.ROPE = "/chipndale/5.2/";
IF wDir=NIL THEN wDir _ Rope.Cat["/", server, main, techName, release, "/"];
IF wDir=NIL THEN wDir _ Rope.Cat["/", server, main, "CD", release, "/"];
--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

-- Module Initialization ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--fix a problem in CD18
versionKey 0
versionKey 1:  
objects with children carry names
versionKey 2: 
versionKey 3:  June 15, 1984 3:46:13 pm PDT;  
applications 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


Κ
–

"cedar" style˜™	Jšœ
Οm
œ7™BJ™0J™0J™6J™—J˜š
Οk	˜	Jš
œ˜Jš
œ
˜
Jšœ	ž
˜
Jšžœ
˜J˜Jš
œ	˜	Jš
œ˜Jš
œ	˜	Jš
œ˜Jšœžœ˜Jš
œ	˜	Jš
œ
˜
Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
Jš
œ˜Jšžœ
˜Jš
œ˜J˜
Jš
œ˜Jšœžœžœ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—šΟbœžœ
ž˜Jš
žœ$žœ3žœGžœžœ[˜Jšžœ
ž˜Jšžœ˜%—Jš
ž˜J™Jš
œ*™*J˜Jšœžœ˜Jšœ
žœ˜J˜J™Jšœž
œ
˜Jšœžœ
žœ
žœ
˜.Jšœžœžœ
˜"Jšœ	žœ
žœ
˜J˜Jš
œžœžœžœžœ
žœ
žœ˜EJš
œžœžœžœžœ
žœ
žœ
˜HJšœžœ
˜J˜Jšœžœ
žœ
˜!Jšœžœ
žœ
˜!J˜Jšœžœ	˜J˜šΟn
œžœžœžœžœ
ž˜7Jš
ž˜Jšžœ˜Jšžœžœ
žœ™2Jšžœ
žœ*žœ™GJšžœ
˜—J˜š	 
œžœžœžœ
ž˜2Jš
ž˜Jšœž
˜Jšžœžœ™/Jšžœ)žœ™CJšžœ˜—J˜š œžœžœ˜Jš
ž˜Jšœ
žœžœ˜4šžœžœ˜Jš
œ,˜,Jš
ž˜J˜—šžœžœ™Jšœ
žœ™-š	žœžœ
žœžœΟc2™XJšœžœ™0Jš
ž™—Jš
œ™—Jšžœ
˜J˜—Jšœžœžœ‘˜BJ˜š
 œžœžœ	žœžœ˜CJš
ž˜š œžœžœ
žœ˜,Jš
œ3˜3šžœžœ
žœ˜Jš
œ$˜$Jš
œ)˜)J˜—Jš
œ˜Jšžœžœ
žœ˜=Jšžœžœ
˜J˜—J˜Jšœžœ
˜
J˜&Jš
œ˜š
ž˜Jš
œ˜šžœžœ˜Jš
œ˜Jšžœ	˜J˜—J˜J˜)š
žœžœ
žœžœ
žœ˜6Jš
œY˜YJ˜
—šžœ˜Jš
œ˜šžœžœžœž˜<Jš
œF˜F—šžœ
žœž˜!Jš
œ˜Jš
œ@˜@J˜
—šžœ
žœžœ˜"šžœžœ
žœžœ˜0Jšœžœ˜1Jš
œL˜LJ˜
—šžœ
žœžœ˜Jšœžœ˜Jš
œR˜RJ˜
—Jšžœžœ˜"Jš
œ˜Jšžœžœžœ
˜6J˜
—Jšžœ˜J˜—Jš
œ˜Jšžœžœžœ˜7Jšžœ
˜—Jšžœ
˜—J˜š œžœ˜Jš
ž˜J˜Jšœžœ˜š
ž˜Jš
œ˜Jšžœžœ˜+Jšžœ
žœžœ˜0Jšžœ	žœ
žœ
˜Jšžœ
˜—Jšžœ
˜—J˜š
 œžœžœžœžœ˜4Jšžœžœ2˜JJ˜J˜—š
 œžœžœžœžœ˜;Jš
ž˜J˜Jšœžœ˜$Jšœžœžœ:˜]š
žœžœ
žœžœ
žœ˜%Jš
œ)˜)Jš
œ*˜*Jš
œ˜Jš
œ˜Jšœ'žœ˜;J˜
—šžœ˜J˜š
žœžœ
žœžœ
žœ
˜Jšœžœ
žœ1žœ˜R—šžœžœ˜šžœžœ˜Jšœžœ˜%J˜Jšžœžœ‘"˜QJ˜—J˜—Jš
œ˜šžœžœ˜Jš
œ˜Jš
œ#˜#Jš
œ˜Jšžœžœ$˜8J˜
—Jš
œ˜—Jšžœ
˜—J˜š
 
œžœ
žœžœžœ	˜/Jš
ž˜J˜'šžœžœ‘˜ Jš	œžœžœžœ
žœ˜#Jšžœ˜J˜—J˜Jšžœ˜Jšžœ
˜J˜—Jšœ
žœ‘˜3Jšœžœžœ
˜!J˜š
 œžœ
žœžœžœ˜@Jš
ž˜Jšœžœ˜Jšœ
žœ!˜-Jšœ
žœžœ˜5Jšœžœ˜-Jšœžœ˜šžœžœ‘+˜Bšœžœ
žœ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜——šžœ˜J˜š œžœžœžœžœ$žœ˜kJš
œ
žœžœžœžœžœžœ˜XJš
ž˜šœžœ&˜-š
œ˜Jš
œ#˜#J˜J˜J˜J˜——š	œžœžœ
žœžœ
˜;J˜J˜,J˜J˜J˜J˜—Jšžœ˜
Jšžœ
˜J˜—šžœžœ˜Jš
œc˜c—šžœ‘˜Jšœžœžœ
˜Jšžœžœžœ
˜'šžœ
žœžœ˜šžœžœ
˜Jš	žœžœžœ
žœž˜B—Jšžœž˜J˜
—šžœ
žœžœ˜Jš	žœžœžœ
žœž˜BJ˜—Jšžœžœž˜'Jšžœ
žœžœž˜-Jšžœ
žœžœ˜9šžœžœžœ
žœ˜0JšœXžœ˜_—šžœ3˜7Jš
œ2˜2—J˜—J˜—Jšžœ˜Jšžœ
˜J˜—š
 œžœžœžœžœ˜LJš
ž˜Jšœžœ˜šžœ
ž˜Jšœžœ˜(Jš
ž˜—Jšžœ
˜—J˜š œžœžœžœ˜/Jš
ž˜Jš
œ+˜+Jšœžœ˜Jšžœžœž˜*šžœ˜Jš
œ˜Jš
œ'˜'J˜—Jš
œ˜Jšœ$žœ
˜)Jšœžœžœ
˜4Jš
œ9˜9Jšžœ
˜—J˜š œžœžœžœ˜8Jš
ž˜Jš
œ˜Jš
œ˜Jšžœ
˜—J˜š
 	œžœ
žœžœžœ	˜.Jš
ž˜Jšœžœ˜Jšžœžœ4˜>Jšžœ
˜—J˜š œžœ˜Jš
ž˜Jšœžœ
˜J˜Jšœžœ˜Jš
œ#˜#Jšœ  ‘˜(šžœžœ
žœž˜$Jš
œ˜Jš
œ˜Jš
œ˜šžœžœ˜Jš
œ˜šžœž˜Jšœžœžœ˜$Jšœžœ˜Jš
œJ˜JJš
œ˜Jšžœ
˜—Jš
œ˜J˜
—šžœ
žœžœ˜!Jšœžœ˜(Jš
œ;˜;J˜
—Jšžœ
˜—Jš
œ4˜4Jš
œM™MJš
œT˜TJšœžœ
˜#š
ž˜Jš
œ˜šžœžœ˜J˜Jšžœ
˜J˜—Jšœžœ.˜QJšžœ
˜—Jš
œ˜Jšžœžœ
žœ˜=Jšžœ
˜—J˜š 
œžœ
žœ
žœžœ
žœ	žœžœ	žœžœžœžœžœ˜rJ™1Jš
œW™WJš
œ-™-J™0Jš
œ™Jš
ž˜šžœ
žœ˜Jšœ
žœ
˜Jšœ
žœ
˜Jšœžœ
˜Jš
œ˜—J˜Jšœžœ	‘$˜7Jš
œE™EJ˜š œžœ
žœ	žœžœ	žœžœ˜FJš
œ2™2J™#š
ž˜šžœ˜Jšžœžœ
˜&Jšœžœ
˜š
œ˜Jš
œ6˜6Jšžœ
˜Jš
œ˜—šœ
žœ˜Jš
œE˜EJš
ž˜Jš
œ˜—J˜—J˜—š œžœ
žœ˜#Jš
œ™Jš
ž˜šžœ
žœ˜Jšœž˜Jš
œ˜J˜—J˜š œžœ
žœ˜#Jš
œ:™:Jš
ž˜Jšžœ
žœžœ˜/šœžœ˜#Jš
œ˜Jš
œ˜Jšœžœ˜Jšœž˜Jš
œ˜—šžœžœ˜Jšœžœ˜Jš
œ2˜2J˜
—Jšžœ
˜—J˜š œž
œ˜'Jš
ž˜Jš
œ™šžœ"žœ˜*Jš
œ9˜9Jšžœ.˜3—Jš
œ™Jš
œ˜šžœžœ˜šžœžœ‘
˜(Jš
œI˜IJš
œ6˜6Jšžœ.˜3Jš
œ
˜
—š	žœ
žœžœžœ‘˜FJš
ž˜J˜
—š	žœ
žœžœžœ‘˜GJš
œI˜IJ˜
—š	žœ
žœž
œžœ‘˜5Jš
œ#˜#Jš
œV˜VJš
œe˜eJš
œS˜SJ˜Jš
œR˜RJš
œ/˜/Jš
œ!˜!J˜Jš
œͺ
˜ͺ
Jš
œ#˜#J˜
—šžœ
žœžœ‘˜5Jš
œ#˜#Jš
œV˜VJš
œe˜eJš
œQ˜QJš
œ„
˜„
Jš
œ#˜#J˜
—š	žœ
žœžœžœ‘˜HJš
œ#˜#Jš
œI˜IJš
œe˜eJš
œ#˜#J˜
—šžœ‘
˜Jš
œI˜IJš
œ<˜<Jšžœ.˜3J˜—Jš
œ˜—Jš
œ™šžœžœ˜šžœžœ˜Jš
œJ˜JJšžœ;˜@Jš
œ˜—J˜—Jšžœ
˜J˜š œžœ
žœ
˜+Jš
ž˜šžœžœ˜Jš
œ&˜&J˜—šžœ žœ
˜'Jš
œM˜M—Jš
œE˜EJšžœ
˜—J˜—Jš
œ™Jš
œ˜Jš
œ#˜#Jš
œ$˜$Jšœ
žœ ˜/šžœžœ
žœ˜Jš
œ%˜%Jš
œ%˜%Jš
œ&˜&Jšžœ˜J˜—Jš
œ7˜7Jš
œ˜Jšžœžœ
žœ
žœ˜9Jš
œ0˜0Jšžœ*žœ(˜XJšœ(‘&˜Nšžœžœ
žœ˜Jšžœ
žœžœ
žœ˜@J˜—Jš
œ˜Jš
œ˜Jš
œR˜Rš
ž˜š
œ˜Jšœžœ
˜Jš
œ˜J˜——Jšžœ
˜J˜—Jš
œ™Jšœžœ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ˜š
œ˜š
œ˜Jšœžœ˜!Jš
žœ
žœžœžœžœ˜=Jš
œ˜Jš
œ,˜,Jšžœ˜Jš
œ
˜
—Jš
œ˜—Jš
œ˜š
ž˜Jšœž˜—Jšžœ
˜—J˜š œžœžœ
žœ˜-Jš
ž˜Jšœžœ'˜6Jš
œ$˜$šžœžœ
žœ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jš
œ&˜&Jšžœ
˜—J™Jš
œ™Jšœ
žœžœ
˜Jšœžœ
˜J™Jš
œ)™)šžœžœ
žœ
žœžœ
žœžœ˜.Jšœžœ
˜Jšœ
žœžœ
žœ
˜!J˜
—šžœ˜Jšžœžœ
žœ˜"š
žœ
žœ
žœžœžœ˜&Jšœžœžœ˜Jšžœžœ˜-J˜
—šžœ˜Jš
œO˜OJšžœ˜J˜—Jš
œ"˜"šœ
žœžœ
˜/šžœžœ˜Jš
œ˜Jš
œ&˜&Jš
œ)˜)Jš
œ˜Jšžœ˜Jš
œ˜——Jšœžœ
˜Jš
œ˜Jš
œ#˜#J˜—J˜Jš
œ™J˜Jš
œ˜J˜Jš
œ™Jš
œ˜Jšœž˜Jšœž˜Jšžœ
žœ
žœ˜&Jšžœ
˜š
ž˜šœ
ž
˜Jšœž˜Jšœž˜Jšœžœ
˜Jš
œ(˜(Jšžœžœ˜
J˜
——Jšžœ
˜—J˜š
 œžœ
žœžœžœ˜HJš
ž˜Jšœžœ˜šžœžœ˜Jšžœžœ	žœžœžœ
žœ˜VJ˜
—šžœ
˜Jš
žœžœžœžœ
žœ˜E—Jšžœ
˜—J™Jš
œ8™8J˜š
 œžœ
žœžœžœ˜NJš
œ0™0Jš
œ™Jšžœ
ž˜šžœžœ
žœžœ˜IJšœžœ
˜Jš
œ1˜1Jš
œ˜šžœžœžœ"žœ˜NJšžœ
˜J˜
—J˜—Jšžœžœ
˜Jšžœ
˜—J˜š
 œžœ
žœ
žœ
žœ˜AJš
ž˜Jš
œ-˜-Jš
œD˜DJšžœ
˜J˜—Jšœ< 
˜=J˜š œžœ
žœ
žœžœ
žœ
žœ˜NJš
ž˜Jšœ
žœ
‘™)Jšœžœ™Jšœžœ™$šžœžœ
žœ
˜šœžœ˜šžœMžœ
ž˜\Jšœžœ$˜0Jšžœžœ
˜—J˜—šœžœ˜Jšœžœ
˜ Jšžœ
žœ
žœ$˜8š
œ/˜/Jš
œ9˜9Jšœ	ž˜Jš
œ˜—Jšžœžœ
žœ<™LJšžœžœ
žœžœ˜1Jšžœžœ
žœ˜$Jš
œ˜—šžœ˜šžœžœ
žœ˜š
œ˜Jšœ;žœ˜A—Jšžœžœ
žœ8™HJšžœžœ
žœ˜$Jš
œ˜—J˜——Jšžœ
˜—J˜š œžœ
žœ
žœžœ
žœ˜JJš
œ"™"J™
Jš
ž˜Jš
œ#˜#šžœžœ
žœ˜Jš
œY˜YJšžœ˜J˜—Jšžœ&˜,Jšžœ
˜J˜—š œžœ
žœžœžœžœ˜BJš
œA™AJšœžœ˜Jšœžœ˜šžœ	ž˜šžœ!ž˜+Jšœžœ˜Jšœžœ
˜Jšžœ
˜—Jšžœ
˜—Jšžœ˜
J˜J˜—š œžœ
žœ
žœ˜(Jšœ
žœ
žœ
žœ
žœžœ
žœžœžœ˜WJš
ž˜Jšœžœ˜#Jš
œ™Jšœžœ˜&Jš
œ™Jšžœžœ˜3Jš
œ™šžœžœ#žœ˜>Jšœžœ˜"Jšžœžœ˜.Jšžœ˜#J˜—Jš
œ™šžœžœ
žœ˜Jšžœ
žœžœž˜6Jš
œ'˜'J˜—Jš
œ™šžœžœ˜ Jš
œ˜J˜—Jšžœ˜
Jšžœ
˜—J˜š 
œžœ
žœ	žœ
žœžœ˜PJš
ž˜J˜š
 œžœ
žœžœžœ˜5Jš
œ™Jšœžœ˜Jšœžœ˜šžœ	ž˜šžœ!ž˜+Jšœžœ˜Jšœžœ
˜Jšžœ
˜—Jšžœ
˜—Jšžœ˜
J˜J˜—š
 œžœ
žœžœžœ˜?Jš
œ)™)Jšœ
žœ
˜Jš
œ$˜$Jš
œ˜Jš
œ˜šžœ	žœ.žœžœ
˜HJš
œ!˜!—Jšžœ˜
J˜—J˜Jš
œ™šžœ3žœ
žœ
˜CJšœžœ˜*Jšžœžœ
˜—Jšžœžœ
žœ˜$Jšžœžœ
žœ˜ Jšžœ
˜J˜—šŸœ˜-Jš
œ3™3Jš
œ-™-Jš
ž˜Jš
œA˜AJšžœ
˜—J™šŸ	œ˜#Jš
ž˜Jš
œ)˜)šžœž˜Jš
œ>˜>—š
ž˜Jš
œ@˜@—Jšžœ
˜—J˜Jš‘œ!™:Jš
œ[˜[Jš
œ.˜.J˜Fš
œ™š
œ˜J˜J˜J˜ Jš
œ˜——Jšžœ
˜J˜J˜Jš
œ™š
œ™Jš
œ!™!—Jš
œ™š
œ.™.Jš
œY™Y—š
œ0™0Jš
œ™—š
œ™Jš
œ=™=—š
œ2™2Jš
œA™A—š
œ0™0Jš
œ6™6—š
œ/™/J™!—š
œ.™.J™J™!J™—J™
—…—NΘyQ