DIRECTORY
D2Basic USING [Number, Pos, Rect],
Imager USING [Context, Color],
MBQueue USING [Queue],
Properties USING [PropList],
RefTab USING [Ref],
Rope USING [ROPE],
SymTab USING [Ref];

CD: CEDAR DEFINITIONS =
BEGIN


Number: TYPE = D2Basic.Number;
Position: TYPE = D2Basic.Pos;
Rect: TYPE = D2Basic.Rect;


Orientation: TYPE = [0..7] _ 0; 
original: Orientation = 0;


Error: ERROR [ec: ErrorCode _ programmingError, explanation: Rope.ROPE _ NIL];
ErrorCode: TYPE = {programmingError, callingError, noResource, doubleRegistration, missingRegistration, other};


PropList: TYPE = Properties.PropList;   
PropRef: TYPE = REF PropList _; --ABSOLUTELY NEVER NIL

InitPropRef: PROC [] RETURNS [PropRef] = INLINE {
RETURN [NEW[PropList_NIL]]
};

layerNum: NAT = 256;
Layer: TYPE = [0..layerNum);
combined: Layer = 0;  -- layer used for object containing different or unknown Layers
highLightShade: Layer = 1;  -- visualization; not for generating masks
highLightError: Layer = 2;  -- visualization; not for generating masks
backGround: Layer = 3; -- special pushed-in backGround; not for generating masks


NewLayer: PROC [technology: Technology, uniqueKey: ATOM] RETURNS [Layer];

FetchLayer: PROC [t: Technology, uniqueKey: ATOM] RETURNS [Layer];
LayerTechnology: PROC [l: Layer] RETURNS [Technology];
LayerKey: PROC [l: Layer] RETURNS [ATOM];



markNum: NAT = 256;

Object: TYPE = REF ObjectRep;

ObjectRep: TYPE = RECORD [
class: REF --READONLY-- ObjectClass, -- never modify class nor class^
size: Position _ [2, 2], 
layer: Layer _ combined,
marked: [0..markNum) _ 0,  --only objects with inDirectory are not shared through designs
specificRef: REF ANY _ NIL,
properties: PropList _ NIL  -- see warning
];

CellPtr: TYPE = REF CellRep;
CellRep: TYPE = RECORD [
contents: InstanceList _ NIL,
ir: Rect _ [0, 0, -1, -1], --actual interest rect
dIr: Rect _ [0, 0, -1, -1], --default value for interest rect
name: Rope.ROPE _ NIL,
simplifyOn: NAT _ LAST[NAT],
useDIr: BOOL _ TRUE, --should use the default for interest rect
origin: Position _ [0, 0]
];

RectPtr: TYPE = REF RectRep;
RectRep: TYPE = RECORD [filler: PRIVATE REF];

InstanceList: TYPE = LIST OF Instance_NIL;
Instance: TYPE = REF InstanceRep;
InstanceRep: TYPE = RECORD [
ob: Object,
location: Position _ [0, 0], --in cd-coords
orientation: Orientation _ 0,
selected: BOOL _ FALSE,
reserved: BOOL _ FALSE,
properties: PropList _ NIL 
];


ObjectClass: TYPE = RECORD [ -- generic procedures for an object
quickDrawMe: DrawProc,
drawMe: DrawProc,
showMeSelected: DrawProc,
hitInside: HitInsideProc,  
interestRect: RectProc,
oldInsideRect: RectProc,
technology: Technology,  -- NIL on technology independent stuff
objectType: ATOM,
inDirectory: BOOL, -- if inDirectory then included in directory;
directoryProcs: REF _ NIL,
wireTyped: BOOL _ FALSE, -- if wiretyped then insideRect.y corresponds length
symbolic: BOOL _ FALSE,  
reserved: BOOL _ FALSE, 
internalWrite: InternalWriteProc,
internalRead: InternalReadProc,
description: Rope.ROPE _ NIL,
describe: DescribeProc _ NIL,
describeInst: DescribeInstProc _ NIL,
origin: PosProc _ NIL, 
further: PRIVATE RefTab.Ref,
properties: PropRef _ NIL 
];

DrawProc: TYPE = PROC [inst: Instance, pos: Position, orient: Orientation, pr: REF DrawInformation];
HitInsideProc: TYPE = PROC [ob: Object, hitRect: Rect] RETURNS [BOOL];   
PosProc: TYPE = PROC [ob: Object] RETURNS [Position];
RectProc: TYPE = PROC [ob: Object] RETURNS [Rect];
BoolProc: TYPE = PROC [ob: Object] RETURNS [BOOL];
InternalWriteProc: TYPE = PROC [me: Object];
InternalReadProc: TYPE = PROC [] RETURNS [Object];
DescribeProc: TYPE = PROC [me: Object] RETURNS [Rope.ROPE];
DescribeInstProc: TYPE = PROC [ap: Instance] RETURNS [Rope.ROPE];
DrawContextProc: TYPE = PROC [pr: DrawRef, proc: DrawContextLayerProc, ob: Object, pos: Position, orient: Orientation, layer: Layer];
DrawContextLayerProc: TYPE = PROC [context: Imager.Context, ob: Object, layer: Layer];

RegisterObjectClass: PROC [objectType: ATOM, technology: Technology_NIL] RETURNS [REF ObjectClass]; 

FetchObjectClass: PROC [objectType: REF, technology: Technology_NIL] RETURNS [REF --readonly-- ObjectClass]; 



PushRec: TYPE = RECORD [
dummyCell: Instance,  
mightReplace: Instance_NIL,
specific: CellPtr, -- cache of dummyCell.ob.specificRef
changed: BOOL_FALSE,
indirectlyChanged: BOOL_FALSE,
deletedList: REF_NIL
];

Design: TYPE = REF DesignRec;
DesignRec: TYPE = RECORD [ -- use only CDOps.CreateDesign to create record
actual: LIST OF PushRec, -- actual.first is most deeply pushed cell; 
cellDirectory: PRIVATE CellTableRef, 
-- pushed cells are copied and not part of the cellDirectory
name: Rope.ROPE _ NIL,
technology: Technology _ NIL,
designValues: DesignValues _ NIL, --CDValue
queue: MBQueue.Queue,  
seqPrivate: SequencerRef,
privateDrawQueue: PRIVATE REF _ NIL,
properties: PropRef _
];

SequencerRef: TYPE = REF SequencerDesignPrivate;
SequencerDesignPrivate: TYPE;  
CellTableRef: PRIVATE TYPE = SymTab.Ref;
DesignValues: TYPE = REF DesignValuesRep; --CDValue
DesignValuesRep: TYPE; --CDValue


Technology: TYPE = REF TechnologyRep;
TechnologyRep: TYPE = RECORD [ 
-- use RegisterTechnology to create record
key: ATOM _ NIL,
name: Rope.ROPE _ NIL,
lambda: CD.Number _ 2,
technologyPrivate: PRIVATE TechnologyPrivate,
technologyValues: TechnologyValues, --CDValue
technologyCommands: TechnologyCommands, --CDSequencer
usedLayers: --READONLY-- LIST OF Layer, -- without constant Layers defined in CD
properties: PropRef _ 
];

TechnologyValues: TYPE = REF TechnologyValuesRep; --CDValue
TechnologyCommands: TYPE = REF TechnologyCommandsRep; --CDSequencer
TechnologyPrivate: TYPE = PRIVATE REF TechnologyPrivateRep; 

TechnologyValuesRep: TYPE; --CDValue
TechnologyCommandsRep: TYPE; --CDSequencer
TechnologyPrivateRep: TYPE;

RegisterTechnology: PROC [key: ATOM, name: Rope.ROPE _ NIL, lambda: CD.Number _ 2] RETURNS [Technology];

FetchTechnology: PROC [key: ATOM] RETURNS [Technology];
EnumerateTechnologies: PROC [proc: TechnologyEnumerator] RETURNS [quit: BOOL];
TechnologyEnumerator: TYPE = PROC[tech: CD.Technology] RETURNS [quit: BOOL_FALSE];


DrawRef: TYPE = REF DrawInformation;
DrawInformation: TYPE = RECORD [
interestClip: Rect, -- (interrest area; not device area), in doubt is larger;
minimalSize: Number, -- if xyz<minimalSize; xyz is not drawn the normal way (Cells)
scaleHint: REAL, -- to monitor simplifications; 0 means no simplifications
drawChild: DrawProc, 
drawRect: DrawRectProc, -- still world coordinates, how many bits do device coordinates use?
drawOutLine: DrawOutLineProc,  -- usefull for visualization only; not for generating masks
drawContext: DrawContextProc,
drawComment: DrawCommentProc,
stopFlag: REF BOOL,
environment: BOOL _ TRUE, --draw the outside of pushed in cells
symbolics: BOOL _ TRUE,  --draw symbolic objects
specialFonts: BOOL _ FALSE, --usually FALSE; replaces fonts
checkPriority: BOOL _ FALSE, --usually FALSE; priority of running process
priorityChecker: CheckPriorityProc _ NIL, --usually no-op
b4: PRIVATE BOOL _ TRUE, -- reserved for experiments 
b5: PRIVATE BOOL _ TRUE, -- reserved for experiments
setGround: SetGroundProc,
devicePrivate: REF _ NIL,  -- differentiate among multiple (viewers) with same drawProc's
deviceContext: Imager.Context _ NIL, --may or may not be used
viewerPrivate: ViewerPrivate _ NIL,  -- speed up for viewers devicePrivate
contextFilter: REF READONLY ContextFilter _ NIL,
design: Design _ NIL,
properties: PropRef _ 
];
ViewerPrivate: TYPE = REF ViewerPrivateRep;
ViewerPrivateRep: TYPE;

DrawRectProc: TYPE = PROC [r: Rect, l: Layer, pr: DrawRef];
DrawOutLineProc: TYPE = PROC [r: Rect, pr: DrawRef];
DrawCommentProc: TYPE = PROC [r: Rect, comment: Rope.ROPE, pr: DrawRef];
SetGroundProc: TYPE = PROC [pr: DrawRef, pushedOut: BOOL];
CheckPriorityProc: TYPE = PROC [pr: DrawRef];

ContextFilter: TYPE = ARRAY Layer OF Imager.Color;


CreateDrawRef: PROC [design: Design, deviceContext: Imager.Context _ NIL] RETURNS [DrawRef];



InterestRect: PROC [ob: Object] RETURNS [r: Rect] = INLINE {
RETURN [ob.class.interestRect[ob]]
};

InterestSize: PROC [ob: Object] RETURNS [sz: Position] = INLINE {
r: CD.Rect = ob.class.interestRect[ob];
RETURN [[r.x2-r.x1, r.y2-r.y1]];
};

ClientOrigin: PROC [ob: Object] RETURNS [pos: Position] = INLINE {
RETURN [ob.class.origin[ob]]
};

END.

PCD.mesa;   Main definitions for ChipNDale, a VLSI design editor
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
by Ch. Jacobi,  June 24, 1983 3:54 pm
last edited Christian Jacobi,  September 20, 1985 2:42:01 pm PDT
-- CD: ChipNDale, a VLSI design editor and data base
-- measures
-- independent of coordinate system
-- RECORD [x, y: Number];
-- RECORD [x1, y1, x2, y2: Number];
--A Rect is called normalized if (x1>x2) OR (y1>y2) means that the Rect is empty.
--Rects are normalized, except if a special comment denies. 
--Rect's are closed: they include all the endpoints; as you expect, points have 
--size 0; except if a special comment denies.
-- Module CDOrient exports all you probably need about Orientations;
-- If your program depends on the representation of Orientation, it
-- is probably wrong.
-- Errors
-- properties
--Friendly use expected: don't assign properties without first register  
--their names with CDProperties.
--Use only CDProperties to access ChipNDale PropList; NOT Properties
--Unprotected enumeration is highly not recomended; ChipNDale might
--re-order the list asynchronously.

-- Layers
-- may raise Error[noResource] and others
-- the technolgy implementation must guarantee for uniqueness of uniqueKey's
-- (unique only for the technology)
--object, cells, instances
--Objects are the main things in ChipNDale
--Objects must draw the same way independant of their environment
-- Several instances may point to same object: consider on modifications.
-- Some implementors of object-classes share the bits of different ObjectRep's
-- (therefore usage of properties of Objects not in the directory is restricted to 
-- the object class implentor.)
-- all object classes which have children must be in the directory
--ignores inst.location and inst.orientation, may use inst.properties
--may raise Error[doubleRegistration] and others
--Also initializes procedures with default values 
--An object type may be used either in arbitrary technology or technology-independent.
--This should be the only way to create data of type ObjectProcsRec
--may raise Error[missingRegistration]  
--consider ObjectClass as readonly if you are not the implementor of the object type 
-- Design
originally a copy of mightReplace; warning: size may be wrong
--CDValue supports more fields 
-- Technology

-- consider all fields read only
--CDValue supports more fields
--This must be the only way to create data of type TechnologyRep
--may raise Error[doubleRegistration] and others
--may raise Error[missingRegistration] and others


-- drawing
--special flags for certain hacks; not known by all devices
-- DrawInformation records should not be copied unless the state of drawing is
-- separately initialized.

--Allows to specify an application specific mapping of layers to colors
--A NIL color entry means the layer is invisible
-- for conveniance; assigns usefull null procedures and default values.
--vanilla procedures
-- Returns the interest rect in objects internal cd coords
-- Returns the size of the interest rect 
-- Returns the position of the client's object origin in objects internal cd coords
ΚY˜
codeš
œ?™?Kšœ
Οm
œ7™BKš
œ%™%Kš
œ@™@—K˜š
Οk	˜	Kšœžœ˜"Kšœžœ˜Kšœžœ	˜Kšœžœ˜Kšœžœ˜Kšœžœžœ˜Kšœžœ˜—K˜šΠlnœžœ
žœ˜Kš
œ4™4—Kš
ž˜K˜Kš
œ™˜Kš
œ#™#—Kšœžœ
ž
œ˜šœ
žœ
ž
œ˜Kšœžœ™—šœžœ˜Kšœžœ™#Kš
œQ™QK™<Kš
œP™PKš
œ-™-K˜—K˜šœ
žœ˜ Kš
œD™DKš
œC™CKš
œ™—K˜K˜Kš
œ	™	K˜KšΟbœžœ6žœžœ˜NKšœžœ`˜oK˜Kš
œ
™
K˜šœ
žœ˜(Kš
œI™IKš
œ ™ Kš
œD™DKš
œC™CK™#—šœ	žœžœ
Οc˜6K˜—šΟnœžœžœ
žœ˜1Kšžœžœ
žœ˜K˜—K™Kš
œ	™	K˜Kšœ
žœ˜šœžœ˜Kšœ‘œ‘7˜UKšœ‘œ‘˜FKšœ‘œ‘˜FKšœ‘œ‘˜PK˜K˜—š’œžœ%žœžœ	˜IKš
œ)™)Kš
œL™LKš
œ#™#K˜—Kš’
œžœžœžœ	˜BKš’œžœžœ˜6š’œžœžœžœ˜)K˜—K˜Kš
œ™K˜Kšœ	žœ˜K˜šœžœžœ˜K™*K™AK˜—šœžœžœ˜Kšœžœ
‘œ‘ ˜EK˜Kš
œ˜Kšœ‘>˜YKšœ
žœ
žœžœ
˜Kšœžœ‘˜*K˜Kš
œI™IKš
œN™NKš
œS™SKš
œ™K˜—Kšœ	žœžœ	˜šœ	žœžœ˜Kšœžœ
˜Kšœ‘˜1Kšœ‘"˜=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˜K˜Kšœ‘&˜?Kšœžœ
˜šœ
žœ‘-˜@Kš
œB™BKšœžœžœ
˜—Kšœžœ‘4˜MKšœ
žœ‘
˜Kšœ
žœ˜K˜!K˜Kšœžœžœ
˜Kšœžœ
˜Kšœ žœ
˜%Kšœžœ
˜Kšœ	žœ˜Kšœžœ
˜K˜K˜—šœ
žœžœ:žœ˜dKš
œE™E—Kš	œžœžœžœžœ˜IKšœ	žœžœžœ˜5Kšœ
žœžœžœ˜2Kš	œ
žœžœžœžœ˜2Kšœžœžœ˜,Kšœžœžœžœ
˜2Kš	œžœžœžœžœ˜;Kš	œžœžœžœžœ˜AKšœžœžœi˜…
Kšœžœžœ5˜VK˜š’œžœžœžœžœžœ˜dKš
œ0™0Kš
œ2™2Kš
œV™VKš
œC™CK˜—š’œžœžœžœžœžœ
‘œ˜mKš
œ(™(Kš
œU™UK˜—K˜Kš
œ	™	K˜šœ	žœžœ˜š
œ˜Kš
œ=™=—Kšœžœ
˜Kšœ‘$˜7Kšœ	žœ
žœ
˜Kšœžœ
žœ
˜Kšœ
žœ
ž˜K˜K˜—Kšœžœžœ˜šœžœžœ‘/˜JKšœžœ
žœ
‘,˜Ešœžœ˜%Kš
‘<˜<—Kšœžœ
žœ
˜Kšœžœ
˜Kšœžœ‘	˜+Kš
œ˜Kš
œ˜Kšœžœ
žœž˜$Kš
œ˜Kš
œ™K˜K˜Kšœžœžœ˜0Kšœžœ‘
˜Kšœžœ˜(Kšœžœžœ‘	˜3Kšœžœ
‘
˜ K˜—K˜Kš
œ
™
K™Kšœžœžœ˜%šœžœžœ˜Kš
‘*˜*Kš
œ ™ Kšœžœžœ
˜Kšœžœ
žœ
˜Kšœžœ˜Kšœžœ˜-Kšœ$‘	˜-Kšœ(‘
˜5Kšœžœ
žœ‘(˜PKšœž
˜Kš
‘™K˜K˜Kšœžœžœ‘
˜;Kšœžœžœ‘
˜CKšœžœžœ
žœ˜<K˜Kšœžœ‘	˜$Kšœžœ‘
˜*Kšœžœ
˜K˜—š’œžœžœ
žœžœ
žœ
žœ˜hKš
œ@™@Kš
œ0™0K˜—š’œžœžœžœ˜7Kš
œ1™1K™—š’œžœžœžœ˜NKš
œžœžœžœ
žœžœ
žœ˜RK˜—K™Kš
œ
™
K˜Kšœ	žœžœ˜$šœžœžœ˜ Kšœ‘9˜MKšœ‘>˜SKšœžœ‘9˜JKš
œ˜Kšœ‘D˜\Kšœ‘;˜ZK˜K˜Kšœ
žœ
žœ
˜™;Kšœ
žœžœ‘%˜?Kšœžœžœ‘˜0Kšœžœžœ‘˜;Kšœžœžœ‘,˜IKšœ%žœ‘˜9Kšœžœžœ‘œ
˜5Kšœžœžœ‘˜4Kš
œ˜Kšœž	œ‘>˜YKšœ žœ‘˜=Kšœžœ‘%˜J—Kšœžœ
žœžœ
˜0Kšœžœ
˜Kš
œ˜˜Kšœ;‘œ™NKš
œ™—Kšœžœžœ˜+Kšœžœ
˜K˜—Kšœžœžœ!˜;Kšœžœžœ˜4Kšœžœžœ,˜HKšœžœžœžœ˜:šœžœžœ˜-K˜—šœžœžœžœ˜2Kš
œG™GKš
œ0™0K˜K˜—š’
œžœ1žœžœ˜\Kš
œG™GK˜—K˜K™K˜š’œžœžœ
žœ˜<Kš
œ:™:Kšžœ˜"K˜K˜—š’œžœžœžœ˜AKš
œ)™)Kš
œ'˜'Kšžœ˜ K˜K˜—šΠbnœžœžœžœ˜BKš
œS™SKšžœ˜K˜—K˜Kšžœ
˜K˜—…— †9/