DIRECTORY 
CD,
CDGenerate,
CDGenerateBackdoor,
CDDirectory,
CDEnvironment,
CDIO,
CDProperties,
CDRemote,
CDValue,
FileNames,
RefTab,
Rope,
SymTab,
TerminalIO,
TokenIO,
UserProfile;

CDRemoteImpl: CEDAR PROGRAM
IMPORTS CDGenerate, CDGenerateBackdoor, CDDirectory, CDEnvironment, CDIO, CDProperties, CDValue, FileNames, RefTab, Rope, SymTab, TerminalIO, UserProfile
EXPORTS CDRemote =
BEGIN


ROPE: TYPE = Rope.ROPE;

dummy: CDGenerate.Context _ CDGenerate.Create[];
contextToName: RefTab.Ref _ RefTab.Create[]; 
-- context ==> remote design name
NameRec: TYPE = RECORD [name: ROPE, key: REF];
nameToContext: SymTab.Ref _ SymTab.Create[];
-- remote design name ==> context

UnspecSelector: CDGenerateBackdoor.SelectorProc = {
key _ TerminalIO.RequestRope[" include [design.oject] >"];
};

Selector: CDGenerateBackdoor.SelectorProc = {
dName: ROPE = DesignName[context];
key _ TerminalIO.RequestRope[Rope.Cat[label, " include oject from ", dName, " >"]];
};

UnspecRemoteIGenerator: CDGenerateBackdoor.IGeneratorProc = {
dotIndex: INT; remoteName, objectName: ROPE _ NIL;
name: ROPE _ FileNames.GetShortName[key];
dotIndex _ Rope.Index[name, 0, "."];  --the first dot! multiple dots belong to the object name
IF dotIndex < Rope.Length[name] THEN {
objectName _ Rope.Substr[name, dotIndex+1];
remoteName _ Rope.Substr[name, 0, dotIndex]
};
IF ~Rope.IsEmpty[remoteName] AND ~Rope.IsEmpty[objectName] THEN {
context: CDGenerate.Context _ GetContext[remoteName];
ob _ CDGenerate.FetchNCall[context, design, objectName];
}
ELSE TerminalIO.PutRopes["**tried to access remote with bad syntax;  [", key, "]\n"];
};

GetContext: PUBLIC PROC [remoteDesign: ROPE] RETURNS [context: CDGenerate.Context_NIL] = {
IF Rope.IsEmpty[remoteDesign] THEN ERROR; 
WITH nameToContext.Fetch[remoteDesign].val SELECT FROM
t: CDGenerate.Context => RETURN [t]
ENDCASE => NULL;
context _ CDGenerateBackdoor.CreateIndirect[onTopOf: dummy, iGenerator: RemoteIGenerator, 
selector: Selector, cache: TRUE, flushThrough: FALSE, clearThrough: FALSE, registerThrough: FALSE];
[] _ contextToName.Insert[context, 
NEW[NameRec _ [name: remoteDesign, key: NEW[INT]] ]
];
IF nameToContext.Insert[remoteDesign, context] THEN RETURN;
RETURN [GetContext[remoteDesign]] --indirection for concurrency problems
};

Get: PUBLIC PROC [for: CD.Design, remoteDesign: ROPE, object: ROPE] RETURNS [ob: CD.Object] = {
context: CDGenerate.Context = GetContext[remoteDesign];
ob _ CDGenerate.FetchNCall[context, for, object];
};

RemoteInfo: PROC [context: CDGenerate.Context] RETURNS [r: REF NameRec_NIL] = {
WITH contextToName.Fetch[context].val SELECT FROM
rn: REF NameRec => RETURN [rn];
ENDCASE => {
context _ CDGenerateBackdoor.Indiretee[context];
IF context#NIL THEN RETURN[RemoteInfo[context]]
};
};

DesignName: PUBLIC PROC [context: CDGenerate.Context] RETURNS [r: ROPE_NIL] = {
rn: REF NameRec _ RemoteInfo[context];
IF rn#NIL THEN RETURN [rn.name]
};

RemoteIGenerator: CDGenerateBackdoor.IGeneratorProc = {
replaceList: CDDirectory.ReplaceList _ NIL;

GetOrLoad: PROC [importer: CD.Design, remoteInfo: REF NameRec] RETURNS [design: CD.Design_NIL] = {
IF remoteInfo=NIL OR Rope.IsEmpty[remoteInfo.name] THEN {
TerminalIO.PutRope["**generate with bad remote name\n"];
RETURN
};
WITH CDValue.Fetch[boundTo: importer, key: remoteInfo.key] SELECT FROM
d: CD.Design => design _ d;
ENDCASE => NULL;
IF design=NIL THEN {
design _ DoLoad[importer, remoteInfo.name];
CacheDesign[importer, design];
};
};

EachChild: CDDirectory.EnumerateObjectsProc = { -- PROC [me: CD.Object, x: REF] -- 
IF me.class.inDirectory THEN {
name: ROPE _ CDDirectory.Name[me];
ob1: CD.Object _ CDGenerate.FetchNCall[realContext, design, name];--will be cached!
replaceRec: REF CDDirectory.ReplaceRec _ NEW[CDDirectory.ReplaceRec _ [old: me, new: ob1]];
replaceList _ CONS[replaceRec, replaceList];
}
};

remoteDesign: CD.Design;
remoteInfo: REF NameRec _ RemoteInfo[passContext];
IF Rope.Equal[remoteInfo.name, design.name] THEN {
ob _ CDDirectory.Fetch[design, key].object;
RETURN
};
remoteDesign _ GetOrLoad[design, remoteInfo];
IF remoteDesign#NIL THEN {
rob: CD.Object _ CDDirectory.Fetch[remoteDesign, key].object;
IF rob#NIL THEN {
tm, cm: CDDirectory.DMode;
[ob, tm, cm] _ CDDirectory.Another[me: rob, fromOrNil: remoteDesign, into: design];
IF ob#NIL THEN { 
IF cm=immutable THEN {
CDDirectory.EnumerateChildObjects[me: ob, p: EachChild];
IF replaceList#NIL THEN 
[] _ CDDirectory.ReplaceDirectChild[me: ob, design: design, replace: replaceList];
}; 
IF tm=ready THEN [] _ CDDirectory.Include[design: design, object: ob];
CDProperties.PutObjectProp[ob, $CameFrom, remoteDesign.name];
CDProperties.PutObjectProp[ob, $OriginalName, key];
RETURN [ob]
};
};
};
};

CacheDesign: PUBLIC PROC [for: CD.Design, remote: CD.Design] = {
rn: REF NameRec _ RemoteInfo[GetContext[remote.name]];
IF for.technology#remote.technology THEN ERROR;
IF rn#NIL THEN CDValue.Store[boundTo: for, key: rn.key, value: remote]
ELSE 
TerminalIO.PutRope["**CacheRemoteDesign failed; debugging is appropriate\n"];
};

FetchDesign: PUBLIC PROC [for: CD.Design, name: ROPE] RETURNS [remote: CD.Design _ NIL] = {
rn: REF NameRec _ RemoteInfo[GetContext[name]];
WITH CDValue.Fetch[boundTo: for, key: rn.key, propagation: design] SELECT FROM
d: CD.Design => remote _ d
ENDCASE => NULL;
};


IsCached: PUBLIC PROC [for: CD.Design, remoteDesign: ROPE] RETURNS [BOOL] = {
RETURN [FetchDesign[for, remoteDesign]#NIL]
};

ForgetCache: PUBLIC PROC [for: CD.Design, remoteDesign: ROPE] = {
rn: REF NameRec _ RemoteInfo[GetContext[remoteDesign]];
CDValue.Store[boundTo: for, key: rn.key, value: NIL]
};

LoadCache: PUBLIC PROC [for: CD.Design, remoteDesign: ROPE, remoteFile: ROPE _ NIL, reload: BOOL _ FALSE] RETURNS [loaded: BOOL] = {
d: CD.Design;
IF ~reload AND IsCached[for, remoteDesign] THEN RETURN [TRUE];
d _ DoLoad[for, remoteDesign, remoteFile];
IF loaded_(d#NIL) THEN CacheDesign[for, d]; 
};

MakupName: PUBLIC PROC [for: CD.Design, remoteDesign: ROPE] RETURNS [f: ROPE_NIL] = {
GetHintList: PROC [for: CD.Design] RETURNS [LIST OF ROPE_NIL] = {
IF for#NIL THEN
WITH CDProperties.GetDesignProp[for, $ImportHints] SELECT FROM
rL: LIST OF ROPE => RETURN [rL];
ENDCASE => NULL;
};
RemSpaces: PROC [r: ROPE] RETURNS [ROPE_NIL] = {
leng: INT _ Rope.Length[r];
start: INT _ 0;
WHILE start<leng AND Rope.Fetch[r, start]='  DO start _ start+1 ENDLOOP;
WHILE leng>start AND Rope.Fetch[r, leng-1]='  DO leng _ leng-1 ENDLOOP;
IF leng>start THEN RETURN [Rope.Substr[r, start, leng-start]];
};
rl: LIST OF ROPE _ GetHintList[for];
key, rest: ROPE _ NIL;
FOR list: LIST OF ROPE _ rl, list.rest WHILE list#NIL DO
[key, rest] _ CDEnvironment.SplitLine[list.first];
IF Rope.Equal[remoteDesign, key] THEN RETURN [RemSpaces[rest]];
ENDLOOP;
f _ UserProfile.Token[Rope.Cat["ChipNDale.ImportFor.", remoteDesign], remoteDesign];  
};

DoLoad: PROC [importer: CD.Design, remoteName: ROPE, fileName: ROPE_NIL] RETURNS [design: CD.Design_NIL] = {
checkWasCalled: BOOL _ FALSE;

Check: PROC [h: TokenIO.Handle] RETURNS [ok: BOOL] = {
design: CD.Design _ CDIO.DesignInReadOperation[h];
checkWasCalled _ TRUE;
IF ok _ design.technology=importer.technology THEN {
ok _ Rope.Equal[remoteName, design.name];
IF NOT ok THEN TerminalIO.PutRope[Rope.Cat["file """, fileName,  """ has different design: """, design.name, """\n"]];
}
ELSE TerminalIO.PutRopes["**technology missmatch: remote design is ", design.technology.name, "\n"];
};

name1: ROPE;
TerminalIO.PutRopes["load remote design ", remoteName, "\n"];
IF Rope.IsEmpty[fileName] THEN fileName _ MakupName[importer, remoteName];
name1 _ CDIO.MakeName[base: fileName, ext: "dale", wDir: CDIO.GetWorkingDirectory[importer]];
design _ CDIO.ReadDesign[name1, Check];
IF ~checkWasCalled AND design=NIL THEN  {
name2: ROPE _ CDIO.MakeName[base: fileName, ext: "dale", wDir: CDIO.GetWorkingDirectory[NIL]];
IF ~Rope.Equal[name1, name2, FALSE] THEN design _ CDIO.ReadDesign[name2, Check];
};
TerminalIO.PutRopes["loading remote design ", (IF design#NIL THEN "done\n" ELSE "not done\n")];
};


unspecRemoteContext: CDGenerate.Context _ CDGenerateBackdoor.CreateIndirect[
onTopOf: dummy, 
iGenerator: UnspecRemoteIGenerator, 
selector: UnspecSelector
];
[] _ SymTab.Insert[CDGenerateBackdoor.publicContexts, "INCLUDE", unspecRemoteContext];
[] _ CDProperties.Register[$CameFrom, [autoRem: TRUE]];
[] _ CDProperties.Register[$OriginalName, [autoRem: TRUE]];
END.


ψCDRemoteImpl.mesa (part of ChipNDale)
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, June 5, 1985 8:02:35 pm PDT
Last edited by: Christian Jacobi, October 20, 1986 12:56:51 pm PDT
--implements two methods of generator contexts
--contexts as exported from CDRemote: selecting an object from one specific remote design
--context "INCLUDE": generator key is designName.objectName; for any designName
-- entries of type REF NameRec
--this one even does not know what design to use
--test for silly case of using same design name
--caller MUST guarantee: remote will NEVER be changed
--  (but a different design with the same name might be cached later...)
--CDRemote guarantees: it will never change remote  
Κ
{˜
codeš
œ%™%Kšœ
Οm
œ7™BKš
œ8™8K™BK˜—šΟk	œ
˜
Kšžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ	˜	Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šΟnœžœ
ž˜Kšžœ;žœQ˜™
Kšžœ˜—Kš
ž˜K˜š
œ.™.Kš
œY™YKš
œO™O—K˜Kšžœžœžœ
˜K˜Kš
œ0˜0š
œ-˜-Kš
Οc!˜!Kš
œ™Kš	œ	žœžœžœžœ˜.—š
œ,˜,Kš
 !˜!—K˜šΟbœ%˜3Kš
œ:˜:Kšž
œ
˜K˜—š‘œ%˜-Kš
œ"˜"Kš
œS˜SKš
œ˜K˜—š‘œ'˜=K™0Kšœ
žœž
œ
žœ
˜2Kšœ
ž
œ˜)Kšœ& 8˜^šžœžœ˜&Kš
œ+˜+Kš
œ+˜+K˜—šžœžœžœ˜AKš
œ5˜5Kš
œ8˜8K˜
—KšžœQ˜UKš
œ˜—K˜šŸ
œžœžœžœ˜ZKšžœžœ
žœ˜*šžœ'žœ
ž˜6Kšœžœ˜#Kšžœžœ
˜—š
œZ˜ZKš	œžœžœžœžœ˜c—š
œ#˜#Kšžœ%žœ
žœ˜3Kš
œ˜—Kšžœ-žœ
žœ
˜;Kšžœ &˜HKš
œ˜—K˜šŸœžœ
žœžœ+žœžœ˜_Kš
œ7˜7Kš
œ1˜1Kš
œ˜—K˜š
Ÿ
œžœžœžœ	žœ˜Ošžœ"žœ
ž˜1Kšœžœžœ˜šžœ˜Kš
œ0˜0Kšžœ	žœ
žœ
žœ˜/Kš
œ˜——Kš
œ˜—K˜š
Ÿ
œžœ
žœžœ
žœ˜OKšœžœ˜&Kšžœžœ
žœ
žœ
˜Kš
œ˜—K˜š‘œ'˜7Kšœ'žœ
˜+K˜šŸ	œžœžœžœ
žœ
žœžœ˜bšžœžœ
žœžœ˜9Kš
œ8˜8Kš
ž˜Kš
œ˜—šžœ7žœ
ž˜FKšœžœ˜Kšžœžœ
˜—šžœžœ
žœ˜Kš
œ+˜+Kš
œ˜K˜—Kš
œ˜—K˜šΠbn	œ' "œ
˜Sšžœžœ˜Kšœžœ˜"Kšœžœ; ˜SKšœžœžœ/˜[Kšœžœ˜,K˜
—Kš
œ˜—K˜Kšœžœ˜Kšœžœ#˜2K™/šžœ*žœ˜2Kš
œ+˜+Kš
ž˜K˜—Kš
œ-˜-šžœžœ
žœ˜Kšœžœ6˜=šžœžœ
žœ˜Kš
œ˜Kš
œS˜Sšžœžœ
žœ˜šžœžœ˜Kš
œ8˜8šžœ
žœ
žœ
˜Kš
œR˜R—Kš
œ˜—Kšžœ
žœ6˜FKš
œ=˜=Kš
œ3˜3Kšžœ˜K˜—K˜—K˜—Kš
œ˜—K˜š
Ÿœžœ
žœžœžœ˜@Kš
œ5™5Kš
œH™HKš
œ4™4Kšœžœ/˜6Kšžœ"žœ
žœ
˜/Kšžœžœ
žœ8˜Fšžœ
˜Kš
œM˜M—Kš
œ˜K˜—šŸœžœ
žœžœžœ
žœ
žœ˜[Kšœžœ(˜/šžœ?žœ
ž˜NKšœžœ˜Kšžœžœ
˜—Kš
œ˜K˜—K˜š
Ÿœžœžœžœžœ˜MKšžœ!žœ
˜+K˜—K˜šŸœžœžœ ˜AKšœžœ0˜7Kšœ0žœ
˜4Kš
œ˜—K˜šŸ	œžœ
žœžœ-ž
œ
žœ
žœžœžœ
žœ˜„
Kšœžœ˜
Kš
žœ	žœžœ
žœžœ˜>Kš
œ*˜*Kšžœžœžœ˜,K˜—K˜šŸ	œžœžœžœžœžœ
žœ˜UšŸœžœžœ	žœžœ
žœ
žœ
žœ˜Ašžœžœ
ž˜šžœ/žœ
ž˜>Kš	œžœ
žœ
žœžœ˜ Kšžœžœ
˜——K˜—šŸ	œžœžœžœžœ
žœ˜0Kšœžœ˜Kšœžœ˜Kšžœžœžœžœ
˜HKšžœžœžœžœ
˜GKšžœžœ
žœ%˜>Kš
œ˜—Kšœžœ
žœ
žœ˜$Kšœžœžœ
˜š
žœžœ
žœ
žœžœžœ
ž˜8Kš
œ2˜2Kšžœžœ
žœ˜?Kšžœ
˜—Kš
œV˜VKš
œ˜—K˜šŸœžœžœžœžœ
žœžœ
žœžœ˜lKšœžœžœ
˜K˜šŸœžœžœžœ˜6Kšœžœ
žœ˜2Kšœžœ
˜šžœ,žœ˜4Kš
œ)˜)Kšžœ
žœžœh˜vK˜
—Kšžœ`˜dKš
œ˜—K˜Kšœžœ
˜Kš
œ=˜=Kšžœžœ,˜JKšœžœ-žœ ˜]Kšœ	žœ˜'šžœžœžœ
žœ˜)Kš	œžœžœ-žœžœ˜^Kšžœžœžœ
žœ˜PK˜—Kš	œ/žœžœ
žœ
žœ˜_Kš
œ˜—K˜K˜Kš
œž
˜ž
Kš
œV˜VKšœ0žœ˜7Kšœ4žœ˜;Kšžœ
˜K˜
—…— Ύ.1