DIRECTORY
Ascii,
Atom,
CD,
CDEnvironment,
CDEvents,
CDOps,
CDValue,
Commander,
CommandTool,
FileNames,
FS,
Icons,
IO,
List,
PopUpSelection,
ProcessProps,
Rope,
RuntimeError,
SystemNames,
TerminalIO,
TEditImpl USING [ReloadTable], --crazy, wonderful tiptable load procedure
TIPUser,
UserProfile;

CDEnvironmentImpl: CEDAR PROGRAM 
IMPORTS Atom, CD, CDEvents, CDOps, CDValue, Commander, CommandTool, FileNames, FS, Icons, IO, List, PopUpSelection, ProcessProps, RuntimeError, Rope, SystemNames, TEditImpl, TerminalIO, TIPUser, UserProfile
EXPORTS CDEnvironment =
BEGIN


cdVersion: PUBLIC NAT _ 25;
preRelease: PUBLIC BOOL _ FALSE;
date: Rope.ROPE = "April 17, 1987";

profilePrefix: PUBLIC Rope.ROPE _ IO.PutFR["ChipNDale%g.", [integer[cdVersion]]];
commandsPrefix: Rope.ROPE _ FileNames.ConvertToSlashFormat[SystemNames.LocalDir["Commands"]];
systemPrefix: Rope.ROPE _ FileNames.ConvertToSlashFormat[SystemNames.LocalDir["System"]];

Prefixed: PROC [r1, r2: Rope.ROPE_NIL] RETURNS [Rope.ROPE] = {
RETURN [Rope.Cat[profilePrefix, r1, r2]]
};
copyRight: Rope.ROPE = "Copyright (C) 1984, 1987 by Xerox Corporation.  All rights reserved.\n\n";
SetTipTable: PUBLIC PROC [for: REF, tipTable: Rope.ROPE] = {
TryExplicitTipTable: PROC [for: REF, name: Rope.ROPE] RETURNS [tipTable: TIPUser.TIPTable] = {
name _ MakeName[base: name, ext: "tip", wDir: TechWDir[for]];
tipTable _ TIPUser.InstantiateNewTIPTable[name ! 
FS.Error => {
TerminalIO.PutRopes["Tip-table not installed; ", error.explanation, "\n"];
GOTO oops
};
TIPUser.InvalidTable => {
TerminalIO.PutRopes["Tip-table not installed; ", errorMsg, "\n"];
GOTO oops
};
]; 
EXITS oops => NULL
};
InstallStandardTip: PROC [for: REF] RETURNS [tipTable: TIPUser.TIPTable _ NIL] = {
WITH for SELECT FROM
tech: CD.Technology => {
techPart: Rope.ROPE _ MakeName[base: "ChipNDale", ext: "tip", modifier: tech.name, wDir: GetWorkingDirectory[tech]];
base: Rope.ROPE _ MakeName[base: "ChipNDale", ext: "tip", wDir: GetWorkingDirectory[NIL]];
default: Rope.ROPE _ Rope.Cat[techPart, " ", base]; 
tipTable _ TEditImpl.ReloadTable[oldTIP: NIL, profileKey: Prefixed[tech.name, ".TIP"], default: default];
IF tipTable=NIL THEN { 
TerminalIO.PutRopes["* tip-table for ", tech.name, " not installed\n"];
tipTable _ TryExplicitTipTable[for, "ChipNDale.tip"];
};
};
d: CD.Design => tipTable _ InstallStandardTip[d.technology]; 
ENDCASE => TerminalIO.PutRope["* tip-table not installed\n"];
};
tipTab: TIPUser.TIPTable _ NIL;
IF Rope.IsEmpty[tipTable] THEN tipTable _ "Standard"; 
CDValue.Store[for, $TipTableName, tipTable];
IF Rope.Equal[tipTable, "Standard"] THEN tipTab _ InstallStandardTip[for]
ELSE tipTab _ TryExplicitTipTable[for, tipTable];
IF tipTab#NIL THEN CDValue.Store[for, $TipTable, tipTab];
};

GetTipTable: PUBLIC PROC [for: REF] RETURNS [TIPUser.TIPTable] = {
WITH CDValue.Fetch[boundTo: for, key: $TipTable, propagation: global] SELECT FROM
tipTable: TIPUser.TIPTable => RETURN [tipTable];
ENDCASE => RETURN [NIL];
};

ReInstallStandardTipTables: Commander.CommandProc = {
EachTech: CD.TechnologyEnumerator = {
WITH CDValue.Fetch[tech, $TipTableName] SELECT FROM
r: Rope.ROPE => IF Rope.Equal[r, "Standard"] THEN SetTipTable[tech, r];
ENDCASE => NULL;
};
[] _ CD.EnumerateTechnologies[EachTech];
[] _ CDEvents.ProcessEvent[reInstallTipTables, NIL];
}; 

FetchIconFromFile: PROC [for: REF, file: Rope.ROPE, n: NAT] RETURNS [icon: REF Icons.IconFlavor] = {
if: Icons.IconFlavor;
icon _ NEW[Icons.IconFlavor_tool];
file _ MakeName[base: file, ext: "icon", wDir: TechWDir[for]];
if _ Icons.NewIconFromFile[file, n ! RuntimeError.UNCAUGHT => GOTO Oops];
icon^ _ if;
EXITS Oops => TerminalIO.PutRope["** icon not loaded\n"];
};

SetIcon: PUBLIC PROC [for: REF, file: Rope.ROPE, n: NAT] = {
icon: REF Icons.IconFlavor _ FetchIconFromFile[for, file, n];
CDValue.Store[for, $Icon, icon];
};

GetIcon: PUBLIC PROC [for: REF] RETURNS [Icons.IconFlavor] = {
WITH CDValue.Fetch[for, $Icon, global] SELECT FROM
ip: REF Icons.IconFlavor => RETURN [ip^];
ENDCASE => RETURN [Icons.IconFlavor[unInit]] 
};

SetPanelIcon: PUBLIC PROC [for: REF, file: Rope.ROPE, n: NAT] = {
icon: REF Icons.IconFlavor _ FetchIconFromFile[for, file, n];
CDValue.Store[for, $PanelIcon, icon];
};

GetPanelIcon: PUBLIC PROC [for: REF] RETURNS [Icons.IconFlavor] = {
WITH CDValue.Fetch[for, $PanelIcon, global] SELECT FROM
ip: REF Icons.IconFlavor => RETURN [ip^];
ENDCASE => RETURN [Icons.IconFlavor[unInit]] 
};


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

SetWorkingDirectory: PUBLIC PROC [for: REF, wDir: Rope.ROPE] = {
IF wDir=NIL THEN {
WITH for SELECT FROM
t: CD.Technology => {
techName: Rope.ROPE _ t.name;
IF techName=NIL THEN techName _ Atom.GetPName[t.key];
wDir _ UserProfile.Token[Prefixed[techName, ".BaseDirectory"]];
};
d: CD.Design => NULL;
ENDCASE => IF for=NIL THEN {
wDir _ UserProfile.Token[Prefixed["BaseDirectory"]];
};
IF wDir=NIL THEN wDir _ FileNames.CurrentWorkingDirectory[];
};
CDValue.Store[for, $WorkingDirectory, CheckWDir[wDir]];
};

GetWorkingDirectory: PUBLIC PROC [for: REF] RETURNS [wDir: Rope.ROPE_NIL] = {
WITH CDValue.Fetch[for, $WorkingDirectory, global] SELECT FROM
r: Rope.ROPE => wDir _ CheckWDir[r];
ENDCASE => NULL;
};
DoWithWDir: PUBLIC PROC [wDir: Rope.ROPE, proc: PROC] = {
ProcessProps.AddPropList[
propList: Atom.PutPropOnList[NIL, $WorkingDirectory, wDir],
inner: proc
];
};

RegisterCommander: PUBLIC PROC [key: Rope.ROPE, proc: Commander.CommandProc _ NIL, doc: Rope.ROPE _ NIL, clientData: REF _ NIL, interpreted: BOOL _ TRUE, technology: CD.Technology _ NIL] = {
gWDir: Rope.ROPE _ GetWorkingDirectory[NIL];
Commander.Register[key: key, proc: proc, doc: doc, clientData: clientData, interpreted: interpreted];
Commander.Register[key: Rope.Cat[gWDir, key], proc: proc, doc: doc, clientData: clientData, interpreted: interpreted];
IF technology#NIL THEN {
tWDir: Rope.ROPE _ GetWorkingDirectory[technology];
IF ~Rope.Equal[gWDir, tWDir] THEN
Commander.Register[key: Rope.Cat[tWDir, key], proc: proc, doc: doc, clientData: clientData, interpreted: interpreted]
}
};    

MakeName: PUBLIC PROC [base: Rope.ROPE, ext: Rope.ROPE_NIL, wDir: Rope.ROPE_NIL, modifier: Rope.ROPE_NIL] RETURNS [Rope.ROPE] = {

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

bang: INT = TrailingChar[base, '!];
r: Rope.ROPE _ Rope.Substr[base: base, len: bang];
IF ~modifier.IsEmpty[] THEN r _ Rope.Concat[r, modifier];
IF ~ext.IsEmpty[] AND (TrailingChar[r, '.]>=Rope.Length[r]) THEN {
dot2: INT _ TrailingChar[ext, '.];
IF dot2>=Rope.Length[ext] THEN r _ Rope.Cat[r, ".", ext]
ELSE r _ Rope.Concat[r, ext.Substr[dot2]]
};
IF wDir#NIL THEN {
IF Rope.IsEmpty[r] OR (Rope.Fetch[r]#'/ AND Rope.Fetch[r]#'[) THEN {
dir: Rope.ROPE _ FileNames.Directory[wDir];
IF ~Rope.IsEmpty[dir] THEN r _ Rope.Cat[FileNames.ConvertToSlashFormat[dir], r]
}
};
IF bang<Rope.Length[base] THEN {
r _ Rope.Concat[r, Rope.Substr[base, bang]]
};
RETURN [r]
};
FindFile: PUBLIC PROC [base: Rope.ROPE, ext: Rope.ROPE_NIL, for: REF_NIL] RETURNS [fn: Rope.ROPE] = {
searchPath: LIST OF Rope.ROPE _ LIST[commandsPrefix, systemPrefix];
AddToWDir: PROC [r: Rope.ROPE] = {
IF ~Rope.IsEmpty[r] AND ~Rope.Equal[searchPath.first, r] THEN
searchPath _ CONS[r, searchPath];
};
AddToWDir[GetWorkingDirectory[NIL]];
WITH for SELECT FROM
rl: LIST OF Rope.ROPE => searchPath _ rl;
r: Rope.ROPE => searchPath _ LIST[r];
r: REF TEXT => searchPath _ LIST[Rope.FromRefText[r]];
d: CD.Design => {
AddToWDir[GetWorkingDirectory[d.technology]];
AddToWDir[GetWorkingDirectory[d]];
};
t: CD.Technology => {
AddToWDir[GetWorkingDirectory[t]];
};
ENDCASE => NULL;
AddToWDir[FileNames.CurrentWorkingDirectory[]];
IF Rope.Length[ext]>0 AND Rope.Fetch[ext, 0]#'. THEN ext _ Rope.Concat[".", ext];
fn _ FileNames.FileWithSearchRules[root: base, defaultExtension: ext, requireExtension: FALSE, requireExact: TRUE, searchRules: searchPath].fullPath;
}; 

RemoveSpaces: PUBLIC PROC [line: Rope.ROPE] RETURNS [Rope.ROPE_NIL] = {
leng: INT _ Rope.Length[line];
start: INT _ 0;
WHILE start<leng DO
SELECT Rope.Fetch[line, start] FROM
Ascii.SP, Ascii.TAB => start _ start+1;
ENDCASE => EXIT;
ENDLOOP;
WHILE leng>start DO
SELECT Rope.Fetch[line, leng-1] FROM
Ascii.SP, Ascii.TAB => leng _ leng-1;
ENDCASE => EXIT;
ENDLOOP;
IF leng>start THEN RETURN [Rope.Substr[line, start, leng-start]];
};

SplitLine: PUBLIC PROC [line: Rope.ROPE] RETURNS [key, rest: Rope.ROPE_NIL] = {
leng: INT _ Rope.Length[line];
nextPos: INT _ 0;
startPos: INT _ 0;
WHILE startPos<leng DO
SELECT Rope.Fetch[line, startPos] FROM
Ascii.SP, Ascii.TAB => startPos _ startPos+1;
ENDCASE => EXIT;
ENDLOOP;
nextPos _ startPos;
WHILE nextPos<leng DO
SELECT Rope.Fetch[line, nextPos] FROM
Ascii.SP, ':, Ascii.TAB => EXIT;
ENDCASE => nextPos _ nextPos+1;
ENDLOOP;
IF startPos<nextPos THEN key _ Rope.Substr[line, startPos, nextPos-startPos];
nextPos _ nextPos+1;
WHILE nextPos<leng DO
SELECT Rope.Fetch[line, nextPos] FROM
Ascii.SP, Ascii.TAB => nextPos _ nextPos+1;
ENDCASE => {rest _ Rope.Substr[line, nextPos, leng-nextPos]; RETURN}
ENDLOOP;
};

FetchKeyLine: PUBLIC PROC [fileName: Rope.ROPE, key: Rope.ROPE] RETURNS [entry: Rope.ROPE_NIL] = {
line, first, rest: Rope.ROPE; file: IO.STREAM;
file _ FS.StreamOpen[fileName ! FS.Error => GOTO finish];
DO
line _ IO.GetLineRope[file ! IO.EndOfStream => GOTO finish];
IF ~Rope.IsEmpty[line] THEN {
[first, rest] _ SplitLine[line]; 
IF Rope.Equal[first, key] THEN RETURN [rest]
}
ENDLOOP;
EXITS finish => NULL;
};


StuffToCommandTool: PUBLIC PROC [r: Rope.ROPE, wDir: Rope.ROPE_NIL, searchPath: LIST OF Rope.ROPE_NIL, catchErrors: BOOL_TRUE, continueErrors: BOOL_TRUE] RETURNS [result: REF_NIL] = {

RopeListPath: PROC [rl: LIST OF Rope.ROPE] RETURNS [path: List.LORA _ NIL] = {
last: Rope.ROPE_NIL;
FOR l: LIST OF Rope.ROPE _ rl, l.rest WHILE l#NIL DO
IF ~Rope.IsEmpty[l.first] AND ~Rope.Equal[last, l.first, FALSE] THEN {
last _ l.first;
path _ CONS[last, path];
}  
ENDLOOP;
RETURN [List.DReverse[path]]
};

propertyList: List.AList _ List.PutAssoc[key: $StopOnFailure, val: $TRUE, aList: NIL]; --temporary
out: Rope.ROPE; --for the result rope returned by the CommandTool 
cmd: Commander.Handle _ NEW[Commander.CommandObject _ [
out:  TerminalIO.TOS[],
err:  TerminalIO.TOS[],
in:  IO.noInputStream,
propertyList: List.PutAssoc[key: $SearchRules, val: RopeListPath[searchPath], aList: propertyList]
]];

Exec: PROC [] = {
[out, result] _ CommandTool.DoCommandRope[commandLine: r, parent: cmd];
};

IF Rope.IsEmpty[r] THEN TerminalIO.PutRopes["executes empty command\n"]
ELSE {
TerminalIO.PutRopes["executes: """, r, """\n"];
DoWithWDir[wDir, Exec !
ABORTED => {TerminalIO.PutRope["\n**aborted\n"]; IF continueErrors THEN CONTINUE};
RuntimeError.UNCAUGHT => {
IF ~catchErrors THEN REJECT 
ELSE
SELECT PopUpSelection.Request[
header: "ERROR", 
choice: LIST["continue with ChipNDale", "debug"], 
headerDoc: "error while executing stuff", 
choiceDoc: LIST["usually ok", "land in debugger (abort will continue ChipNDale)"],
timeOut: 600 --10 minutes
] FROM
1 => CONTINUE;
-1 => {TerminalIO.PutRope["\n**Timed out request for debugging: reject will probably open a debugger window\n"]; REJECT};
2 => REJECT;
ENDCASE => CONTINUE;
};
];
TerminalIO.PutRopes["\n{", out, "}\n"];
};
};
ExecFileEntry: PUBLIC PROC [key: Rope.ROPE, technology: CD.Technology_NIL, modifier: Rope.ROPE_NIL, catchErrors: BOOL_TRUE, continueErrors: BOOL_TRUE] = {
wDir: Rope.ROPE; --for working directories
entry: Rope.ROPE; --for the line which will be stuffed into a command tool 

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

searchPath: LIST OF Rope.ROPE _ LIST[GetWorkingDirectory[NIL], commandsPrefix, systemPrefix];
IF technology#NIL THEN {
wDir _ GetWorkingDirectory[technology];
searchPath _ CONS[wDir, searchPath];
Fetch[technology.name];
};
IF entry=NIL THEN {
wDir _ GetWorkingDirectory[NIL];
Fetch["CD"];
}; 
IF entry=NIL THEN TerminalIO.PutRopes["command line for ", key, " not found\n"]
ELSE [] _ StuffToCommandTool[entry, wDir, searchPath, catchErrors, continueErrors];
};
LoadTechnology: PUBLIC PROC [key: ATOM, name: Rope.ROPE] RETURNS [tech: CD.Technology_NIL] = {
IF key#NIL THEN {
tech _ CD.FetchTechnology[key];
IF tech=NIL THEN tech _ GetTechnology[key];
};
IF tech=NIL THEN {
IF name#NIL THEN tech _ GetTechnology[name];
IF tech=NIL THEN {
autoLoadDefault: BOOL _ UserProfile.Boolean[Prefixed["AutoLoad.Default"], TRUE];
IF Rope.IsEmpty[name] THEN name _ Atom.GetPName[key];
IF UserProfile.Boolean[Prefixed["AutoLoad.", name], autoLoadDefault] THEN {
TerminalIO.PutRopes["load technology """, name, """ \n"];
ExecFileEntry[name, NIL, NIL, TRUE, TRUE];
IF key#NIL THEN tech _ GetTechnology[key];
IF tech=NIL THEN tech _ GetTechnology[name];
};
IF tech=NIL THEN TerminalIO.PutRopes["technology '", name, "' not loaded\n"];
};
};
};
AskAndExecute: Commander.CommandProc = {
question: Rope.ROPE; 
cl: Rope.ROPE _ cmd.commandLine;
IF Rope.IsEmpty[cl] THEN RETURN;
question _ Rope.Cat["execute: ", Rope.Substr[base: cl, len: Rope.Length[cl]-1]];
IF ~TerminalIO.Confirm[text: question, dontLog: TRUE] THEN 
RETURN [$Failure, "denied"];
result _ CommandTool.DoCommand[commandLine: cl, parent: cmd];
};
GetTechnology: PUBLIC PROC [hint: REF] RETURNS [technology: CD.Technology] = {
GetWithRope: PROC [name: Rope.ROPE] RETURNS [t: CD.Technology_NIL] = {
EachTechnology: CD.TechnologyEnumerator = {
IF Rope.Equal[tech.name, name, FALSE] 
OR Rope.Equal[Atom.GetPName[tech.key], name, FALSE] 
THEN {quit _ TRUE; technology _ tech}
};
IF Rope.IsEmpty[name] THEN RETURN;
[] _ CD.EnumerateTechnologies[EachTechnology];
};
WITH hint SELECT FROM
tech: CD.Technology => RETURN [tech];
d: CD.Design => RETURN [d.technology];
a: ATOM =>  technology _ CD.FetchTechnology[a];
ENDCASE => NULL;
IF technology=NIL THEN RETURN [GetWithRope[CDOps.ToRope[hint]]]
};

TechWDir: PROC [for: REF] RETURNS [Rope.ROPE] = {
WITH for SELECT FROM
d: CD.Design => for _ d.technology
ENDCASE => NULL;
RETURN [GetWorkingDirectory[for]]
};

TechnologyHasBeenRegisterd: CDEvents.EventProc = {
WITH x SELECT FROM
t: CD.Technology => {
SetWorkingDirectory[t, NIL];
};
ENDCASE => NULL
};

NewDesignHasBeenCreated: CDEvents.EventProc = {
IF design#NIL THEN SetWorkingDirectory[design, FileNames.CurrentWorkingDirectory[]];
};

reInstallTipTables: CDEvents.EventRegistration _ CDEvents.RegisterEventType[ $CDReRegisterTipTables];
CDValue.RegisterKey[$TipTable, NIL, $CD];
CDValue.RegisterKey[$TipTableName, NIL, $CD];
CDValue.RegisterKey[$Icon, NIL, $CD];
CDValue.RegisterKey[$WorkingDirectory, NIL, $CD];
SetIcon[NIL, "ChipNDale.icons", 0];
SetPanelIcon[NIL, "ChipNDale.icons", 1];
SetWorkingDirectory[NIL, NIL];
CDEvents.RegisterEventProc[$CreateNewDesign, NewDesignHasBeenCreated];
CDEvents.RegisterEventProc[$RegisterTechnology, TechnologyHasBeenRegisterd];
RegisterCommander["CDReInstallTipTables", ReInstallStandardTipTables, "Reload TIP tables for standard ChipNDale technologies"];
RegisterCommander["AskFirst", AskAndExecute, "Conditionally executes command"];
TerminalIO.PutF["ChipNDale\n   %g Version %g.%g for Cedar %g\n   %g\n   Copyright (C) 1984, 1987 by Xerox Corporation.  All rights reserved.\n\n",
[rope[IF preRelease THEN "PRE RELEASED" ELSE ""]],
[integer[cdVersion/10]],
[integer[cdVersion MOD 10]],
[rope[SystemNames.ReleaseName[]]],
[rope[date]]
];
END. 


 
ΊCDEnvironmentImpl.mesa        (part of ChipNDale)
Copyright c 1983, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi,  August 11, 1983 11:32 am 
Last Edited by: Christian Jacobi, April 17, 1987 10:55:16 am PDT
-- versions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~



-- tip tables ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~



-- Icons ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Working Directories ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

--if wDir is a directory, return it in slash format
--else return NIL


-- Commander ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-- Names ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--position of last "char", only before '!, '], '>, '/ considered 
--remove version number
--include modifier
--include extension
--include working directory
--put version number back


-- Loader ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--skip leading spaces
--find position of separator
--skip leading spaces again
--Searches for a line starting with key in file
--Returns the rest of the line found or NIL if not found

--checks whether a particular key is mentioned in a .CDLoadList file
--if particular key is found, executes the rest of the line with a command tool
--technology and modifier are used to make the name of the used .CDLoadList file
--(using modifier .CDLoadList files for particular feature classes can be distinguished)
--building of name for the .CDLoadList files:
--   ChipNDale-CD.CDLoadList if {technology=NIL, modifier=NIL}
--   ChipNDale-CD-modifier.CDLoadList if {technology=NIL, modifier#NIL}
--   ChipNDale-technologyName.CDLoadList if {technology#NIL, modifier=NIL}
--   ChipNDale-technologyName-modifier.CDLoadList if {technology#NIL, modifier#NIL}
--internal procedure
--makes up the full path name of the .CDLoadList file
--and looks for a particular entry line in it
--mod: name for the technology

--makes all the necessary messages if not loaded



-- internals ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ΚΗ˜
codeš
œ1™1Kšœ
Οm
œ7™BKš
œ7™7K™@K˜—š
Οk	˜	Kšœž
˜Kšœž
˜Kšžœ
˜Kš
œ˜Kš
œ	˜	K˜K˜Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kšœ
žœΟc*˜IKš
œ˜Kš
œ˜—K˜šΟnœžœ
žœ
˜!Kšžœžœ?žœ	žœr˜Ξ
Kšžœ˜—Kš
ž˜K˜Kš
œ4™4K™K˜Kšœžœ
žœ˜Kšœžœ
žœžœ
˜ Kšœžœ˜#K˜Kšœžœžœžœ-˜QKšœžœD˜]KšœžœB˜YK˜š œžœžœ
žœžœžœ˜>Kšžœ"˜(K˜—K™KšœžœN˜bK™Kš
œ6™6K™š
 œžœ
žœžœžœ˜<š
 œžœžœ
žœžœ!˜^Kš
œ=˜=š
œ1˜1šžœ˜
Kš
œJ˜JKšžœ˜	Kš
œ˜—š
œ˜Kš
œA˜AKšžœ˜	Kš
œ˜—Kš
œ˜—Kšžœ	ž˜Kš
œ˜—š
 œžœžœžœžœ˜Ršžœžœ
ž˜šœžœ˜Kšœžœa˜tKšœžœEžœ˜ZKšœžœ"˜4Kšœ)žœ=˜išžœ
žœ
žœ˜Kš
œG˜GKš
œ5˜5K˜—Kš
œ˜—Kšœžœ8˜=Kšžœ6˜=—Kš
œ˜—Kšœžœ
˜Kšžœžœ˜6Kš
œ,˜,Kšžœ"žœ!˜IKšžœ-˜1Kšžœžœ
žœ'˜9Kš
œ˜—K˜š
 œžœ
žœžœžœ˜BšžœBžœ
ž˜QKšœžœ˜0Kšžœžœžœ˜—Kš
œ˜—K˜šΠbnœ˜5š‘œžœ˜%šžœ$žœ
ž˜3Kšœžœžœžœ˜GKšžœžœ
˜—K˜—Kšœžœ!˜(Kšœ/žœ˜4Kš
œ˜—K™K™Kš
œ4™4K˜š œžœžœ
žœžœžœžœ˜dKš
œ˜Kšœžœ˜"Kš
œ>˜>Kšœ2žœžœ˜IKš
œ˜Kšžœ4˜9Kš
œ˜—K˜š œžœ
žœžœ
žœžœ˜<Kšœžœ4˜=Kš
œ ˜ Kš
œ˜K˜—š
 œžœ
žœžœžœ˜>šžœ#žœ
ž˜2Kšœžœžœ˜)Kšžœžœ˜-—Kš
œ˜—K˜š œžœ
žœžœ
žœžœ˜AKšœžœ4˜=Kš
œ%˜%Kš
œ˜K˜—š
 œžœ
žœžœžœ˜Cšžœ(žœ
ž˜7Kšœžœžœ˜)Kšžœžœ˜-—Kš
œ˜—K˜Kš
œ8™8K™š
 	œžœ
žœžœžœ˜DKš
œ3™3Kš
œ™Kšœžœ
˜šžœžœ
ž
œžœ˜FKš
œ1˜1Kš
œ ˜ Kšžœ
žœžœ
žœ
˜EK˜—Kšžœžœ
˜Kš
œ˜—K˜š
 œžœ
žœžœ
žœ˜@šžœžœ
žœ˜šžœžœ
ž˜šœžœ˜Kšœžœ
˜Kšžœ
žœ
žœ!˜5Kš
œ?˜?K˜—Kšœžœžœ
˜šžœžœžœ
žœ˜Kš
œ4˜4K˜——Kšžœžœ
žœ,˜<K˜—Kš
œ7˜7Kš
œ˜K˜—š œžœ
žœžœžœ
žœ
žœ˜Mšžœ/žœ
ž˜>Kšœžœ˜$Kšžœžœ
˜—Kš
œ˜—K™š 
œžœ
žœžœ˜9š
œ˜Kšœžœ˜;Kš
œ˜K˜—K˜—K™Kš
œ8™8K˜š œžœ
žœžœ žœžœžœžœžœžœžœžœžœ˜Ύ
Kšœžœžœ˜,Kš
œe˜eKš
œv˜všžœžœ
žœ˜Kšœžœ#˜3šžœž˜!Kš
œu˜u—K˜
—Kš
œ˜—K™Kš
œ4™4K˜š œžœ
žœ
žœžœ
žœ
žœ
žœžœ
žœžœžœ˜
K˜š œžœ
žœžœžœžœ˜BKš
œA™AKšœžœ˜Kšœžœ˜šžœ	ž˜šžœ!ž˜+Kšœžœ˜Kšœžœ
˜Kšžœ
˜—Kšžœ
˜—Kšžœ˜
K˜K˜—Kšœžœ˜#Kš
œ™Kšœžœ&˜2Kš
œ™Kšžœžœ˜9Kš
œ™šžœžœ'žœ˜BKšœžœ˜"Kšžœžœ˜8Kšžœ%˜)K˜—Kš
œ™šžœžœ
žœ˜šžœžœžœžœ˜DKšœ
žœ˜+Kšžœžœ5˜OK˜
—K˜—Kš
œ™šžœžœ˜ Kš
œ+˜+K˜—Kšžœ˜
Kš
œ˜—K™š œžœ
žœžœ
žœžœ
žœžœžœ˜eKš	œžœ
žœžœžœ˜Cš 	œžœ
žœ˜"šžœžœ"ž˜=Kšœ
žœ˜!—Kš
œ˜—Kšœžœ˜$šžœžœ
ž˜Kšœžœ
žœžœ˜)Kšœžœžœ˜%Kšœžœžœ˜6šœžœ˜Kš
œ-˜-Kš
œ"˜"Kš
œ˜—šœžœ˜Kš
œ"˜"Kš
œ˜—Kšžœžœ
˜—Kš
œ/˜/Kšžœžœžœ˜QKšœXžœžœ$˜•
Kš
œ˜—K™KšœŸœ"™+K˜š œžœ
žœžœžœ
žœ˜GKšœžœ˜Kšœžœ˜šžœž˜šžœž˜#Kšœžœžœ˜'Kšžœžœ
˜—Kšžœ
˜—šžœž˜šžœž˜$Kšœžœžœ˜%Kšžœžœ
˜—Kšžœ
˜—Kšžœžœ
žœ(˜AK˜—K˜š 	œžœ
žœ
žœžœžœ
žœ˜OKšœžœ˜Kšœ	žœ˜Kšœ
žœ˜Kš
œ™šžœž˜šžœž˜&Kšœžœžœ˜-Kšžœžœ
˜—Kšžœ
˜—Kš
œ™Kš
œ˜šžœž˜šžœž˜%Kšœžœžœžœ
˜ Kšžœ˜—Kšžœ
˜—Kšžœžœ5˜MKš
œ˜Kš
œ™šžœž˜šžœž˜%Kšœžœžœ˜+Kšžœ6žœ
˜D—Kšžœ
˜—Kš
œ˜—K˜š‘œžœ
žœžœžœžœžœ
žœ˜bKš
œ/™/Kš
œ8™8Kšœžœžœ
žœ
˜.Kšœžœžœ
žœ	˜9š
ž˜Kš	œžœΟr
Πkr’œžœ	˜<šžœžœ˜Kš
œ!˜!Kšžœžœ
žœ˜,K˜
—Kšžœ
˜—Kšžœžœ
˜Kš
œ˜—K˜K˜š" œžœ
žœ
žœ
žœ
žœžœ
žœžœ
žœžœ
žœžœ
žœžœ
žœ
žœ˜·
K˜š œžœžœ
žœžœžœ
žœžœ˜NKšœžœ
žœ
˜š
žœžœ
žœžœžœžœ
ž˜4šžœžœžœžœ˜FKš
œ˜Kšœžœ
˜Kš
œ˜—Kšžœ
˜—Kšžœ˜Kš
œ˜—K˜KšœQžœŸ˜bKšœ
žœŸ2˜Bšœžœ˜7Kšœžœ˜Kšœžœ˜Kšœžœ˜Kš
œb˜bKš
œ˜—K˜š œžœ˜Kš
œG˜GK˜—K˜Kšžœžœ0˜Gšžœ˜Kš
œ/˜/š
œ˜Kšžœ*žœžœ
žœ˜Ršœ
žœ˜Kšžœžœ
žœ
˜š
ž˜šžœ˜Kš
œ˜Kšœžœ&˜2Kš
œ*˜*KšœžœC˜RKšœ
Ÿ˜Kšœž˜Kšœžœ
˜Kšœqžœ˜yKšœžœ
˜Kšžœžœ
˜——K˜—Kš
œ˜—Kš
œ'˜'Kš
œ˜—Kš
œ˜—K™š 
œžœ
žœžœžœžœžœ
žœžœ
žœžœ
žœ˜š
Kš
œD™DKš
œO™OKš
œP™PKš
œX™XKš
œ-™-Kš
œ>™>Kš
œG™GKš
œJ™JKš
œS™SKšœžœŸ˜*KšœžœŸ9˜KK˜š œžœžœ˜ Kš
œ™Kš
œ5™5Kš
œ-™-Kš
œ™Kšžœ
žœ
žœ$˜8Kš
œ6˜6Kš
œ˜K˜—K˜Kšœžœ
žœžœžœžœ!˜]šžœžœ
žœ˜Kš
œ'˜'Kšœ
žœ˜$Kš
œ˜K˜—šžœžœ
žœ˜Kšœžœ˜ Kš
œ˜Kš
œ˜—Kšžœžœ
žœ>˜OKšžœO˜SKš
œ˜—K™š œžœ
žœžœ
žœžœžœžœ˜^K™0šžœžœ
žœ˜Kšœžœ˜Kšžœžœ
žœ˜+K˜—šžœžœ
žœ˜Kšžœžœ
žœ˜,šžœžœ
žœ˜Kšœžœ5žœ˜PKšžœžœ˜5šžœCžœ˜KKš
œ9˜9Kš	œžœžœžœžœ˜*Kšžœžœ
žœ˜*Kšžœžœ
žœ˜,K˜—Kšžœžœ
žœ=˜MK˜—K˜—K˜—K™š 
œ˜(Kšœžœ˜Kšœ	žœ˜ Kšžœžœ
žœ
˜ Kš
œP˜Pšžœ.žœžœ
˜;Kšžœ˜—Kš
œ=˜=K˜—K™š 
œžœ
žœžœžœžœ˜Nš œžœ
žœžœžœžœ˜Fš‘œžœ˜+šžœžœ˜&Kšžœ+žœ˜4Kšžœ	žœ˜%—K˜—Kšžœžœ
žœ
˜"Kšœžœ'˜.K˜—šžœžœ
ž˜Kšœžœžœ˜%Kšœžœžœ˜&Kšœžœžœ˜/Kšžœžœ
˜—Kšžœžœ
žœ
žœ"˜?K˜—K™Kš
œ.™.K˜š
 œžœžœžœžœ˜1šžœžœ
ž˜Kšœžœ˜"Kšžœžœ
˜—Kšžœ˜!Kš
œ˜—K˜š œ˜2šžœžœ
ž˜šœžœ˜Kšœžœ˜Kš
œ˜—Kšžœž˜—Kš
œ˜—K˜š‘œ˜/Kšžœžœ
žœB˜TKš
œ˜—K˜Kš
œe˜eKšœžœ˜)Kšœ#žœ˜-Kšœžœ˜%Kšœ'žœ˜1Kšœžœ˜#Kšœ
žœ˜(Kšœžœžœ˜K˜FK˜LKš
œ˜Kš
œO˜Oš
œ’
˜’
Kšœžœžœžœ˜2Kš
œ˜Kšœžœ˜Kš
œ"˜"Kš
œ˜K˜—Kšžœ˜K˜K˜K˜
—…—=β[c