
<<CDImportCommands.mesa   (part of Chipndale)>>
<<Copyright © 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>>

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;


<<--xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx>>
<<--multi-design-copy feature>>

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] =
<<--never returns with both foundNamed and foundWithoutChildren set to true>>
<<--if not found then message to TerminalIO>>
<<--if foundNamed then both, moduleName, objectName # NIL>>
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.