DIRECTORY
CD,
CDBasics,
CDCallSpecific, 
CDDirectory,
CDDirectoryOps,
CDEvents,
CDGenerate,
CDRemote,
CDImports,
CDImportsExtras,
CDInstances,
CDIO,
CDOps,
CDOrient,
CDProperties,
CDValue,
Rope,
TerminalIO,
TokenIO;

CDImportsImpl: CEDAR PROGRAM 
IMPORTS CD, CDBasics, CDDirectory, CDDirectoryOps, CDEvents, CDGenerate, CDRemote, CDInstances, CDIO, CDOps, CDOrient, CDProperties, CDValue, Rope, TerminalIO, TokenIO
EXPORTS CDImports, CDImportsExtras
SHARES CDDirectory, CDRemote =
BEGIN

BoolOrInteractive: TYPE = CDImports.BoolOrInteractive;
ImportPtr: TYPE = CDImports.ImportPtr;
ImportRep: TYPE = CDImports.ImportRep;
ImportList: TYPE = CDImports.ImportList;
ImportDesign: TYPE = CDImports.ImportDesign;
ObList: TYPE = LIST OF CD.Object;
ROPE: TYPE = Rope.ROPE;
ImpList: TYPE = LIST OF REF ImportDesign;

importListKey: ATOM = $ImportList; -- for CDValue

importsClass: PUBLIC CD.ObjectClass = CD.RegisterObjectClass[$Import, [
drawMe: DrawForImport,
quickDrawMe: QuickDrawReference,
showMeSelected: DrawSelectionForImport,
internalRead: ReadImportOb,
internalWrite: WriteImportOb,
describe: DescribeImport,
interestRect: InterestRect
]];

ImpPrivate: TYPE = RECORD [
d: CD.Design_NIL,
obList: ObList_NIL
];

EnumerateItsObjects: PROC [me: CD.Object, p: CDDirectory.EnumerateObjectsProc, x: REF] = 
BEGIN
END;

ReplaceDirectChild:  CDDirectory.ReplaceDChildsProc =
BEGIN
END;

InternalCreateImport: PROC [into: CD.Design, 
size: CD.Position_[1, 1], ir: CD.Rect _ [0, 0, -1, -1],
objectName, importeeName: ROPE, 
autoLoad: BOOL _ FALSE,  --loads file if neccessary; if loaded, import design is made 
autoImport: BOOL _ FALSE,  --import design even if not loaded successfully
autoCreateOb: BOOL _ FALSE,  --creates ob if not found or design not loaded (but not if import not made) 
allowConflicts: BoolOrInteractive_false,  --allow size conflicts on the object
include: BOOL _ TRUE] 
RETURNS [ob: CD.Object _ NIL] =
BEGIN
referedOb: CD.Object _ NIL; iR: CD.Rect; 
import: REF ImportDesign; impPriv: REF ImpPrivate;
probablySize: CD.Position _ CDBasics.MaxPoint[size, [1, 1]];

import  _ GetImportEntry[into, importeeName, false];
IF (import=NIL OR ~import.loaded) AND autoLoad THEN {
loaded: BOOL _ Load[into: into, importeeName: importeeName, overload: false, allowConflicts: false];
};
IF import=NIL AND autoImport THEN import _ GetImportEntry[into, importeeName, true];
IF import=NIL THEN RETURN [NIL];

IF CDBasics.NonEmpty[ir] THEN iR _ ir ELSE iR _ CDBasics.RectAt[[0, 0], probablySize]; 
impPriv _ NARROW[import.reservedForCDImports];
FOR list: ObList _ impPriv.obList, list.rest WHILE list#NIL DO
iPtr: ImportPtr _ NARROW[list.first.specificRef, ImportPtr];
IF Rope.Equal[iPtr.objectName, objectName] AND Rope.Equal[iPtr.designName, importeeName] THEN {
IF list.first.size=size AND (CD.InterestRect[list.first]=iR OR ~CDBasics.NonEmpty[ir]) THEN RETURN [list.first];
IF allowConflicts=true THEN RETURN [list.first];
IF allowConflicts=interactive AND TerminalIO.Confirm[choice: "ignore", label: "size conflicts"] THEN RETURN [list.first];
RETURN [NIL]
};
ENDLOOP;
IF import.loaded THEN referedOb _ CDDirectory.Fetch[impPriv.d, objectName].object;
IF referedOb=NIL AND ~autoCreateOb THEN RETURN [NIL];
IF allowConflicts=true AND referedOb#NIL THEN {
probablySize _ referedOb.size; iR _ CD.InterestRect[referedOb];
};
ob _ NEW[CD.ObjectRep_[
size: probablySize,
class: importsClass,
layer: CD.undefLayer,
specificRef: NEW[ImportRep _ [
objectName: objectName, 
ir: iR,
designName: importeeName 
]]
]];
impPriv.obList _ CONS[ob, impPriv.obList];
IF include THEN [] _ CDDirectory.Include[design: into, object: ob, alternateName: Rope.Cat[importeeName, ".", objectName]];
IF import.loaded THEN [] _ BindReference[into, ob, impPriv.d, allowConflicts];
END;

CreateImport: PUBLIC PROC [into: CD.Design, objectName, importeeName: ROPE] RETURNS [ob: CD.Object] =
BEGIN
ob _ InternalCreateImport[into: into, objectName: objectName, importeeName: importeeName, autoCreateOb: FALSE, autoImport: FALSE, autoLoad: TRUE, allowConflicts: true, include: TRUE];
END;
 
ShortName: PROC [me: CD.Object, iPtr: ImportPtr] RETURNS [n: ROPE] = INLINE
BEGIN
n _ CDDirectory.Name[me];
IF Rope.IsEmpty[n] THEN n _ iPtr.objectName;
END;

DescribeImport: PROC[me: CD.Object] RETURNS [ROPE] = 
BEGIN
iPtr: ImportPtr = NARROW[me.specificRef];
RETURN [Rope.Cat["reference to ", iPtr.designName, ".", iPtr.objectName]];
END;

DrawForImport: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
iPtr: ImportPtr = NARROW[inst.ob.specificRef];
IF iPtr.boundInstance#NIL THEN {
pr.drawChild[iPtr.boundInstance, pos, orient, pr];
}
ELSE {
r: CD.Rect = MappedInterestRect[inst.ob, pos, orient];
pr.drawRect[r, CD.shadeLayer, pr];
pr.drawComment[r, ShortName[inst.ob, iPtr], pr];
}
END; 

MappedInterestRect: PROC [ob: CD.Object, pos: CD.Position, orient: CD.Orientation] RETURNS [CD.Rect] = INLINE
BEGIN
RETURN [CDOrient.MapRect[
itemInCell: CD.InterestRect[ob],
cellSize: ob.size,
cellInstOrient: orient,
cellInstPos: pos
]]
END;

QuickDrawReference: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
iPtr: ImportPtr = NARROW[inst.ob.specificRef];
IF iPtr.boundInstance#NIL THEN {
iPtr.boundInstance.ob.class.quickDrawMe[iPtr.boundInstance, pos, orient, pr];
}
ELSE {
r: CD.Rect = MappedInterestRect[inst.ob, pos, orient];
pr.drawRect[r, CD.shadeLayer, pr];
pr.drawComment[r, ShortName[inst.ob, iPtr], pr];
}
END; 

DrawSelectionForImport: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
iPtr: ImportPtr = NARROW[inst.ob.specificRef];
IF iPtr.boundInstance#NIL THEN 
iPtr.boundInstance.ob.class.showMeSelected[iPtr.boundInstance, pos, orient, pr]
ELSE 
pr.drawOutLine[MappedInterestRect[inst.ob, pos, orient], CD.selectionLayer, pr]
END; 

InterestRect: PROC [ob: CD.Object] RETURNS [CD.Rect] =
BEGIN
RETURN [NARROW[ob.specificRef, ImportPtr].ir]
END;

WriteImportOb: CD.InternalWriteProc -- PROC [me: Object] -- =
BEGIN
iPtr: ImportPtr = NARROW[me.specificRef];
CDIO.WritePos[me.size];
CDIO.WriteRect[iPtr.ir];
TokenIO.WriteRope[iPtr.objectName];
TokenIO.WriteRope[iPtr.designName];
END;

ReadImportOb: CD.InternalReadProc --PROC [] RETURNS [Object]-- =
BEGIN
sz: CD.Position = CDIO.ReadPos[];
ir: CD.Rect;
objectName: ROPE;
importeeName: ROPE;
ob: CD.Object;
IF CDIO.VersionKey[] >= 8 THEN ir _ CDIO.ReadRect[] 
ELSE ir _ CDBasics.RectAt[[0, 0], sz];
objectName _ TokenIO.ReadRope[];
importeeName _ TokenIO.ReadRope[];
ob _ InternalCreateImport[
into: CDIO.DesignInReadOperation[], 
ir: ir, size: sz, 
objectName: objectName, importeeName: importeeName,
autoCreateOb: TRUE,
autoImport: TRUE,
autoLoad: FALSE,
allowConflicts: interactive,
include: FALSE 
];
RETURN [ob]
END;

GetImportList: PUBLIC PROC [design: CD.Design] RETURNS [imp: REF ImportList] =
BEGIN
WITH CDValue.Fetch[boundTo: design, key: importListKey, propagation: design] SELECT FROM
imp: REF ImportList => RETURN[imp];
ENDCASE => {
imp _ NEW[ImportList _ [list: NIL]];
[] _ CDValue.StoreConditional[boundTo: design, key: importListKey, value: imp];
RETURN [GetImportList[design]]
};
END;

GetImportEntry: PUBLIC PROC [into: CD.Design, importeeName: ROPE_NIL, createIfNotFound: BoolOrInteractive _ true] RETURNS [REF ImportDesign_NIL] =
BEGIN

ToBool: PROC[b: BoolOrInteractive, r: ROPE, r2: ROPE_NIL] RETURNS [BOOL] =
BEGIN
SELECT b FROM
true => RETURN [TRUE];
false => RETURN [FALSE];
ENDCASE => {
TerminalIO.WriteRopes[r, r2];
RETURN [TerminalIO.Confirm[r]]
}
END;

mdata: REF ImportDesign _ NIL; 
impl: REF ImportList = GetImportList[into];
IF Rope.IsEmpty[importeeName] THEN 
ERROR CD.Error[ec: other, explanation: "design has empty name, but shouldn't"];
IF impl#NIL THEN
FOR l: ImpList _ impl.list, l.rest WHILE l#NIL DO
IF l.first#NIL AND Rope.Equal[l.first.importeeName, importeeName] THEN RETURN [l.first]
ENDLOOP;
IF ToBool[createIfNotFound, "create an import", importeeName] THEN {
pData: REF ImpPrivate _ NEW[ImpPrivate];
mdata _ NEW[ImportDesign _ [importeeName: importeeName, loaded: FALSE, reservedForCDImports: pData]];
IF Rope.Equal[into.name, importeeName] THEN
ERROR CD.Error[ec: other, explanation: "circular import"];
impl.list _ CONS[mdata, impl.list];  --should be atomic--
};
RETURN [mdata]
END;

BindImportee: PROC [importer, importee: CD.Design, 
allowSizeConflicts, overload: BoolOrInteractive _ true] =
BEGIN
ENABLE TerminalIO.UserAbort => GOTO UserAborted;
done1: BOOL_TRUE;
impPriv: REF ImpPrivate; mdata: REF ImportDesign;
IF importer=importee OR Rope.Equal[importer.name, importee.name] THEN ERROR;
mdata _ GetImportEntry[importer, importee.name, true];
IF mdata=NIL THEN ERROR;
impPriv _ NARROW[mdata.reservedForCDImports];
IF mdata.loaded THEN {
IF overload=false THEN RETURN
ELSE IF overload=interactive THEN
IF NOT TerminalIO.Confirm[label: "design already loaded", choice: "overload"] THEN {
TerminalIO.WriteRope["dont overload; not done\n"];
RETURN 
}
};
impPriv.d _ importee;
mdata.loaded _ TRUE;
FOR list: ObList _ impPriv.obList, list.rest WHILE list#NIL DO
done1 _ done1 AND BindReference[importer, list.first, importee, allowSizeConflicts].ok
ENDLOOP;
IF NOT done1 THEN TerminalIO.WriteRope["some import not bound\n"];
CDOps.DelayedRedraw[importer]; 
EXITS
UserAborted => {TerminalIO.WriteRope["aborted, design not bound\n"]};
END;

BindReference: PROC [design: CD.Design, reference: CD.Object, importee: CD.Design, allowSizeConflicts: BoolOrInteractive _ true] RETURNS [ok: BOOL_FALSE] =
BEGIN
ENABLE TerminalIO.UserAbort => GOTO UserAborted;
iPtr: ImportPtr = NARROW[reference.specificRef, ImportPtr];
oldRect, newRect: CD.Rect;
referedOb: CD.Object _ CDDirectory.Fetch[importee, iPtr.objectName].object;
IF referedOb=NIL THEN {
TerminalIO.WriteRopes["entry ", iPtr.objectName];
TerminalIO.WriteRopes[" in ", importee.name, " not found\n"];
RETURN
};
oldRect _ InterestRect[reference];
newRect _ CD.InterestRect[referedOb];
IF newRect#oldRect THEN {
TerminalIO.WriteRopes["object ", iPtr.objectName, " has different size; "];
IF CDBasics.SizeOfRect[oldRect]=CDBasics.SizeOfRect[newRect] THEN 
TerminalIO.WriteRope[" has different outer size; "]
ELSE 
TerminalIO.WriteRope[" has different interest size; "];
IF allowSizeConflicts=false THEN {
TerminalIO.WriteRope["not resolved\n"];
RETURN
};
IF allowSizeConflicts=interactive THEN {
IF ~TerminalIO.Confirm[choice: "import anyway", label: "size conflict"] THEN {
TerminalIO.WriteRope["no\n"];
RETURN
};
TerminalIO.WriteRope["yes\n"];
};
};
iPtr.boundInstance _ CDInstances.NewInst[ob: referedOb];
BEGIN
oldSize: CD.Position = reference.size;
oldBase: CD.Position = CDBasics.BaseOfRect[oldRect];
newSize: CD.Position = referedOb.size;
newBase: CD.Position = CDBasics.BaseOfRect[newRect];
IF oldSize#newSize OR oldRect#newRect THEN {
reference.size _ newSize;
iPtr.ir _ newRect;
CDDirectory.RepositionObject[design: design,
ob: reference, 
oldSize: oldSize, 
baseOff: CDBasics.SubPoints[oldBase, newBase]
];
};
END;
CDDirectory.PropagateChange[reference, design];
ok _ TRUE;
EXITS
UserAborted => {TerminalIO.WriteRope["aborted, entry not replaced\n"]};
END;

GetImportee: PROC [into: CD.Design, importeeName: ROPE] RETURNS [d: CD.Design_NIL] =
BEGIN
ENABLE CDRemote.ioFailed => GOTO thatsit;
d _ CDRemote.FetchDesign[into, importeeName];
IF d=NIL THEN {
[] _ CDRemote.GetTableUsingFile[for: into, remoteDesign: importeeName];
d _ CDRemote.FetchDesign[into, importeeName];
}
EXITS thatsit => NULL;
END;

Load: PUBLIC PROC [into: CD.Design, importeeName: ROPE,
overload, allowConflicts: BoolOrInteractive_true] RETURNS [done: BOOL_FALSE] = 
BEGIN
indirectImport: REF ImportList;
importee: CD.Design _ GetImportee[into, importeeName];
IF importee=NIL THEN {
TerminalIO.WriteRope["load not done\n"];
RETURN
};
indirectImport _ GetImportList[importee]; 
IF indirectImport^.list#NIL THEN TerminalIO.WriteRope["There are indirect imports\n"];
FOR list: ImpList _ indirectImport^, list.rest WHILE list#NIL DO
IF Rope.Equal[list.first.importeeName, into.name] THEN {
TerminalIO.WriteRope["**creates circular imports\n"];
RETURN
}
ENDLOOP; 
BindImportee[importer: into, importee: importee, allowSizeConflicts: allowConflicts, overload: overload];
FOR list: ImpList _ GetImportList[into]^, list.rest WHILE list#NIL DO
ip: REF ImpPrivate = NARROW[list.first.reservedForCDImports];
IF ip.d#NIL AND ip.d#importee THEN
BindImportee[importer: ip.d, importee: importee, allowSizeConflicts: false, overload: true];
ENDLOOP; 
FOR list: ImpList _ indirectImport^, list.rest WHILE list#NIL DO
ip: REF ImpPrivate = NARROW[list.first.reservedForCDImports];
IF ip.d=NIL THEN {--new design did not load..
imp: REF ImportDesign _ GetImportEntry[into, list.first.importeeName, false];
IF imp#NIL THEN {
oldip: REF ImpPrivate = NARROW[imp.reservedForCDImports];
IF oldip.d#NIL AND oldip.d#importee THEN
BindImportee[importer: importee, importee: oldip.d, allowSizeConflicts: false, overload: true];
};
}
ENDLOOP; 
done _ TRUE;
END;   

DesignHasBeenRenamed: CDEvents.EventProc 
--PROC [event: REF, design: CD.Design, x: REF] RETURNS [dont: BOOL_FALSE]-- =
BEGIN
imp: REF ImportDesign = GetImportEntry[into: design, importeeName: design.name, createIfNotFound: false];
IF imp#NIL THEN {
dont _ TRUE;
TerminalIO.WriteRope["rename causes circularities; not done\n"]
};
END;   

OneLevelIncludedCopy: PUBLIC PROC [impObject: CD.Object, design: CD.Design] RETURNS [CD.Object] =
BEGIN

ReplaceChildrenByImports: PROC[me: CD.Object, design: CD.Design, importeeName: ROPE] =
BEGIN
replaceList: CDDirectory.ReplaceList_NIL;

PerChild: CDDirectory.EnumerateObjectsProc --PROC [me: CD.Object, x: REF] -- =
BEGIN
IF me.class.inDirectory THEN { 
impChild: CD.Object;
FOR list: CDDirectory.ReplaceList _ replaceList, list.rest WHILE list#NIL DO
IF list.first.old=me THEN RETURN -- eliminate duplicates
ENDLOOP; 
impChild _ InternalCreateImport[
into: design, objectName: CDDirectory.Name[me], importeeName: importeeName,
size: me.size, 
autoImport: TRUE, autoLoad: FALSE, 
autoCreateOb: TRUE, allowConflicts: true, 
include: TRUE
];
replaceList _ CONS[
NEW[CDDirectory.ReplaceRec_[
old: me, 
oldSize: me.size, 
new: impChild, 
newSize: impChild.size, 
off: [0, 0]
]], 
replaceList
];
}
END;
CDDirectory.EnumerateChildObjects[me: me, p: PerChild, x: NIL];
IF replaceList#NIL THEN 
[] _ CDDirectory.ReplaceDirectChild[me: me, design: design, replace: replaceList];
END; --ReplaceChildrenByImports
WITH impObject.specificRef SELECT FROM
impPtr: ImportPtr => {
newOb: CD.Object; tm, cm: CDDirectory.DMode;
import: REF ImportDesign = GetImportEntry[design, impPtr.designName, false];
ip: REF ImpPrivate;
IF impPtr.boundInstance=NIL OR import=NIL OR ~import.loaded THEN 
ERROR CD.Error[callingError, "OneLevelIncludedCopy impObject not bound "];
ip _ NARROW[import.reservedForCDImports];
[newOb, tm, cm] _ CDDirectory.Another[me: impPtr.boundInstance.ob, fromOrNil: ip.d, into: design];
IF newOb=NIL OR tm=immutable THEN ERROR;
IF tm=ready THEN [] _ CDDirectory.Include[design, newOb];
IF cm=immutable THEN
ReplaceChildrenByImports[me: newOb, design: design, importeeName: import.importeeName];
RETURN [newOb]
};
ENDCASE => ERROR CD.Error[callingError, "OneLevelIncludedCopy impObject not reference"]
END; --OneLevelIncludedCopy

Another: PROC [me: CD.Object, fromOrNil: CD.Design, into: CD.Design, friendly: BOOL] RETURNS [new: CD.Object, topMode: CDDirectory.InclOrReady_included, childMode: CDDirectory.ImmOrIncl_included] =
BEGIN
impPtr: ImportPtr = NARROW[me.specificRef]; own: REF;
IF into=NIL THEN ERROR;
new _ InternalCreateImport[into: into, objectName: impPtr.objectName, importeeName: impPtr.designName, autoCreateOb: TRUE, autoImport: TRUE, allowConflicts: true, include: TRUE, size: me.size, autoLoad: FALSE];
IF new=NIL THEN ERROR;
own _ CDProperties.GetObjectProp[new, $OwnerDesign];
CDProperties.AppendProps[looser: me.properties, winner: new.properties, putOnto: new];
CDProperties.PutObjectProp[new, $OwnerDesign, own];
END;

Expand: PROC [me: CD.Object, fromOrNil: CD.Design, into: CD.Design, friendly: BOOL] RETURNS [new: CD.Object, topMode: CDDirectory.DMode_immutable, childMode: CDDirectory.ImmOrIncl_immutable] =
BEGIN
impPtr: ImportPtr = NARROW[me.specificRef];
IF impPtr.boundInstance=NIL THEN RETURN [NIL]; --can not expand unloaded object
IF into#NIL --AND friendly-- THEN {
tm, cm: CDDirectory.DMode;
[me, tm, cm] _ CDDirectory.Another[me: me, fromOrNil: fromOrNil, into: into];
IF me#NIL AND tm=included THEN { 
new _ OneLevelIncludedCopy[impObject: me, design: into];
IF new#NIL THEN RETURN [new, included, included];
}
};
RETURN [impPtr.boundInstance.ob, immutable, immutable];
END;

MergeInImports: PUBLIC PROC [into: CD.Design, importeeName: ROPE] =
BEGIN
imp: REF ImportDesign _ GetImportEntry[into, importeeName, false];
IF imp=NIL THEN {
TerminalIO.WriteRopes["MergeInImports not done; design ", importeeName, " is not imported\n"];
RETURN
}
ELSE IF ~imp.loaded THEN {
TerminalIO.WriteRopes["MerginImport not done; design ", importeeName, " is not loaded\n"];
RETURN
}
ELSE {
impPrivate: REF ImpPrivate = NARROW[imp.reservedForCDImports];
generatorTable: CDGenerate.Table;
importee: CD.Design _ impPrivate.d; 
objectList: ObList _ NIL;
doList: ObList _ NIL;
dontList: ObList _ NIL;
CDRemote.CacheDesign[for: into, remote: importee];
generatorTable _ CDRemote.GetTable[imp.importeeName];
FOR list: ObList _ impPrivate.obList, list.rest WHILE list#NIL DO
IF NARROW[list.first.specificRef, ImportPtr].boundInstance#NIL THEN 
doList _ CONS[list.first, doList]
ELSE dontList _ CONS[list.first, dontList];
ENDLOOP;
FOR list: ObList _ doList, list.rest WHILE list#NIL DO
pr: ImportPtr = NARROW[list.first.specificRef];
newOb: CD.Object _ CDGenerate.FetchNCall[table: generatorTable, design: into, key: pr.objectName, cache: TRUE];
IF newOb#NIL THEN {
CDDirectory.ReplaceObject[design: into, old: list.first, new: newOb];
IF CDDirectoryOps.RemoveIfUnused[design: into, ob: list.first].done THEN {
[] _ CDDirectory.Rename[into, newOb, pr.objectName];
};
}
ELSE dontList _ CONS[list.first, dontList];
ENDLOOP;
impPrivate.obList _ dontList;
}
END;   

HasUnloadedImports: PUBLIC PROC [design: CD.Design] RETURNS [yes: BOOL_FALSE] =
BEGIN
impList: REF CDImports.ImportList = GetImportList[design];
IF impList#NIL THEN
FOR list: LIST OF REF CDImports.ImportDesign _ impList^, list.rest WHILE list#NIL DO
IF ~list.first.loaded THEN {
RETURN [yes _ TRUE]
}
ELSE {
p: REF ImpPrivate _ NARROW[list.first.reservedForCDImports];
FOR obl: ObList _ p.obList, obl.rest WHILE obl#NIL DO
ip: ImportPtr = NARROW[obl.first.specificRef];
IF ip.boundInstance=NIL THEN RETURN [yes _ TRUE];
ENDLOOP;
yes _ p.d#NIL AND HasUnloadedImports[p.d];
}
ENDLOOP;
END;

Init: PROC [] = 
BEGIN
dirProcs: REF CDDirectory.DirectoryProcs = CDDirectory.InstallDirectoryProcs[importsClass, [
enumerateChildObjects: EnumerateItsObjects,
replaceDirectChilds: ReplaceDirectChild,
another: Another,
expand: Expand
]];
CDValue.RegisterKey[importListKey];
CDEvents.RegisterEventProc[$RenameDesign, DesignHasBeenRenamed];
END; 

Init[];
END. 

öCDImportsImpl.mesa   (part of ChipNDale)
Copyright c 1984, 1986 by Xerox Corporation.  All rights reserved.
by Christian Jacobi, March 20, 1984 5:50:51 pm PST 
last edited Christian Jacobi, March 28, 1986 6:41:45 pm PST
dont !!! 
the imported objects are not part of this design
-- PROC[me: CD.Object, design: CD.Design, replace: LIST OF REF ReplaceRec] --
dont, don't ERROR:  
don't ERROR, because the client doese not know that imports cannot be changed
--make an import of the importee design 
--search for an already existing import object 

--already existing imported object not found; make new object
--if not load, trust for the size... it is checked at binding time
-- check for forbidden circular import
-- now we certainly have no circular import
--
-- do the actual import
--check all already imported designs for importing the new design
--check the new design for importing of already imported and loaded designs
-- prevent a renaming which would cause circularity
--imp is an imported and bound object which will be made local to design

--build list of direct children
--replace each direct child by an import

--OneLevelIncludedCopy
--Includes all the imported and bound objects from importeeName (including  
--their transitive closure; but not indirect imports) into design.
--split the reference list in bounded and not bounded
--make includes for all bounded references  
--a directly imported design is not loaded
--check all objects of this design
--check for indirect objects; there are no loops
�ʤ˜
codeš
œ(™(Kšœ
Ïm
œ7™BKš
œ3™3Kš
œ;™;K˜—š
Ïk	˜	Kšžœ
˜Kš
œ	˜	K˜K˜K˜K˜	Kš
œ˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜K˜Kšžœ
˜Kš
œ˜Kš
œ	˜	K˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šÐbl
œžœ
žœ
˜Kšžœ
žœVžœC˜§
Kšžœ˜"Kšžœ˜—Kš
ž˜K˜Kšœžœ˜6Kšœžœ˜&Kšœžœ˜&Kšœžœ˜(Kšœžœ˜,Kš	œžœžœ
žœ
žœ˜!Kšžœžœžœ
˜Kš	œ	žœžœ
žœ
žœ˜)K˜KšœžœÏc˜1K˜šœž	œžœ˜GKš
œ˜Kš
œ ˜ Kš
œ'˜'Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šœžœžœ˜Kšœžœžœ
˜Kšœž˜K˜—K˜šÏnœžœžœ1žœ˜YKš
ž˜š
œ	™	J™0—Kšžœ
˜—K˜šÏbœ#˜5Kš
œM™MKš
ž˜š
œ™Kš
œM™M—Kšžœ
˜—K˜š¡œžœžœ	˜-Kšœžœžœ˜7Kšœžœ˜ Kšœ
žœžœ =˜VKšœžœžœ /˜JKšœžœžœ L˜iKšœ* $˜Nšœ	žœ
žœ˜Kšžœžœ
žœ˜—Kš
ž˜Kšœžœ
žœžœ˜)Kšœžœžœ˜2Kšœžœ,˜<K˜Kš
œ(™(Kš
œ4˜4š
žœ	žœ
žœžœ
žœ˜5KšœžœX˜dK˜—Kšžœžœ
žœžœ3˜TKš
žœžœ
žœ
žœžœ˜ K˜Kš
œ/™/Kšžœžœ	žœ-˜WKšœ
žœ˜.šžœ*žœžœ
ž˜>Kšœžœ$˜<šžœ)žœ+žœ˜_Kšžœžœžœžœžœ
žœ˜pKšžœžœ
žœ˜0Kšžœžœ?žœ
žœ˜yKšžœžœ
˜Kš
œ˜—Kšžœ
˜—K™Kš
œ=™=Kš
œB™BKšžœžœ=˜RKšžœžœ
žœžœ
žœžœ˜5šžœžœ	ž
œ
˜/Kšœ$žœ˜?Kš
œ˜—šœžœ
žœ˜Kš
œ˜Kš
œ˜Kšœž
œ
˜šœ
žœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜—Kšœžœ˜*Kšžœ	žœl˜{Kšžœžœ9˜NKšžœ
˜—K˜š¡œžœ
žœžœ#žœžœžœ
˜eKš
ž˜Kš	œhžœžœžœ!žœ˜·
Kšžœ
˜—Kš
œ
˜
š¡	œžœžœžœžœž˜KKš
ž˜Kš
œ˜Kšžœžœ˜,Kšžœ
˜—K˜š
¡œžœžœ	žœžœ˜5Kš
ž˜Kšœžœ˜)KšžœD˜JKšžœ
˜—K˜š
¡
œžœžœžœžœ
˜QKšœžœ˜Kš
ž˜Kšœžœ˜.šžœžœ
žœ˜ Kš
œ2˜2K˜
—šžœ˜Kšœžœ1˜6Kšœžœ˜"Kš
œ0˜0K˜
—Kšžœ˜K˜—š¡œžœžœžœžœžœžœ	ž˜mKš
ž˜šžœ˜Kšœžœ˜ Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kšžœ
˜K˜—š
¡œžœžœžœžœ
˜VKšœžœ˜Kš
ž˜Kšœžœ˜.šžœžœ
žœ˜ Kš
œM˜MK˜
—šžœ˜Kšœžœ1˜6Kšœžœ˜"Kš
œ0˜0K˜
—Kšžœ˜K˜—š
¡œžœžœžœžœ
˜ZKšœžœ˜Kš
ž˜Kšœžœ˜.šžœžœ
žœ
˜Kš
œO˜O—šžœ
˜Kšœ9žœ˜O—Kšžœ˜—K˜š
¡œžœžœ	žœžœ˜6Kš
ž˜Kšžœžœ˜-Kšžœ
˜K˜—š¢
œžœ œ˜=Kš
ž˜Kšœžœ˜)Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ#˜#Kšžœ
˜—K˜š¢œžœ œ˜@Kš
ž˜Kš
œ!˜!Kšœžœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜Kšžœ
žœžœ˜4Kšžœ"˜&Kš
œ ˜ Kš
œ"˜"š
œ˜Kšœžœ˜$Kš
œ˜Kš
œ3˜3Kšœžœ
˜Kšœžœ
˜Kšœ
žœ
˜Kš
œ˜Kšœ	žœ
˜Kš
œ˜—Kšžœ˜Kšžœ
˜—K˜š¡
œžœ
žœ
žœ	žœžœ˜NKš
ž˜šžœIžœ
ž˜XKšœžœžœ˜#šžœ˜Kšœžœžœ˜$Kš
œO˜OKšžœ˜K˜——Kšžœ
˜—K˜š¡œžœ
žœžœžœ
žœ.žœžœžœ˜’
Kš
ž˜K˜š¡œžœžœžœ
žœžœžœ˜JKš
ž˜šžœž˜
Kšœžœžœ˜Kšœ	žœžœ˜šžœ˜Kš
œ˜Kšžœ˜K˜
——Kšžœ
˜—K˜Kšœžœžœ˜Kšœžœ"˜+šžœžœ
˜#Kšžœ
žœG˜O—šžœžœ
ž˜šžœ žœžœ
ž˜1Kš
žœ	žœ
žœ0žœ
žœ
˜WKšžœ
˜——šžœ<žœ˜DKšœžœžœ
˜(Kšœžœ5žœ ˜ešžœ%ž˜+Kšžœ
žœ2˜:—Kšœžœ ˜9K˜—Kšžœ˜Kšžœ
˜—K˜š¡œžœžœ	˜3Kš
œ9˜9š
ž˜Kšžœžœ
˜0—Kšœžœ
žœ
˜Kšœ	žœžœ˜1Kšžœžœ*žœ
žœ
˜LKš
œ6˜6Kšžœžœ
žœ
žœ
˜Kšœ
žœ˜-šžœžœ˜Kšžœžœ
ž˜šžœ
žœž˜!šžœ
žœHžœ˜TKš
œ2˜2Kšžœ
˜K˜
——K˜—Kš
œ˜Kšœžœ
˜šžœ*žœžœ
ž˜>KšœžœE˜VKšžœ
˜—Kšžœ
žœžœ1˜BKš
œ˜š
ž˜Kš
œE˜E—Kšžœ
˜—K˜š¡
œžœ
žœžœžœ7žœžœ
žœ˜›
š
ž˜Kšžœžœ
˜0—Kšœžœ#˜;Kšœžœ˜Kšœžœ>˜Kšžœžœ
žœ˜Kš
œ1˜1Kš
œ=˜=Kš
ž˜K˜—Kš
œ"˜"Kšœ
žœ˜%šžœžœ˜Kš
œK˜Kšžœ;žœ
˜BKš
œ3˜3—šžœ
˜Kš
œ7˜7—šžœžœ˜"Kš
œ'˜'Kš
ž˜K˜—šžœ žœ˜(šžœFžœ˜NKš
œ˜Kš
ž˜Kš
œ˜—Kš
œ˜Kš
œ˜—K˜—Kš
œ8˜8š
ž˜Kšœ	žœ˜&Kšœ	žœ)˜4Kšœ	žœ˜&Kšœ	žœ)˜4šžœžœžœ˜,Kš
œ˜Kš
œ˜š
œ,˜,Kš
œ˜Kš
œ˜Kš
œ-˜-Kš
œ˜—K˜—Kšžœ
˜—Kš
œ/˜/Kšœžœ
˜
š
ž˜Kš
œG˜G—Kšžœ
˜—K˜š¡œžœžœžœžœžœžœ˜TKš
ž˜Kšžœžœ	˜)Kš
œ-˜-šžœžœ
žœ˜Kš
œG˜GKš
œ-˜-K˜
—Kšžœžœ
˜Kšžœ
˜—K˜š
Ðbnœžœ
žœžœžœ
˜7Kšœ2žœžœ
žœ˜OKš
ž˜Kšœžœ˜Kšœ
žœ*˜6šžœ
žœ
žœ˜Kš
œ(˜(Kš
ž˜Kš
œ˜—Kš
œ*˜*Kšžœžœ
žœ6˜VKš
œ&™&šžœ,žœžœ
ž˜@šžœ0žœ˜8Kš
œ5˜5Kš
ž˜Kš
œ
˜
—Kšžœ˜	—Kš
œ+™+Kš
œ™Kš
œ™Kš
œi˜iKš
œA™Ašžœ1žœžœ
ž˜EKšœžœžœ"˜=šžœžœ
žœž˜"Kš
œ\˜\—Kšžœ˜	—Kš
œK™Kšžœ,žœžœ
ž˜@Kšœžœžœ"˜=šžœžœ
žœ ˜-KšœžœE˜Mšžœžœ
žœ˜Kšœžœžœ˜9šžœ	žœ
žœž˜(Kš
œ_˜_—K˜—K˜
—Kšžœ˜	—Kšœžœ
˜Kšžœ˜—K˜š¢œ˜)Kš žœ	žœ
žœžœžœžœ
žœ
 œ˜MKš
œ3™3Kš
ž˜Kšœžœa˜išžœžœ
žœ˜Kšœžœ
˜Kš
œ?˜?K˜—Kšžœ˜—K˜š¡œžœ
žœ
žœžœ	žœžœ
˜aKš
œH™HKš
ž˜K˜š
¡œžœžœžœžœ˜VKš
ž˜Kšœ%žœ
˜)K˜š¢œ# !œ˜NKš
ž˜šžœžœ˜Kšœ
žœ˜šžœ8žœžœ
ž˜LKšžœžœ
ž ˜8Kšžœ˜	—š
œ ˜ Kš
œK˜KKš
œ˜Kšœžœžœ˜#Kšœžœ˜*Kšœ	ž˜
Kš
œ˜—šœžœ
˜šžœ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜—K˜
—Kšžœ
˜—K™Kš
œ™Kšœ:žœ˜?Kš
œ(™(šžœ
žœ
žœ
˜Kš
œR˜R—Kšžœ ˜—K™Kš
œ™šžœžœ
ž˜&š
œ˜Kšœžœ#˜,KšœžœA˜LKšœžœ˜šžœžœ
žœžœ
žœžœ
˜AKšžœ
žœB˜J—Kšœžœ˜)Kš
œb˜bKš
žœžœ
žœžœ
žœ
˜(Kšžœ
žœ)˜9šžœž˜Kš
œW˜W—Kšžœ˜K˜—Kšžœžœ
žœD˜W—Kšžœ ˜—K˜š¡œžœžœžœžœžœžœžœ`˜Å
Kš
ž˜Kšœžœ˜5Kšžœžœ
žœ
žœ
˜Kš	œužœžœ!žœžœ˜Ò
Kšžœžœ
žœ
žœ
˜Kš
œ4˜4Kš
œV˜VKš
œ3˜3Kšžœ
˜—K˜š¡œžœžœžœžœžœžœžœ\˜À
Kš
ž˜Kšœžœ˜+Kšžœžœ
žœ
žœžœ  ˜Ošžœžœ
 œ
žœ˜#Kš
œ˜Kš
œM˜Mšžœžœ
žœ
žœ˜!Kš
œ8˜8Kšžœžœ
žœ
žœ˜1K˜
—K˜—Kšžœ1˜7Kšžœ
˜—K˜š
¡œžœ
žœžœžœ˜CKš
œL™LKš
œB™BKš
ž˜Kšœžœ:˜Bšžœžœ
žœ˜Kš
œ^˜^Kš
ž˜K˜
—šžœ
žœ
žœ˜Kš
œZ˜ZKš
ž˜K˜
—šžœ˜Kšœžœžœ˜>Kš
œ!˜!Kšœ
žœ˜$Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ2˜2Kš
œ5˜5Kš
œ5™5šžœ-žœžœ
ž˜Ašžœ
žœ2žœ
žœ
˜DKšœ	žœ˜!—Kšžœžœ˜+Kšžœ
˜—Kš
œ,™,šžœ"žœžœ
ž˜6Kšœžœ˜/Kšœžœ`žœ˜ošžœžœ
žœ˜Kš
œE˜EšžœBžœ˜JKš
œ4˜4K˜—K˜
—Kšžœžœ˜+Kšžœ
˜—Kš
œ˜K˜
—Kšžœ˜—K˜š¡œžœ
žœ
žœ	žœžœ
žœ˜OKš
ž˜Kšœ	žœ.˜:šžœ	žœ
ž˜š
žœžœ
žœ
žœ.žœžœ
ž˜Tšžœžœ˜Kš
œ*™*Kšžœžœ
˜K˜
—šžœ˜Kš
œ"™"Kšœžœžœ"˜<šžœ"žœžœ
ž˜5Kšœžœ˜.Kš
žœžœ
žœ
žœžœ˜1Kšžœ
˜—Kš
œ0™0Kšœ
žœ
žœ˜*Kš
œ
˜
—Kšžœ
˜——Kšžœ
˜—K˜š¡œžœ˜Kš
ž˜šœ
žœO˜\Kš
œ+˜+Kš
œ(˜(Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ#˜#K˜@Kšžœ˜—K˜K˜Kšžœ˜K˜—…—JZhô