DIRECTORY
CD,
CDAtomicObjects,
CDBasics,
CDCells, 
CDCommandOps,
CDCleanUp,
CDDirectory,
CDExtras,
CDImports,
CDMenus,
CDOps,
CDOrient,
CDCurves,
CDProperties,
CDRects,
CDSequencer,
CDSymbolicObjects, 
CDTexts,
CDViewer,
RefTab,
Rope,
TerminalIO;

CDConvertTechnology: CEDAR PROGRAM 
IMPORTS CD, CDBasics, CDAtomicObjects, CDCleanUp, CDCells, CDCommandOps, CDDirectory, CDExtras, CDImports, CDMenus, CDOps, CDOrient, CDCurves, CDProperties, CDRects, CDSymbolicObjects, CDTexts, CDViewer, RefTab, TerminalIO = 
BEGIN
fromTechnologyKey: ATOM_NIL;
toTechnologyKey: ATOM_NIL;
layerConversion: RefTab.Ref; 	-- layerkey => layerkey
classConversion: RefTab.Ref; 	-- object class key => key for atomic objects
classPosOffsets: RefTab.Ref; 	-- old object class key => CD.Position [offset in old coord system]
classSizeOffsets: RefTab.Ref; 	-- old object class key => CD.Position [offset in old coord system]

correspondKey: REF INT;
abortFlag: REF BOOL _ NEW[BOOL_FALSE];
design: CD.Design;
newDesign: CD.Design;
lambda: CD.Number;
newLambda: CD.Number;
oldTech: CD.Technology;
newTech: CD.Technology;

TRect: PROC [rect: CD.Rect] RETURNS [r: CD.Rect] =
BEGIN
r _ [x1: rect.x1*newLambda/lambda, x2: rect.x2*newLambda/lambda, y1: rect.y1*newLambda/lambda, y2: rect.y2*newLambda/lambda]
END;

TPos: PROC [pos: CD.Position] RETURNS [p: CD.Position] =
BEGIN
p _ [pos.x*newLambda/lambda, pos.y*newLambda/lambda]
END;

TNum: PROC [n: CD.Number] RETURNS [CD.Number] =
BEGIN
RETURN [n*newLambda/lambda]
END;

SizeOffset: PROC [oldOb: CD.Object] RETURNS [s: CD.Position] =
BEGIN
IF classSizeOffsets#NIL THEN 
WITH RefTab.Fetch[classSizeOffsets, oldOb.class.objectType].val SELECT FROM
p: REF CD.Position => s _ p^;
ENDCASE => NULL;
END; 

MustOffsetOrigin: PROC [oldOb: CD.Object] RETURNS [off: CD.Position _ [0, 0]] =
BEGIN
IF classPosOffsets#NIL THEN 
WITH RefTab.Fetch[classPosOffsets, oldOb.class.objectType].val SELECT FROM
p: REF CD.Position => off _ p^;
ENDCASE => NULL;
END; 

OriginPos: PROC [i: CD.Instance, point: CD.Position _ [0, 0]] RETURNS [p: CD.Position] =
BEGIN
RETURN [CDOrient.MapPoint[
pointInCell: CDBasics.AddPoints[point, CD.ClientOrigin[i.ob]],
cellSize: i.ob.size,
cellInstOrient: i.orientation,
cellInstPos: i.location
]]
END;

CorrespondingLayer: PROC [layer: CD.Layer] RETURNS [l: CD.Layer] =
BEGIN
key: ATOM _ CD.LayerKey[layer];
WITH RefTab.Fetch[layerConversion, key].val SELECT FROM
a: ATOM => l _ CD.FetchLayer[newTech, a];
ENDCASE => {
IF CD.LayerTechnology[layer]=NIL THEN RETURN [layer];
l _ CD.FetchLayer[newTech, CD.LayerKey[layer]]
}
END;

TransferAny: PROC [ob: CD.Object] RETURNS [new: CD.Object_NIL] =
BEGIN
WITH CDProperties.GetProp[ob, correspondKey] SELECT FROM
ob1: CD.Object => RETURN [ob1];
ENDCASE => NULL;
IF CDAtomicObjects.IsAtomicOb[ob] THEN new _ TransferAtomicObject[ob]
ELSE IF CDCells.IsCell[ob] THEN new _ TransferCell[ob]
ELSE IF ob.class.wireTyped THEN new _ TransferWire[ob]
ELSE IF CDSymbolicObjects.IsMark[ob] THEN new _ CDSymbolicObjects.CreateMark[]
ELSE IF CDTexts.IsText[ob] THEN new _ TransferText[ob]
ELSE IF CDImports.IsImport[ob] THEN new _ TransferImport[ob]
ELSE IF CDCurves.IsPolygon[ob] THEN new _ TransferPolygon[ob]
ELSE IF CDCurves.IsLine[ob] THEN new _ TransferLine[ob]
ELSE IF CDCurves.IsSpline[ob] THEN new _ TransferSpline[ob]
ELSE IF CDCurves.IsFilledCurve[ob] THEN new _ TransferFilledCurve[ob];
IF new=NIL THEN new _ TransferHard[ob];
IF new=NIL THEN TerminalIO.WriteRope["unknown object type\n"]
END;

GetAtomKey: PROC [a: ATOM] RETURNS [ATOM] =
BEGIN
WITH RefTab.Fetch[classConversion, a].val SELECT FROM 
aa: ATOM => RETURN [aa];
ENDCASE => RETURN [NIL];
END;

TransferAtomicObject: PROC [ob: CD.Object] RETURNS [new: CD.Object_NIL] =
BEGIN
newKey: ATOM _ GetAtomKey[ob.class.objectType];
sz: CD.Position _ CD.InterestSize[ob];
sz _ TPos[CDBasics.AddSize[sz, SizeOffset[ob]]];
IF newKey#NIL THEN {
new _ CDAtomicObjects.CreateAtomicOb[newKey, sz, newTech, CorrespondingLayer[ob.layer]];
}
END;

TransferHard: PROC [ob: CD.Object] RETURNS [new: CD.Object_NIL] =
BEGIN
ob1: CD.Object _ CDDirectory.Expand[ob, design, NIL].new;
IF ob1=NIL OR ob1=ob THEN ob1 _ CDDirectory.ExpandByDraw[ob];
IF ob1#NIL THEN {
new _ TransferWithChildrenCheck[ob1];
CDProperties.PutProp[ob, correspondKey, CDProperties.GetProp[ob1, correspondKey]];
}
END;

TransferWire: PROC [ob: CD.Object] RETURNS [new: CD.Object] =
BEGIN
new _ CDRects.CreateRect[TPos[CD.InterestSize[ob]], CorrespondingLayer[ob.layer]]
END;

TransferText: PROC [ob: CD.Object] RETURNS [new: CD.Object] =
BEGIN
tp: CDTexts.TextPtr _ NARROW[ob.specificRef];
font: CDTexts.CDFont;
font _ CDTexts.MakeFont[name: tp.cdFont.supposedName, scale: TNum[tp.cdFont.scaleI]];
new _ CDTexts.CreateText[text: tp.text, font: font, layer: CorrespondingLayer[ob.layer]];
END;

TransferImport: PROC [ob: CD.Object] RETURNS [new: CD.Object] =
BEGIN
ip: CDImports.ImportPtr _ NARROW[ob.specificRef];
newIp: CDImports.ImportPtr _ NEW[CDImports.ImportRep_[ir: TRect[ip.ir], objectName: ip.objectName, designName: ip.designName]];
new _ NEW[CD.ObjectRep_ob^];
new.properties _ NIL;
new.specificRef _ newIp;
new.size _ TPos[new.size];
[] _ CDDirectory.Include[newDesign, new, CDDirectory.Name[ob]]
END;

TransferPosList: PROC [ob: CD.Object] RETURNS [newPl: LIST OF CD.Position_NIL, w: CD.Number] = 
BEGIN
pp: CDCurves.CurvePtr _ NARROW[ob.specificRef];
FOR pl: LIST OF CD.Position _ pp.points, pl.rest WHILE pl#NIL DO
newPl _ CONS[TPos[pl.first], newPl];
ENDLOOP;
w _ pp.w
END;

TransferPolygon: PROC [ob: CD.Object] RETURNS [new: CD.Object] =
BEGIN
newPl: LIST OF CD.Position; w: CD.Number;
[newPl, w] _ TransferPosList[ob];
new _ CDCurves.CreatePolygon[newPl, CorrespondingLayer[ob.layer]].ob;
END;

TransferLine: PROC [ob: CD.Object] RETURNS [new: CD.Object] =
BEGIN
newPl: LIST OF CD.Position; w: CD.Number;
[newPl, w] _ TransferPosList[ob];
new _ CDCurves.CreateLine[newPl, w, CorrespondingLayer[ob.layer]].ob;
END;

TransferSpline: PROC [ob: CD.Object] RETURNS [new: CD.Object] =
BEGIN
newPl: LIST OF CD.Position; w: CD.Number;
[newPl, w] _ TransferPosList[ob];
new _ CDCurves.CreateSpline[newPl, w, CorrespondingLayer[ob.layer]].ob;
END;

TransferFilledCurve: PROC [ob: CD.Object] RETURNS [new: CD.Object] =
BEGIN
newPl: LIST OF CD.Position; w: CD.Number;
[newPl, w] _ TransferPosList[ob];
new _ CDCurves.CreateFilledCurve[newPl, CorrespondingLayer[ob.layer]].ob;
END;

TransferCell: PROC [ob: CD.Object] RETURNS [new: CD.Object] =
BEGIN
newChild: CD.Object;
cp: CD.CellPtr _ NARROW[ob.specificRef];
new _ CDCells.CreateEmptyCell[];
FOR il: CD.InstanceList _ cp.contents, il.rest WHILE il#NIL DO
inst: CD.Instance;
position: CD.Position _ TPos[CDBasics.SubPoints[OriginPos[il.first, MustOffsetOrigin[il.first.ob]], cp.origin]];
newChild _ TransferAny[il.first.ob];
IF newChild=NIL THEN LOOP;
inst _ CDCells.IncludeOb[design: NIL, cell: new, position: position, ob: newChild, orientation: il.first.orientation, cellCSystem: originCoords, obCSystem: originCoords, mode: dontPropagate].newInst;
CDProperties.AppendProps[winner: inst.properties, looser: il.first.properties, putOnto: inst];
ENDLOOP;
IF ~cp.useDIr THEN 
CDCells.SetInterestRect[new, 
TRect[CDBasics.MoveRect[cp.ir, CDBasics.NegOffset[CD.ClientOrigin[ob]]]]
];
[] _ CDCells.RepositionCell[new, NIL];
CDProperties.AppendProps[winner: new.properties, looser: ob.properties, putOnto: new];
[] _ CDDirectory.Include[newDesign, new, CDDirectory.Name[ob]]
END;

ReallyTransfer: PROC [ob: CD.Object] RETURNS [ob1: CD.Object] =
BEGIN
ob1 _ TransferAny[ob]
END;

TransferWithChildrenCheck: PROC [ob: CD.Object] RETURNS [ob1: CD.Object] =
BEGIN
EachChild: PROC [me: CD.Object, x: REF] = {
[] _ TransferWithChildrenCheck[me];
};
WITH CDProperties.GetProp[ob, correspondKey] SELECT FROM
obx: CD.Object => ob1 _ obx;
ENDCASE => {
CDDirectory.EnumerateChildObjects[ob, EachChild, NIL];
ob1 _ ReallyTransfer[ob];
CDProperties.PutProp[ob, correspondKey, ob1]
};
END;

Transfer: PROC [from: CD.Design, tech: CD.Technology] RETURNS [nD: CD.Design] =
BEGIN
EachDirEl: PROC [name: Rope.ROPE, ob: CD.Object] RETURNS [quit: BOOL_FALSE] = {
[] _ TransferWithChildrenCheck[ob];
};
dummyOb, newDummyOb: CD.Object;
design _ from;
correspondKey _ NEW[INT];
oldTech _ from.technology;
newTech _ tech;
newDesign _ nD _ CDOps.CreateDesign[tech];
CDExtras.PopToTopLevel[from];
dummyOb _ CDExtras.CreateDummyObject[from];
lambda _ oldTech.lambda;
newLambda _ newTech.lambda;
[] _ CDDirectory.Enumerate[design: from, action: EachDirEl];
newDummyOb _ TransferWithChildrenCheck[dummyOb];
[] _ CDCells.IncludeOb[design: newDesign, ob: newDummyOb];
CDCleanUp.RemoveProperties[from, correspondKey];
END;

ProtectedTransferComm: PROC [comm: CDSequencer.Command] =
BEGIN
t: CD.Technology;
d: CD.Design;
TerminalIO.WriteRope["transfer technology\n"];
IF comm.design.technology.key#fromTechnologyKey THEN {
TerminalIO.WriteRope["not right ""from"" technology set up\n"];
ERROR ABORTED
};
t _ CD.FetchTechnology[toTechnologyKey];
IF t=NIL THEN {
TerminalIO.WriteRope["the ""to"" technology is not loaded\n"];
ERROR ABORTED
};
[] _ CDCleanUp.CleanUp[comm.design];
d _ Transfer[comm.design, t];
[] _ CDViewer.CreateViewer[d];
END;


TransferComm: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["transfer technology\n"]; 
abortFlag^ _ FALSE;
[] _ CDCommandOps.CallWithResource[
proc: ProtectedTransferComm, 
comm: comm, 
resource: $CDTransferTecnology, 
abortFlag: abortFlag
];
END;

CDMenus.ImplementEntryCommand[menu: $ProgramMenu, entry: "convert to dragon cmos", p: TransferComm];
END. 



θCDConvertTechnology.mesa  (part of ChipNDale)
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
by Christian Jacobi, June 24, 1983 5:03 pm 
last edited Christian Jacobi, March 26, 1986 5:03:53 pm PST
Last Edited by: Jacobi July 9, 1986 8:34:02 pm PDT

--MUST BE SETUP USING INTERPRETER
--must be protected
--off in old coord system 
--point in origin coordinates of object i.ob is returned in world coordinates 
--dirty
--all children of ob are already transfereed
Κ
˜
codeš
œ-™-Kšœ
Οm
œ7™BKš
œ+™+Kš
œ;™;K™2—K˜š
Οk	˜	Kšžœ
˜K˜Kš
œ	˜	Kš
œ	˜	Kš
œ
˜
K˜
K˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ	˜	Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ˜K˜—šΠblœžœ
žœ
˜#KšžœΪ
˜α
—Kš
ž˜K™Kš
Ρbfl!™!Kšœžœ
˜Kšœžœ
˜KšœΟc˜5Kšœ‘-˜KKšœ‘C˜aKšœ‘C˜bK˜Kš
œ™Kšœžœ
žœ
˜Kšœžœ
žœžœ
žœ
žœ˜&Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœ	žœ˜Kšœ	žœ˜K˜š
Οnœžœžœžœžœ˜2Kš
ž˜Kš
œ|˜|Kšžœ
˜K˜—š
’œžœžœžœžœ˜8Kš
ž˜Kš
œ4˜4Kšžœ
˜K˜—š
’œžœžœ	žœžœ
˜/Kš
ž˜Kšžœ˜Kšžœ
˜—K˜š
’
œžœ	žœ	žœžœ˜>Kš
ž˜šžœžœ
žœ
˜šžœ<žœ
ž˜KJšœžœ
žœ˜Jšžœžœ
˜——Kšžœ˜—K˜š
’œžœ	žœ	žœžœ˜OKš
œ™Kš
ž˜šžœžœ
žœ
˜šžœ;žœ
ž˜JJšœžœ
žœ˜Jšžœžœ
˜——Kšžœ˜—K˜š’	œžœžœžœžœžœ˜XKš
œN™NKš
ž˜šžœ˜Kšœ'žœ˜>Kš
œ˜Kš
œ˜Kš
œ˜K˜—Kšžœ
˜—K˜š
’œžœ	žœžœžœ	˜BKš
ž˜Kšœžœžœ˜šžœ(žœ
ž˜7Kšœžœžœ˜)šžœ˜Kš
žœ
žœžœ
žœ
žœ	˜5Kšœžœžœ˜.K˜
——Kšžœ
˜—K˜š’œžœžœ	žœžœžœ˜@Kš
ž˜šžœ)žœ
ž˜8Kšœžœžœ˜Kšžœžœ
˜—Kšžœ žœ˜EKšžœ
žœžœ˜6Kšžœ
žœžœ˜6Kšžœ
žœžœ%˜NKšžœ
žœžœ˜6Kšžœ
žœžœ˜<Kšžœ
žœžœ˜=Kšžœ
žœžœ˜7Kšžœ
žœžœ˜;Kšžœ
žœžœ˜FKšžœžœ
žœ˜'Kšžœžœ
žœ.˜=Kšžœ
˜—K˜š
’
œžœžœžœžœ˜+Kš
ž˜šžœ&žœ
žœ
˜6Kšœžœžœ˜Kšžœžœžœ˜—Kšžœ
˜K˜—š’œžœžœ	žœžœžœ˜IKš
ž˜Kšœžœ#˜/Kšœžœ ˜&Kš
œ0˜0šžœžœ
žœ˜Kš
œX˜XK˜
—Kšžœ
˜—K˜š’œžœžœ	žœžœžœ˜AKš
ž˜Jšœžœ)žœ˜9Jšžœžœ
žœžœ$˜=šžœžœ
žœ˜Jš
œ%˜%Jš
œR˜RJ˜
—Kšžœ
˜—K˜š
’œžœžœ	žœžœ
˜=Kš
ž˜Kšœžœ1˜QKšžœ
˜—K˜š
’œžœžœ	žœžœ
˜=Kš
ž˜Jšœžœ˜-Kš
œ˜Kš
œU˜UKš
œY˜YKšžœ
˜—K˜š
’œžœžœ	žœžœ
˜?Kš
ž˜JšœΟb™Jšœžœ˜1Kšœžœ_˜Kšœžœ
žœ˜Kšœžœ
˜Kš
œ˜K˜Kš
œ>˜>Kšžœ
˜—K˜š’œžœžœ	žœ	žœ
žœ
žœ
žœžœ˜_Kš
ž˜Jšœžœ˜/š
žœžœ
žœ
žœžœžœ
ž˜@Jšœžœ˜$Jšžœ
˜—Kš
œ˜Kšžœ
˜—K˜š
’œžœžœ	žœžœ
˜@Kš
ž˜Kš	œžœ
žœ
žœžœ˜)Kš
œ!˜!Kš
œE˜EKšžœ
˜—K˜š
’œžœžœ	žœžœ
˜=Kš
ž˜Kš	œžœ
žœ
žœžœ˜)Kš
œ!˜!Kš
œE˜EKšžœ
˜—K˜š
’œžœžœ	žœžœ
˜?Kš
ž˜Kš	œžœ
žœ
žœžœ˜)Kš
œ!˜!Kš
œG˜GKšžœ
˜—K˜š
’œžœžœ	žœžœ
˜DKš
ž˜Kš	œžœ
žœ
žœžœ˜)Kš
œ!˜!Kš
œI˜IKšžœ
˜—K˜š
’œžœžœ	žœžœ
˜=Kš
ž˜Kšœ
žœ˜Kšœžœžœ˜(Kš
œ ˜ š	žœžœ%žœžœ
ž˜>Kšœžœ
˜Kšœ
žœd˜pKš
œ$˜$Kšžœ
žœ
žœ
žœ
˜Kšœ!žœ£
˜Η
Kš
œ^˜^Kšžœ
˜—šžœžœ
˜š
œ˜Kšœ2žœ˜HKš
œ˜——Kšœ!žœ˜&Kš
œV˜VKš
œ>˜>Kšžœ
˜—K˜š
Πbnœžœžœ	žœžœ
˜?Kš
œ,™,Kš
ž˜Kš
œ˜Kšžœ
˜—K˜š
’œžœžœ	žœžœ
˜JKš
ž˜š’	œžœžœžœ˜+Kš
œ#˜#Kš
œ˜—šžœ)žœ
ž˜8Kšœžœ˜šžœ˜Kšœ1žœ˜6Kš
œ˜Kš
œ,˜,K˜——Kšžœ
˜—K˜š’œžœžœžœ
žœžœ
˜OKš
ž˜š’	œžœ
žœžœ	žœžœ
žœ˜OKš
œ#˜#Kš
œ˜—Kš
œ˜Kš
œ˜Kšœžœ
žœ˜Kš
œ˜Kš
œ˜Kš
œ*˜*Kš
œ˜Kš
œ+˜+Kš
œ˜Kš
œ˜Kš
œ<˜<Kš
œ0˜0Kš
œ:˜:Kš
œ0˜0Kšžœ
˜—K˜š’œžœ˜9Kš
ž˜Kš
œ˜Kšœžœ˜
Kš
œ.˜.šžœ.žœ˜6Kš
œ?˜?Kšžœ
ž˜
K˜—Kšœžœ"˜(šžœžœ
žœ˜Kš
œ>˜>Kšžœ
ž˜
K˜—Kš
œ$˜$Kš
œ˜Kš
œ˜Kšžœ
˜K˜—K˜š’œžœ˜0Kš
ž˜Kš
œ/˜/Kšœ
žœ
˜š
œ#˜#Kš
œ˜Kš
œ˜Kš
œ ˜ Kš
œ˜Kš
œ˜—Kšžœ
˜—K˜Kš
œd˜dKšžœ˜K˜
—…—%840