DIRECTORY
CD,
CDApplications,
CDCallSpecific, 
CDDirectory,
CDEvents,
CDExtras USING [MergeInObjects],
CDImports,
CDImportsExtras,
CDBasics,
CDIO,
CDOps,
CDOrient,
CDProperties,
CDValue,
Rope,
TerminalIO,
CDInterestRects,
TokenIO;

CDImportsImpl: CEDAR PROGRAM 
IMPORTS CD, CDApplications, CDDirectory, CDEvents, CDExtras, CDBasics, CDIO, CDOps, CDOrient, CDProperties, CDValue, Rope, TerminalIO, TokenIO, CDInterestRects
EXPORTS CDImports, CDImportsExtras
SHARES CDDirectory =
BEGIN


BoolOrInteractive: TYPE = CDImports.BoolOrInteractive;
ReferencePtr: TYPE = CDImports.ReferencePtr;
ReferenceRep: TYPE = CDImports.ReferenceRep;

ImportList: TYPE = CDImports.ImportList;
Import: TYPE = CDImports.Import;

importListKey: ATOM = $ImportList; -- for CDValue

pForReference: REF CD.ObjectProcs = CD.RegisterObjectType[$Import];

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

ReplaceDirectChild:  CDDirectory.ReplaceDChildsProc =
BEGIN
END;

InternalCreateReference: PROC [design: CD.Design, 
	size: CD.DesignPosition_[1, 1],  --ignored if allowConflicts
	ir: CD.DesignRect _ [0, 0, -1, -1],
	objectName, importeeName: Rope.ROPE, 
	autoImport: BoolOrInteractive_false,  --creates an import if not already done
	autoCreateOb: BoolOrInteractive_false,  --creates if not found but design available
	allowConflicts: BoolOrInteractive_false,  --allow size conflicts of the object
	include: BOOL_TRUE] RETURNS [CD.ObPtr] =
BEGIN
ob: CD.ObPtr;
rp: ReferencePtr;
import: REF Import = GetImport[design, importeeName, autoImport];
probablySize: CD.DesignPosition _ CDBasics.MaxPoint[size, [1, 1]];
iR: CD.DesignRect;
IF CDBasics.NonEmpty[ir] THEN iR _ ir ELSE iR _ CDBasics.RectAt[[0, 0], probablySize]; 
IF import=NIL THEN RETURN [NIL];
FOR list: LIST OF CD.ObPtr _ import.referenceList, list.rest WHILE list#NIL DO
ob _ list.first;
rp _ NARROW[ob.specificRef, ReferencePtr];
IF Rope.Equal[rp.objectName, objectName] 
AND Rope.Equal[rp.designName, importeeName] THEN {
IF ob.size=size OR allowConflicts=true THEN RETURN [ob]
ELSE IF allowConflicts=interactive AND TerminalIO.UserSaysYes[
text: "size conflict\n", 
label: "ignore?"
] THEN RETURN [ob] 
ELSE RETURN [NIL]
};
ENDLOOP;
IF import.importee#NIL THEN {
found: BOOL;
referedOb: CD.ObPtr;
[found, referedOb] _ CDDirectory.Fetch[import.importee, objectName];
IF ~found THEN {
IF autoCreateOb=false OR (autoCreateOb=interactive AND ~TerminalIO.UserSaysYes[
text: "object not found\n", 
label: "ignore?"
]) THEN RETURN [NIL];
}
ELSE {
IF allowConflicts=true THEN {
probablySize _ referedOb.size;
iR _ CD.InterestRect[referedOb];
};
}
};
ob _ NEW[CD.ObjectDefinition_[
size: probablySize,
p: pForReference,
layer: CD.combined,
specificRef: NEW[ReferenceRep _ [
objectName: objectName, 
ir: iR,
designName: importeeName 
]]
]];
import.referenceList _ CONS[ob, import.referenceList];
IF include THEN [] _ CDDirectory.Include[design: design, object: ob, alternateName: Rope.Cat[importeeName, ".", objectName]];
IF import.importee#NIL THEN [] _ BindReference[design, ob, import.importee, allowConflicts];
RETURN [ob]
END;

GetReference: PUBLIC PROC [design: CD.Design, objectName, importeeName: Rope.ROPE] RETURNS [ob: CD.ObPtr] =
BEGIN
ob _ InternalCreateReference[design: design, objectName: objectName, importeeName: importeeName, autoCreateOb: false, autoImport: false, allowConflicts: true, include: TRUE];
END;
 
ReferenceName: PROC [me: CD.ObPtr] RETURNS [Rope.ROPE] =
BEGIN
n: Rope.ROPE = CDDirectory.Name[me];
IF Rope.IsEmpty[n] THEN {
rp: ReferencePtr = NARROW[me.specificRef];
RETURN [Rope.Cat[rp.designName, ".", rp.objectName]]
};
RETURN [n]
END;

ShortName: PROC [me: CD.ObPtr, rp: ReferencePtr] RETURNS [Rope.ROPE] = INLINE
BEGIN
n: Rope.ROPE = CDDirectory.Name[me];
IF Rope.IsEmpty[n] THEN {
RETURN [rp.objectName]
};
RETURN [n]
END;

DescribeReference: PROC[me: CD.ObPtr] RETURNS [Rope.ROPE] = 
BEGIN
RETURN [Rope.Concat["reference to ", ReferenceName[me]]]
END;

DrawReference: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => 
IF pr.nesting.table[pr.nestDepth-1]=aptr THEN pr.nestDepth _ pr.nestDepth-1;
rp: ReferencePtr = NARROW[aptr.ob.specificRef];
IF rp.boundApp#NIL THEN {
pr.nesting.table[pr.nestDepth] _ aptr;
pr.nestDepth _ pr.nestDepth+1;
pr.drawChild[rp.boundApp, pos, orient, pr];
pr.nestDepth _ pr.nestDepth-1;
}
ELSE {
r: CD.DesignRect = IntRect[aptr.ob, pos, orient];
pr.drawRect[r, CD.highLightShade, pr];
pr.drawComment[r, ShortName[aptr.ob, rp], pr];
}
END; 

IntRect: PROC [ob: CD.ObPtr, pos: CD.DesignPosition, orient: CD.Orientation] RETURNS [CD.DesignRect] = INLINE
BEGIN
RETURN [CDOrient.MapRect[
itemInCell: CD.InterestRect[ob],
cellSize: ob.size,
cellInstOrient: orient,
cellInstPos: pos
]]
END;

QuickDrawReference: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => 
IF pr.nesting.table[pr.nestDepth-1]=aptr THEN pr.nestDepth _ pr.nestDepth-1;
rp: ReferencePtr = NARROW[aptr.ob.specificRef];
IF rp.boundApp#NIL THEN {
pr.nesting.table[pr.nestDepth] _ aptr;
pr.nestDepth _ pr.nestDepth+1;
rp.boundApp.ob.p.quickDrawMe[rp.boundApp, pos, orient, pr];
pr.nestDepth _ pr.nestDepth-1;
}
ELSE {
r: CD.DesignRect = IntRect[aptr.ob, pos, orient];
pr.drawRect[r, CD.highLightShade, pr];
pr.drawComment[r, ShortName[aptr.ob, rp], pr];
}
END; 

DrawReferenceSelection: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
rp: ReferencePtr = NARROW[aptr.ob.specificRef];
IF rp.boundApp#NIL THEN 
rp.boundApp.ob.p.showMeSelected[rp.boundApp, pos, orient, pr]
ELSE 
pr.outLineProc[IntRect[aptr.ob, pos, orient], pr]
END; 

InterestRect: PROC [ob: CD.ObPtr] RETURNS [CD.DesignRect] =
BEGIN
RETURN [NARROW[ob.specificRef, ReferencePtr].ir]
END;

WriteRect: PROC[r: CD.Rect] =
BEGIN
TokenIO.WriteInt[r.x1];
TokenIO.WriteInt[r.y1];
TokenIO.WriteInt[r.x2];
TokenIO.WriteInt[r.y2];
END;

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

WriteReference: CD.InternalWriteProc -- PROC [me: ObPtr] -- =
BEGIN
rp: ReferencePtr = NARROW[me.specificRef];
TokenIO.WriteInt[me.size.x];
TokenIO.WriteInt[me.size.y];
WriteRect[rp.ir];
TokenIO.WriteRope[rp.objectName];
TokenIO.WriteRope[rp.designName];
END;

ReadReference: CD.InternalReadProc --PROC [] RETURNS [ObPtr]-- =
BEGIN
x: INT = TokenIO.ReadInt[];
y: INT = TokenIO.ReadInt[];
ir: CD.DesignRect;
objectName: Rope.ROPE;
importeeName: Rope.ROPE;
ob: CD.ObPtr;
IF CDIO.VersionKey[] >= 8 THEN ir _ ReadRect[] 
ELSE ir _ CDBasics.RectAt[[0, 0], [x, y]];
objectName _ TokenIO.ReadRope[];
importeeName _ TokenIO.ReadRope[];
ob _ InternalCreateReference[
design: CDIO.DesignInReadOperation[], 
ir: ir,
size: [x, y], 
objectName: objectName, 
autoCreateOb: true,
importeeName: importeeName,
autoImport: true,
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.Store[boundTo: design, key: importListKey, value: imp];
};
END;

GetImport: PUBLIC PROC [design: CD.Design, importeeName: Rope.ROPE_NIL, createIfNotFound: BoolOrInteractive _ true] RETURNS [REF Import] =
BEGIN

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

mdata: REF Import _ NIL; 
impl: REF ImportList = GetImportList[design];
IF Rope.IsEmpty[importeeName] THEN ERROR CD.Error[ec: other, 
explanation: "design has empty name, but shouldn't"
];
IF impl#NIL THEN
FOR l: LIST OF REF Import _ 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", TRUE, importeeName] THEN {
mdata _ NEW[Import _ [importeeName: importeeName, importee: NIL, referenceList: NIL]];
impl.list _ CONS[mdata, impl.list];  --atomic--
};
RETURN [mdata]
END;

BindImportee: PROC [importer, importee: CD.Design, 
allowSizeConflicts, allowOverload: BoolOrInteractive _ true] =
BEGIN
ENABLE TerminalIO.UserAbort => GOTO UserAborted;
done1: BOOL_TRUE;
mdata: REF Import = GetImport[importer, importee.name];
IF mdata=NIL THEN ERROR;
IF mdata.importee#NIL THEN {
IF allowOverload=false THEN RETURN
ELSE IF allowOverload=interactive THEN
IF NOT TerminalIO.UserSaysYes[
text: "design already loaded; shall overload?\n", 
label: "overload?"] THEN {
TerminalIO.WriteRope["dont overload; not done\n"];
RETURN 
}
};
mdata.importee _ importee;
FOR list: LIST OF CD.ObPtr _ mdata.referenceList, list.rest WHILE list#NIL DO
done1 _ done1 AND BindReference[importer, list.first, mdata.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.ObPtr, importee: CD.Design, allowSizeConflicts: BoolOrInteractive _ true] RETURNS [ok: BOOL_FALSE] =
BEGIN
ENABLE TerminalIO.UserAbort => GOTO UserAborted;
rp: ReferencePtr = NARROW[reference.specificRef, ReferencePtr];
found: BOOL; 
oldRect, newRect: CD.DesignRect;
referedOb: CD.ObPtr;
[found, referedOb] _ CDDirectory.Fetch[importee, rp.objectName];
IF NOT found THEN {
TerminalIO.WriteRope["entry "];
TerminalIO.WriteRope[rp.objectName];
TerminalIO.WriteRope[" in "];
TerminalIO.WriteRope[importee.name];
TerminalIO.WriteRope[" not found\n"];
RETURN
};
oldRect _ InterestRect[reference];
newRect _ CD.InterestRect[referedOb];
IF newRect#oldRect THEN {
TerminalIO.WriteRope["object "];
TerminalIO.WriteRope[rp.objectName];
TerminalIO.WriteRope[" 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.UserSaysYes[text: "import anyway? ", 
label: "import different sized ob?"] THEN {
TerminalIO.WriteRope["no\n"];
RETURN
};
TerminalIO.WriteRope["yes\n"];
};
};
rp.boundApp _ CDApplications.NewApplicationI[ob: referedOb];
rp.boundApp.location _ [0, 0];
BEGIN
oldSize: CD.DesignPosition = reference.size;
oldBase: CD.DesignPosition = CDBasics.BaseOfRect[oldRect];
newSize: CD.DesignPosition = referedOb.size;
newBase: CD.DesignPosition = CDBasics.BaseOfRect[newRect];
IF oldSize#newSize OR oldRect#newRect THEN {
reference.size _ newSize;
rp.ir _ newRect;
CDDirectory.RepositionObject[design: design,
ob: reference, 
oldSize: oldSize, 
baseOff: CDBasics.SubPoints[oldBase, newBase]
];
};
END;
ok _ TRUE;
EXITS
UserAborted => {TerminalIO.WriteRope["aborted, entry not replaced\n"]};
END;

DoImport: PUBLIC PROC [design: CD.Design, importee: CD.Design,
allowOverload, allowConflicts: BoolOrInteractive_true] RETURNS [done: BOOL_FALSE] = 
BEGIN
indirectImport: REF ImportList ~ GetImportList[importee]; 
IF indirectImport^.list#NIL THEN TerminalIO.WriteRope["There are indirect imports\n"];
FOR list: LIST OF REF Import _ indirectImport^, list.rest WHILE list#NIL DO
IF Rope.Equal[list.first.importeeName, design.name] THEN {
TerminalIO.WriteRope["**creates circular imports\n"];
RETURN
}
ENDLOOP; 
BindImportee[importer: design, importee: importee, allowSizeConflicts: allowConflicts, allowOverload: allowOverload];
FOR list: LIST OF REF Import _ GetImportList[design]^, list.rest WHILE list#NIL DO
IF list.first.importee#NIL THEN
BindImportee[importer: list.first.importee, importee: importee, allowSizeConflicts: false, allowOverload: true];
ENDLOOP; 
FOR list: LIST OF REF Import _ indirectImport^, list.rest WHILE list#NIL DO
IF list.first.importee=NIL THEN {
imp: REF Import _ GetImport[design, list.first.importeeName, false];
IF imp#NIL AND imp.importee#NIL THEN
BindImportee[importer: importee, importee: imp.importee, allowSizeConflicts: false, allowOverload: true];
}
ENDLOOP; 
done _ TRUE;
END;   

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

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

PerChild: CDDirectory.EnumerateObjectsProc --PROC [me: CD.ObPtr, x: REF] -- =
BEGIN
IF me.p.inDirectory THEN { 
impChild: CD.ObPtr;
FOR list: CDDirectory.ReplaceList _ replaceList, list.rest WHILE list#NIL DO
IF list.first.old=me THEN RETURN -- eliminate duplicates
ENDLOOP; 
impChild _ InternalCreateReference[
design: design, objectName: CDDirectory.Name[me], importeeName: importeeName,
size: me.size, autoImport: true, 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.DoReplaceDirectChild[me: me, design: design, replace: replaceList];
END;

OneLevelIncludedCopy: PUBLIC PROC [impObject: CD.ObPtr, design: CD.Design] RETURNS [CD.ObPtr] =
BEGIN
WITH impObject.specificRef SELECT FROM
rp: ReferencePtr => {
newOb: CD.ObPtr;
import: REF Import = GetImport[design, rp.designName, false];
IF rp.boundApp=NIL OR import=NIL OR import.importee=NIL THEN 
ERROR CD.Error[callingError, "OneLevelIncludedCopy impObject not bound "];
newOb _ CDDirectory.Another[me: rp.boundApp.ob, from: import.importee, to: design];
ReplaceChildrenByImports[me: newOb, design: design, importeeName: import.importeeName];
RETURN [newOb]
};
ENDCASE => ERROR CD.Error[callingError, "OneLevelIncludedCopy impObject not reference"]
END;

Another: PROC [me: CD.ObPtr, from, to: CD.Design] RETURNS [CD.ObPtr] =
BEGIN
rp: ReferencePtr = NARROW[me.specificRef];
newOb: CD.ObPtr = InternalCreateReference[design: to, objectName: rp.objectName, importeeName: rp.designName, autoCreateOb: true, autoImport: true, allowConflicts: true, include: TRUE, size: me.size];
newOb.properties _ CDProperties.AppendProps[looser: me.properties, winner: newOb.properties];
IF newOb=NIL THEN ERROR;
RETURN [newOb];
END;

MergeInImport: PUBLIC PROC [design: CD.Design, importeeName: Rope.ROPE] =
BEGIN
imp: REF Import _ GetImport[design, importeeName, false];
IF imp=NIL THEN {
TerminalIO.WriteRope["MergeInImport not done; design "];
TerminalIO.WriteRope[importeeName];
TerminalIO.WriteRope[" is not imported\n"];
RETURN
}
ELSE IF imp.importee=NIL THEN {
TerminalIO.WriteRope["MerginImport not done; design "];
TerminalIO.WriteRope[importeeName];
TerminalIO.WriteRope[" is not loaded\n"];
RETURN
}
ELSE {
importee: CD.Design _ imp.importee; 
objectList: LIST OF CD.ObPtr _ NIL;
doList: LIST OF CD.ObPtr _ NIL;
dontList: LIST OF CD.ObPtr _ NIL;
FOR list: LIST OF CD.ObPtr _ imp.referenceList, list.rest WHILE list#NIL DO
IF NARROW[list.first.specificRef, ReferencePtr].boundApp#NIL THEN 
doList _ CONS[list.first, doList]
ELSE dontList _ CONS[list.first, dontList];
ENDLOOP;
imp.importee _ NIL;
imp.referenceList _ dontList;
FOR list: LIST OF CD.ObPtr _ doList, list.rest WHILE list#NIL DO
pr: ReferencePtr = NARROW[list.first.specificRef];
objectList _ CONS[pr.boundApp.ob, objectList];
ENDLOOP;
CDExtras.MergeInObjects[design: design, from: importee, objects: objectList];
FOR list: LIST OF CD.ObPtr _ doList, list.rest WHILE list#NIL DO
[] _ CDDirectory.Remove[design: design, 
name: CDDirectory.Name[list.first], 
expectObject: list.first
]
ENDLOOP;
FOR list: LIST OF CD.ObPtr _ doList, list.rest WHILE list#NIL DO
pr: ReferencePtr = NARROW[list.first.specificRef];
CDDirectory.ReplaceObject[design: design, old: list.first, new: pr.boundApp.ob]
ENDLOOP;
}
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.Import _ impList^, list.rest WHILE list#NIL DO
IF list.first.importee=NIL THEN {
RETURN [yes _ TRUE]
}
ENDLOOP;
END;

OldSetInterest: PROC [ob: CD.ObPtr, r: CD.DesignRect] =
BEGIN
cptr: ReferencePtr = NARROW[ob.specificRef];
cptr.ir _ r;
END;

Init: PROC [] = 
BEGIN
rp: REF CDDirectory.DirectoryProcs ~ CDDirectory.InstallDirectoryProcs[pForReference];
rp.enumerateChildObjects _ EnumerateItsObjects;
rp.replaceDirectChilds _ ReplaceDirectChild;
rp.another _ Another;
pForReference.drawMe _ DrawReference;
pForReference.quickDrawMe _ QuickDrawReference;
pForReference.showMeSelected _ DrawReferenceSelection;
pForReference.internalRead _ ReadReference;
pForReference.internalWrite _ WriteReference;
pForReference.describe _ DescribeReference;
pForReference.interestRect _ InterestRect;
CDInterestRects.InstallOldSetInterest[pForReference, OldSetInterest];
CDValue.EnregisterKey[importListKey];
CDEvents.RegisterEventProc[$RenameDesign, DesignHasBeenRenamed];
END; 

Init[];
END. 

äCDImportsImpl.mesa   (part of ChipNDale)
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
by Christian Jacobi, March 20, 1984 5:50:51 pm PST 
last edited Christian Jacobi, April 11, 1985 9:30:55 am PST
dont !!! 
rp: ReferencePtr ~ NARROW[me.specificRef];
IF rp.boundApp#NIL THEN p[rp.boundApp.ob, x];
-- PROC[me: CD.ObPtr, 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
--search first for an already imported object object
--already imported object has not been found; make import
-- check for forbidden circular import
-- no circular import
--check already imported designs for importing the new design
--check the new design for importing of already imported designs
-- prevent a renaming which would cause circularity

--build list of direct children
--replace each direct child by an import
--imp is an imported and bound object which will be made local to design
--Includes all the imported and bound objects from importeeName (including  
--their transitive closure; but not indirect imports) into design.
--split the reference list in doList and dontList
--merge in objects from doList
--now remove old references
�ʶ˜š
œ(™(Jšœ
Ïm
œ7™BJš
œ3™3Jš
œ;™;J˜—š
Ïk	˜	Jšžœ
˜J˜J˜J˜J˜	Jšœ	žœ˜ Jš
œ
˜
Jš
œ˜Jš
œ	˜	Jš
œ˜Jš
œ˜Jš
œ	˜	J˜
Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—šÏb
œžœ
žœ
˜Jšžœ
žœ=žœT˜Ÿ
Jšžœ˜"Jšžœ˜—Jš
ž˜J˜J˜Jšœžœ˜6Jšœžœ˜,Jšœžœ˜,J˜Jšœžœ˜(Jšœžœ˜ J˜JšœžœÏc˜1J˜Jšœžœžœ˜CJ˜šÏnœžœžœ0žœ˜XJš
ž˜š
œ	™	Jšœžœ™*Jšžœ
žœ
žœ™-—Jšžœ
˜—J˜šŸœ#˜5Jš
œL™LJš
ž˜Jš
œ™Jš
œM™MJšžœ
˜—J˜š¡œžœ
žœ	˜2Jšœžœ œ%˜bJšœ žœ˜&Jšœ' '˜NJšœ) +˜TJšœ+ $˜OJš	œ
žœ
žœžœžœ	˜)Jš
ž˜Jšœžœ˜
Jš
œ˜Jšœžœ6˜AJšœžœ2˜BJšœžœ˜Jšžœžœ	žœ-˜WJš
žœžœ
žœ
žœžœ˜ Jš
œ4™4š
žœžœ
žœ
žœ)žœžœ
ž˜NJš
œ˜Jšœžœ˜*šžœ'˜)šžœ)žœ˜2Jšžœžœžœ
žœ˜7šžœ
žœžœ˜>Jš
œ˜Jš
œ˜Jšœžœ
žœ˜—Jšžœ
žœžœ
˜—Jš
œ˜—Jšžœ
˜—Jš
œ9™9šžœžœ
žœ˜Jšœžœ
˜Jšœžœ˜Jš
œD˜Dšžœžœ˜šžœžœžœ˜OJš
œ˜Jš
œ˜Jšœžœ
žœžœ˜—J˜
—šžœ˜šžœžœ˜Jš
œ˜Jšœžœ˜ Jš
œ˜—J˜
—J˜—šœžœ
žœ˜Jš
œ˜Jš
œ˜Jšœžœ
˜šœ
žœ˜!Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜—Jšœžœ˜6Jšžœ	žœn˜}Jšžœžœ
žœA˜\Jšžœ˜Jšžœ
˜—J˜š¡œžœ
žœ
žœ(žœžœžœ	˜kJš
ž˜Jšœ¨
žœ˜®
Jšžœ
˜—Jš
œ
˜
š
¡
œžœžœžœžœ˜8Jš
ž˜Jšœžœ˜$šžœžœ˜Jšœžœ˜*Jšžœ.˜4J˜—Jšžœ˜
Jšžœ
˜—J˜š¡	œžœžœžœžœž˜MJš
ž˜Jšœžœ˜$šžœžœ˜Jšžœ˜J˜—Jšžœ˜
Jšžœ
˜—J˜š
¡œžœžœžœžœ˜<Jš
ž˜Jšžœ2˜8Jšžœ
˜—J˜š
¡
œžœžœžœžœ
˜]Jšœžœ˜Jš
ž˜šžœ
žœ˜Jšžœ'žœ˜L—Jšœžœ˜/šžœ
žœ
žœ˜Jš
œ&˜&Jš
œ˜Jš
œ+˜+Jš
œ˜J˜
—šžœ˜Jšœžœ,˜1Jšœžœ˜&Jš
œ.˜.J˜
—Jšžœ˜J˜—š¡œžœžœ
žœžœžœžœž˜mJš
ž˜šžœ˜Jš
œ ˜ Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jšžœ
˜J˜—š
¡œžœžœžœžœ
˜bJšœžœ˜š
ž˜šžœ
žœ˜Jšžœ'žœ˜L——Jšœžœ˜/šžœ
žœ
žœ˜Jš
œ&˜&Jš
œ˜Jš
œ;˜;Jš
œ˜J˜
—šžœ˜Jšœžœ,˜1Jšœžœ˜&Jš
œ.˜.J˜
—Jšžœ˜J˜—š
¡œžœžœžœžœ
˜fJšœžœ˜Jš
ž˜Jšœžœ˜/šžœ
žœ
žœ
˜Jš
œ=˜=—šžœ
˜Jš
œ1˜1—Jšžœ˜—J˜š
¡œžœžœžœžœ˜;Jš
ž˜Jšžœžœ"˜0Jšžœ
˜J˜—š¡	œžœžœ˜Jš
ž˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšžœ
˜—J˜š¡œžœžœžœ˜%Jš
ž˜Jšœžœ˜J˜J˜J˜J˜Jšžœ˜
Jšžœ
˜—J˜
codeš¡œžœ œ˜=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šžœ˜Jšžœ
˜—J˜š¡
œžœ
žœ
žœ	žœžœ˜NJš
ž˜šžœIžœ
ž˜XJšœžœžœ˜#šžœ˜Jšœžœžœ˜$Jš
œ?˜?J˜——Jšžœ
˜—J˜š¡	œžœ
žœ
žœžœ
žœ.žœžœ
˜Š
Jš
ž˜J˜š¡œžœžœžœ
žœžœ
žœžœžœ˜hJš
ž˜šžœž˜
Jšœžœžœ˜Jšœ	žœžœ˜šžœ˜Jš
œ˜Jš
œ˜Jšžœ&˜,J˜
——Jšžœ
˜—J˜Jšœžœ
žœ˜Jšœžœ$˜-šžœžœ
žœ
žœ˜=Jš
œ3˜3Jš
œ˜—šžœžœ
ž˜š
žœžœ
žœ
žœžœžœ
ž˜<Jš
žœ	žœ
žœ0žœ
žœ
˜WJšžœ
˜——šžœ.žœžœ˜JJšœžœ1žœžœ˜VJšœžœ 
˜/J˜—Jšžœ˜Jšžœ
˜—J˜š¡œžœžœ	˜3Jš
œ>˜>š
ž˜Jšžœžœ
˜0—Jšœžœ
žœ
˜Jšœžœ-˜7Jšžœžœ
žœ
žœ
˜šžœžœ
žœ˜Jšžœžœ
ž˜"šžœ
žœž˜&šžœ
žœ˜Jš
œ2˜2šœžœ˜Jš
œ2˜2Jšžœ
˜J˜
———J˜—Jš
œ˜š
žœžœ
žœ
žœ(žœžœ
ž˜MJšœžœK˜\Jšžœ
˜—Jšžœ
žœžœ1˜BJš
œ˜š
ž˜Jš
œE˜E—Jšžœ
˜—J˜š¡
œžœ
žœžœžœ7žœžœ
žœ˜š
š
ž˜Jšžœžœ
˜0—Jšœžœ&˜?Jšœžœ˜
Jšœžœ˜ Jšœžœ˜Jš
œ@˜@šžœ
žœžœ˜Jš
œ˜Jš
œ$˜$Jš
œ˜Jš
œ$˜$Jš
œ%˜%Jš
ž˜J˜—Jš
œ"˜"Jš
œ%˜%šžœžœ˜Jš
œ ˜ Jš
œ$˜$Jš
œ.˜.šžœ;žœ
˜BJš
œ3˜3—šžœ
˜Jš
œ7˜7—šžœžœ˜"Jš
œ'˜'Jš
ž˜J˜—šžœ žœ˜(šžœ2˜4šœ%žœ˜+Jš
œ˜Jš
ž˜Jš
œ˜——Jš
œ˜Jš
œ˜—J˜—Jš
œ<˜<Jš
œ˜š
ž˜Jšœ	žœ!˜,Jšœ	žœ/˜:Jšœ	žœ!˜,Jšœ	žœ/˜:šžœžœžœ˜,Jš
œ˜Jš
œ˜š
œ,˜,Jš
œ˜Jš
œ˜Jš
œ-˜-Jš
œ˜—J˜—Jšžœ
˜—Jšœžœ
˜
š
ž˜Jš
œG˜G—Jšžœ
˜—J˜š
Ðbnœžœ
žœ
žœžœ˜>Jšœ7žœžœ
žœ˜TJš
ž˜Jšœžœ'˜:Jšžœžœ
žœ6˜VJš
œ&™&š
žœžœ
žœ
žœ%žœžœ
ž˜Kšžœ2žœ˜:Jš
œ5˜5Jš
ž˜Jš
œ
˜
—Jšžœ˜	—Jš
œ™Jš
œu˜uJš
œ=™=š
žœžœ
žœ
žœ,žœžœ
ž˜Ršžœžœ
ž˜Jš
œp˜p—Jšžœ˜	—Jš
œ@™@š
žœžœ
žœ
žœ%žœžœ
ž˜Kšžœžœ
žœ˜!Jšœžœ<˜Dš	žœžœ
žœžœ
ž˜$Jš
œi˜i—J˜
—Jšžœ˜	—Jšœžœ
˜Jšžœ˜—J˜šŸœ˜)Jš žœ	žœ
žœžœžœžœ
žœ
 œ˜MJš
œ3™3Jš
ž˜JšœžœX˜`šžœžœ
žœ˜Jšœžœ
˜Jš
œ?˜?J˜—Jšžœ˜—J˜š
¡œžœžœžœžœ˜ZJš
ž˜Jšœ%žœ
˜)J˜šŸœ#  œ˜MJš
ž˜šžœžœ˜Jšœ
žœ˜šžœ8žœžœ
ž˜LJšžœžœ
ž ˜8Jšžœ˜	—š
œ#˜#Jš
œM˜MJšœTž˜XJš
œ˜—šœžœ
˜šžœ˜Jš
œ	˜	Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ˜—J˜
—Jšžœ
˜—J™Jš
œ™Jšœ:žœ˜?Jš
œ(™(šžœ
žœ
žœ
˜Jš
œT˜T—Jšžœ
˜—J˜š¡œžœ
žœ
žœžœ	žœžœ	˜_Jš
œH™HJš
ž˜šžœžœ
ž˜&š
œ˜Jšœžœ˜Jšœžœ2˜=šžœ
žœ
žœžœ
žœžœ
žœ
˜=Jšžœ
žœB˜J—Jš
œS˜SJš
œW˜WJšžœ˜J˜—Jšžœžœ
žœD˜W—Jšžœ
˜—J˜š¡œžœžœžœ	žœžœ	˜FJš
ž˜Jšœžœ˜*Jšœžœª
žœ˜È
Jš
œ]˜]Jšžœžœ
žœ
ž˜Jšžœ	˜Jšžœ
˜—J˜š
¡
œžœ
žœ
žœžœ˜IJš
œL™LJš
œB™BJš
ž˜Jšœžœ1˜9šžœžœ
žœ˜Jš
œ8˜8Jš
œ#˜#Jš
œ+˜+Jš
ž˜J˜
—šžœ
žœžœ
žœ˜Jš
œ7˜7Jš
œ#˜#Jš
œ)˜)Jš
ž˜J˜
—šžœ˜Jšœ
žœ˜$Jš	œžœ
žœ
žœ	žœ
˜#Jš	œžœ
žœ
žœ	žœ
˜Jš	œ
žœ
žœ
žœ	žœ
˜!Jš
œ1™1š
žœžœ
žœ
žœ&žœžœ
ž˜Kšžœ
žœ0žœ
žœ
˜BJšœ	žœ˜!—Jšžœžœ˜+Jšžœ
˜—Jšœžœ
˜Jš
œ˜Jš
œ™š
žœžœ
žœ
žœžœžœ
ž˜@Jšœžœ˜2Jšœ
žœ˜.Jšžœ
˜—Jš
œM˜MJš
œ™š
žœžœ
žœ
žœžœžœ
ž˜@š
œ(˜(Jš
œ$˜$Jš
œ˜Jš
œ
˜
—Jšžœ
˜—š
žœžœ
žœ
žœžœžœ
ž˜@Jšœžœ˜2Jš
œO˜OJšžœ
˜—J˜
—Jšžœ˜—J˜š¡œžœ
žœ	žœžœ
žœ˜OJš
ž˜Jšœ	žœ.˜:šžœ	žœ
ž˜š
žœžœ
žœ
žœ(žœžœ
ž˜Nšžœžœ
žœ˜!Jšžœžœ
˜J˜
—Jšžœ
˜——Jšžœ
˜—J˜š¡œžœžœžœ˜7Jš
ž˜Jšœžœ˜,Jš
œ˜Jšžœ
˜J˜—š¡œžœ˜Jš
ž˜JšœžœO˜VJš
œ/˜/Jš
œ,˜,Jš
œ˜Jš
œ%˜%Jš
œ/˜/Jš
œ6˜6Jš
œ+˜+Jš
œ-˜-Jš
œ+˜+Jš
œ*˜*Jš
œE˜EJš
œ%˜%J˜@Jšžœ˜—J˜J˜Jšžœ˜J˜—…—Dîaˆ