DIRECTORY
CD,
CDCallSpecific, 
CDDirectory,
CDImports,
CDIO,
CDOps,
CDProperties,
CDSequencer,
Rope,
TerminalIO;

CDImportCommands: CEDAR PROGRAM 
IMPORTS CDDirectory, CDImports, CDIO, CDOps, CDSequencer, Rope, TerminalIO =
BEGIN

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

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

GetImportedEntryCommand: PROC [comm: CDSequencer.Command] =
BEGIN
importeeName, objectName: Rope.ROPE;
referenceOb, referedOb: CD.ObPtr;
found: BOOLEAN;
import: REF Import;
TerminalIO.WriteRope["draw object of imported design; "];
importeeName _ TerminalIO.RequestRope["design > "! TerminalIO.UserAbort => {GOTO aborted}];
IF Rope.IsEmpty[importeeName] THEN {
TerminalIO.WriteRope[" empty name; not done\n"];
RETURN
};
import _ CDImports.GetImport[design: comm.design, importeeName: importeeName, createIfNotFound: false];
IF import=NIL OR import.importee=NIL THEN {
TerminalIO.WriteRope["design "];
TerminalIO.WriteRope[importeeName];
TerminalIO.WriteRope[" not yet loaded; not done\n"];
RETURN
};
objectName _ TerminalIO.RequestRope["entry > "! TerminalIO.UserAbort => {GOTO aborted}];
[found, referedOb] _ CDDirectory.Fetch[import.importee, objectName];
IF NOT found THEN {
TerminalIO.WriteRope[objectName]; 
TerminalIO.WriteRope[" not found in design "];
TerminalIO.WriteRope[importeeName]; 
TerminalIO.WriteRope["; not done\n"];
RETURN
};
referenceOb _ CDImports.GetReference[design: comm.design, objectName: objectName, importeeName: importeeName];
CDOps.AddAnObject[design: comm.design, ob: referenceOb, location: comm.pos];
EXITS
aborted => NULL;
END;


DisplayImports: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope[comm.design.name];
TerminalIO.WriteRope["'s import list: "];
TerminalIO.WriteRope[comm.design.name];
TerminalIO.WriteRope["\n"];
FOR list: LIST OF REF Import _ CDImports.GetImportList[comm.design]^, list.rest WHILE list#NIL DO
TerminalIO.WriteRope["   "];
TerminalIO.WriteRope[list.first.importeeName];
TerminalIO.WriteRope[IF list.first.importee=NIL THEN " -\n" ELSE " +\n"];
ENDLOOP; 
TerminalIO.WriteRope["---\n"]
END;

DisplayImportedEntries: PROC [comm: CDSequencer.Command] =
BEGIN
hasNotBound: BOOL _ FALSE;  -- if importee loaded
importeeName: Rope.ROPE;
mdata: REF Import;
TerminalIO.WriteRope["display used entries of imported design\n"];
importeeName _ TerminalIO.RequestRope["design > "];
mdata _ CDImports.GetImport[comm.design, importeeName, false];
TerminalIO.WriteRope[importeeName];
IF mdata=NIL THEN {
TerminalIO.WriteRope[" not imported\n"];
RETURN
}
ELSE {
IF mdata.importee#NIL THEN TerminalIO.WriteRope[" already loaded\n"] 
ELSE TerminalIO.WriteRope[" not yet loaded\n"];
FOR list: LIST OF CD.ObPtr _ mdata.referenceList, list.rest WHILE list#NIL DO
rp: ReferencePtr ~ NARROW[list.first.specificRef];
TerminalIO.WriteRope["   "];
TerminalIO.WriteRope[CDDirectory.Name[list.first]];
TerminalIO.WriteRope["  ("];
TerminalIO.WriteRope[rp.objectName];
TerminalIO.WriteRope[")"];
IF rp.boundApp=NIL AND mdata.importee#NIL THEN {
hasNotBound_TRUE; 
TerminalIO.WriteRope[" not bound"];
};
TerminalIO.WriteRope["\n"];
ENDLOOP; 
TerminalIO.WriteRope["---"];
IF hasNotBound THEN {
TerminalIO.WriteRope[" has not-bound entries"];
RETURN
};
TerminalIO.WriteRope["\n"]
};
END;

ImportReadCommand: PROC [comm: CDSequencer.Command] = 
BEGIN

Check: PROC [design: CD.Design] RETURNS [ok: BOOL] =
BEGIN
ok _ design.technology=comm.design.technology;
IF NOT ok THEN { 
TerminalIO.WriteRope["Technology missmatch: includee is "];
TerminalIO.WriteRope[design.technology.name];
TerminalIO.WriteRope["\n"];
RETURN
};
ok _ NOT Rope.Equal[comm.design.name, CDIO.DesignInReadOperation[].name];
IF NOT ok THEN { 
TerminalIO.WriteRope["design can not be imported, it has same name\n"];
};
END;

done: BOOL _ FALSE;
design: CD.Design;
TerminalIO.WriteRope["load a design for import\n"];
[] _ CDIO.UseWorkingDirectory[comm.design];
design _ CDIO.ReadDesign[NIL, Check];
IF design#NIL THEN {
done _ CDImports.DoImport[design: comm.design, importee: design, allowOverload: interactive, allowConflicts: interactive];
};
TerminalIO.WriteRope[IF done THEN "done\n" ELSE "not done\n"];
END;

MerginImportCommand: PROC [comm: CDSequencer.Command] = 
BEGIN
importeeName: Rope.ROPE;
mdata: REF Import;
TerminalIO.WriteRope["merge imports into the design\n"];
importeeName _ TerminalIO.RequestRope["imported design > "];
mdata _ CDImports.GetImport[comm.design, importeeName, false];
IF mdata=NIL THEN {
TerminalIO.WriteRope[importeeName];
TerminalIO.WriteRope[" not imported; not done\n"];
RETURN
}
ELSE IF mdata.importee=NIL THEN {
TerminalIO.WriteRope[importeeName];
TerminalIO.WriteRope[" is not yet loaded; not done\n"];
RETURN
};
CDImports.MergeInImport[design: comm.design, importeeName: importeeName];
TerminalIO.WriteRope["end merge\n"];
END;



selectedDesign: CD.Design _ NIL;
SelectADesign: PROC [comm: CDSequencer.Command] = 
BEGIN
TerminalIO.WriteRope["select "];
TerminalIO.WriteRope[comm.design.name];
TerminalIO.WriteRope[" for inter-design source\n"];
selectedDesign _ comm.design;
END;

GlobalSelection: PROC [expectedTechnology: CD.Technology] RETURNS [foundNamed: BOOL_FALSE, foundWithoutChildren: BOOL_FALSE, moduleName: Rope.ROPE_NIL, objectName: Rope.ROPE_NIL, object: CD.ObPtr_NIL, orient: CD.Orientation_CD.original] =
BEGIN
Out: PROC [t: Rope.ROPE] = {TerminalIO.WriteRope[t]};
from: CD.Design = selectedDesign;  -- so it does not change
IF from=NIL THEN Out["  no selected design"]
ELSE {
fromName: Rope.ROPE = from.name; -- so it does not change 
IF Rope.IsEmpty[fromName] THEN Out["  selected design has no name"]
ELSE IF expectedTechnology#from.technology AND expectedTechnology#NIL THEN
Out["  different technologies"]
ELSE {
ap: CD.ApplicationPtr;  -- the referred application to support the name
multiple: BOOLEAN; 
[ap, multiple] _ CDOps.SelectedApplication[from];
IF multiple THEN Out["   multiple selection"] 
ELSE IF ap=NIL THEN Out["   no selection"] 
ELSE {
orient _ ap.orientation;
IF NOT ap.ob.p.inDirectory THEN {
object _ ap.ob;
foundWithoutChildren _ TRUE;
}
ELSE {
entryName: Rope.ROPE = CDDirectory.Name[ap.ob];
IF Rope.IsEmpty[entryName] THEN Out["   object has no name"]
ELSE {
moduleName _ fromName;
objectName _ entryName;
foundNamed _ TRUE;
}
}
}
}
}
END;

DrawImportedCopy: PROC [comm: CDSequencer.Command] = 
BEGIN
foundNamed: BOOL;
foundWithoutChildren: BOOL;
moduleName: Rope.ROPE;
objectName: Rope.ROPE;
referenceOb, referedOb: CD.ObPtr;
orient: CD.Orientation;
TerminalIO.WriteRope["draw corresponding object (import);  "];
[foundNamed: foundNamed, foundWithoutChildren: foundWithoutChildren, moduleName: moduleName, objectName: objectName, object: referedOb, orient: orient] _ GlobalSelection[comm.design.technology];
IF foundNamed THEN {
import: REF Import ~ CDImports.GetImport[design: comm.design, importeeName: moduleName, createIfNotFound: false];
IF Rope.Equal[moduleName, comm.design.name] THEN {
TerminalIO.WriteRope["  don't refer itself; not done\n "];
RETURN
};
IF import=NIL OR import.importee=NIL THEN {
TerminalIO.WriteRope["  design "];
TerminalIO.WriteRope[moduleName];
TerminalIO.WriteRope[" not yet loaded; not done\n"];
RETURN
};
[foundNamed, referedOb] _ CDDirectory.Fetch[import.importee, objectName];
IF NOT foundNamed THEN {
TerminalIO.WriteRope["  "];
TerminalIO.WriteRope[objectName]; 
TerminalIO.WriteRope[" not found in imported design "];
TerminalIO.WriteRope[moduleName]; 
TerminalIO.WriteRope["; not done\n"];
RETURN
};
referenceOb _ CDImports.GetReference[design: comm.design, objectName: objectName, importeeName: moduleName];
IF referenceOb=NIL THEN {
TerminalIO.WriteRope["  NIL object; not done\n"];
RETURN
};
CDOps.AddAnObject[design: comm.design, ob: referenceOb, location: comm.pos, orientation: orient];
TerminalIO.WriteRope[CDOps.Info[referenceOb]];
TerminalIO.WriteRope[" included\n"];
}
ELSE IF foundWithoutChildren THEN {
CDOps.AddAnObject[design: comm.design, ob: referedOb, location: comm.pos, orientation: orient];
TerminalIO.WriteRope[CDOps.Info[referedOb]];
TerminalIO.WriteRope["  copied\n"];
}
ELSE TerminalIO.WriteRope["; not done\n"];
END;

CDSequencer.ImplementCommand[$DrawImported, GetImportedEntryCommand];
CDSequencer.ImplementCommand[$DisplayImports, DisplayImports,, doQueue];
CDSequencer.ImplementCommand[$DisplayImportedEntries, DisplayImportedEntries,, doQueue];
CDSequencer.ImplementCommand[$ImportADesign, ImportReadCommand];
CDSequencer.ImplementCommand[$SelectADesign, SelectADesign,, doQueue];
CDSequencer.ImplementCommand[$DrawCorrespondingObject, DrawImportedCopy];
CDSequencer.ImplementCommand[$MerginImport, MerginImportCommand];
END. 


ΨCDImportCommands.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,   January 30, 1985 4:57:55 pm PST

--xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--multi-design-copy feature
--never returns with both foundNamed and foundWithoutChildren set to true
--if not found then message to TerminalIO
--if foundNamed then both, moduleName, objectName # NIL

Κ	Ϋ˜š
œ+™+Jšœ
Οm
œ7™BJš
œ5™5Jš
œ?™?—J˜š
Οk	˜	Jšžœ
˜J˜J˜Jš
œ
˜
Jš
œ˜Jš
œ˜J˜
Jš
œ˜Jš
œ˜Jš
œ˜J˜—šΟbœžœ
žœ
˜ JšžœE˜L—Jš
ž˜J˜Jšœžœ˜-Jšœžœ˜,J˜Jšœžœ˜(Jšœžœ˜ J˜šΠbnœžœ˜;Jš
ž˜Jšœžœ
˜$Jšœžœ˜!Jšœžœ
˜Jšœžœ˜J˜9JšœLžœ˜[šžœžœ˜$Jš
œ0˜0Jš
ž˜J˜—Jš
œg˜gš
žœžœ
žœžœ
žœ˜+Jš
œ ˜ Jš
œ#˜#Jš
œ4˜4Jš
ž˜J˜—JšœIžœ˜XJš
œD˜Dšžœ
žœžœ˜Jš
œ"˜"Jš
œ.˜.Jš
œ$˜$Jš
œ%˜%Jš
ž˜Jš
œ˜—Jš
œn˜nJš
œL˜Lš
ž˜Jšœžœ
˜—Jšžœ
˜—J˜J˜šΟnœžœ˜2Jš
ž˜Jš
œ'˜'Jš
œ)˜)Jš
œ'˜'J˜š
žœžœ
žœ
žœ;žœžœ
ž˜aJš
œ˜Jš
œ.˜.Jš	œžœžœ
žœžœ	˜IJšžœ˜	—Jš
œ˜Jšžœ
˜J˜—J™š‘œžœ˜:Jš
ž˜Jšœ
žœžœΟc˜1Jšœžœ
˜Jšœžœ˜Jš
œB˜BJš
œ3˜3Jš
œ>˜>Jš
œ#˜#šžœžœ
žœ˜Jš
œ(˜(Jš
ž˜J˜
—šžœ˜Jšžœžœ
žœ+˜EJšžœ+˜/š
žœžœ
žœ
žœ(žœžœ
ž˜MJšœžœ˜2Jš
œ˜Jš
œ3˜3Jš
œ˜Jš
œ$˜$Jš
œ˜š
žœ
žœ
žœžœ
žœ˜0Jšœžœ˜Jš
œ#˜#J˜—Jš
œ˜Jšžœ˜	—Jš
œ˜šžœ
žœ˜Jš
œ/˜/Jš
ž˜J˜—Jš
œ˜J˜—Jšžœ
˜J˜—š‘œžœ˜6Jš
ž˜J˜š
‘œžœ
žœ	žœžœ˜4Jš
ž˜Jš
œ.˜.šžœ
žœžœ˜Jš
œ;˜;Jš
œ-˜-Jš
œ˜Jš
ž˜J˜—Jšœžœžœ˜Išžœ
žœžœ˜Jš
œG˜GJ˜—Jšžœ
˜—J˜Jšœžœžœ
˜Jšœžœ˜Jš
œ3˜3Icodeš
œ+˜+Kšœžœ	˜%šžœžœ
žœ˜Jš
œz˜zJ˜—Jšœžœžœ
žœ˜>Jšžœ
˜—J˜š‘œžœ˜8Jš
ž˜Jšœžœ
˜Jšœžœ˜Jš
œ8˜8Jš
œ<˜<Jš
œ>˜>šžœžœ
žœ˜Jš
œ#˜#Jš
œ2˜2Jš
ž˜J˜
—šžœ
žœžœ
žœ˜!Jš
œ#˜#Jš
œ7˜7Jš
ž˜J˜—Kš
œI˜IJš
œ$˜$Jšžœ
˜—J˜J˜Jš
œ"™"Jš
œ™J˜Jšœžœ
žœ
˜ š‘
œžœ˜2Jš
ž˜Jš
œ ˜ Jš
œ'˜'Jš
œ3˜3Jš
œ˜Jšžœ
˜—J˜š ‘œžœžœ
žœžœ
žœžœ
žœžœ
žœžœ
žœ
žœžœ
žœ
žœ˜ξ
Jš
œI™IJš
œ)™)Jš
œ7™7Jš
ž˜Jš‘œžœ
žœ˜5Jšœžœ’˜;Jšžœžœ
žœ˜,šžœ˜Jšœžœ’˜:Jšžœžœ%˜Cš	žœ
žœ$žœžœ
ž˜JJš
œ˜—šžœ˜Jšœžœ’/˜GJšœ
žœ˜Jš
œ1˜1Jšžœ
žœ˜.Jšžœ
žœžœ
žœ˜+šžœ˜Jš
œ˜šžœ
žœžœ˜!Jš
œ˜Jšœžœ
˜Jš
œ
˜
—šžœ˜Jšœžœ˜/Jšžœžœ˜<šžœ˜Jš
œ˜Jš
œ˜Jšœ
žœ
˜J˜
—J˜
—J˜
—J˜
—J˜
—Jšžœ
˜—J˜š‘œžœ˜5Jš
ž˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ˜!Jšœžœ
˜Jš
œ>˜>Jš
œΒ
˜Β
šžœžœ˜Jšœžœf˜qšžœ*žœ˜2Jš
œ:˜:Jš
ž˜J˜—š
žœžœ
žœžœ
žœ˜+Jš
œ"˜"Jš
œ!˜!Jš
œ4˜4Jš
ž˜J˜—Jš
œI˜Išžœ
žœžœ˜Jš
œ˜Jš
œ"˜"Jš
œ7˜7Jš
œ"˜"Jš
œ%˜%Jš
ž˜Jš
œ˜—Jš
œl˜lšžœ
žœ
žœ˜Jš
œ1˜1Jš
ž˜J˜—Jš
œa˜aJš
œ.˜.Jš
œ$˜$Jš
œ
˜
—šžœ
žœžœ˜#Jš
œ_˜_Jš
œ,˜,Jš
œ#˜#Jš
œ
˜
—Jšžœ&˜*Jšžœ
˜—J™J˜Jš
œE˜EJš
œH˜HJš
œX˜XJš
œ@˜@Jš
œF˜FJš
œI˜IJš
œA˜AJšžœ˜J˜—…—!τ-§