DIRECTORY
CDProperties,
CDPropertyTools,
CD,
CDPrivate,
Atom,
Commander,
CommandTool,
List,
Properties,
RefTab,
Rope,
RopeList,
RuntimeError USING [UNCAUGHT],
TokenIO,
UserProfile USING [Boolean],
ViewerTools USING [TiogaContents, TiogaContentsRec];

CDPropertiesImpl: CEDAR MONITOR 
IMPORTS CD, CDPrivate, CDProperties, Atom, Commander, CommandTool, List, Properties, RefTab, Rope, RopeList, RuntimeError, TokenIO, UserProfile 
EXPORTS CDProperties, CDPropertyTools =
BEGIN

PropList: TYPE = CD.PropList;
PropertyProcs: TYPE = CDProperties.PropertyProcs;
PropertyProcsRec: TYPE = CDProperties.PropertyProcsRec;

atomTab: RefTab.Ref = RefTab.Create[]; 
-- contains atoms [maybe in future ref's] where properties hang


propertyNameTab: RefTab.Ref = RefTab.Create[]; -- key: propertynames; value: PropertyProcs
registrationTab: RefTab.Ref = RefTab.Create[]; -- contains registrationKeys

RegisterProperty: PUBLIC ENTRY PROC [prop: REF, registrationKey: REF_NIL] RETURNS [first: BOOL_TRUE] = {
val: REF ANY; found: BOOL;
[found, val] _ RefTab.Fetch[registrationTab, prop];  -- returns a registration key
IF found THEN {
IF registrationKey#NIL AND registrationKey=val THEN RETURN [FALSE];
RETURN WITH ERROR CD.Error[doubleRegistration]
}
ELSE {
pp: PropertyProcs _ NEW[PropertyProcsRec_[key: prop]];
[] _ RefTab.Insert[propertyNameTab, prop, pp]; -- procs
[] _ RefTab.Insert[registrationTab, prop, registrationKey]; -- registration
};
};



Err: ERROR = CODE;

PutProp: PUBLIC PROC [onto: REF, prop: REF, val: REF] = {
WITH onto SELECT FROM
a: CD.Instance => PutInstanceProp[a, prop, val];
o: CD.Object => PutObjectProp[o, prop, val];
pr: CD.PropRef => PutPRefProp[pr, prop, val];
d: CD.Design => PutDesignProp[d, prop, val];
t: CD.Technology => PutTechnologyProp[t, prop, val];
at: ATOM => PutAtomProp[at, prop, val];
class: CD.ObjectClass => PutObjectClassProp[class, prop, val];
pp: PropertyProcs  => PutPropertyClassProp[pp, prop, val];
pl: Properties.PropList => RETURN WITH ERROR Err; --explicitely forbidden
ENDCASE => RETURN WITH ERROR Err
};

GetProp: PUBLIC ENTRY PROC [from: REF, prop: REF] RETURNS [REF] = {
ENABLE UNWIND => NULL;
WITH from SELECT FROM
a: CD.Instance => RETURN[Properties.GetProp[a.properties, prop]];
o: CD.Object => RETURN[Properties.GetProp[o.properties, prop]];
pr: CD.PropRef => RETURN[Properties.GetProp[pr^, prop]];
pl: CD.PropList => RETURN[Properties.GetProp[pl, prop]];
at: ATOM => RETURN[GetRefAnyPropf[at, prop]];
d: CD.Design => RETURN[Properties.GetProp[d.properties^, prop]];
t: CD.Technology => RETURN[Properties.GetProp[t.properties^, prop]];
class: CD.ObjectClass => RETURN[Properties.GetProp[class.properties^, prop]];
pp: PropertyProcs => RETURN[Properties.GetProp[pp.properties, prop]];
ENDCASE => RETURN WITH ERROR Err;
};

GetListProp: PUBLIC ENTRY PROC [propList: PropList, prop: REF] RETURNS [REF] = {
ENABLE UNWIND => NULL;
RETURN [Properties.GetProp[propList, prop]]
};


PutPRefProp: PUBLIC ENTRY PROC [onto: CD.PropRef, prop: REF, val: REF] = {
ENABLE UNWIND => NULL;
IF onto=NIL THEN RETURN WITH ERROR CD.Error[other, "nil property field"];
onto^ _ Properties.PutProp[onto^, prop, val]
};

PutObjectProp: PUBLIC ENTRY PROC [onto: CD.Object, prop: REF, val: REF] = {
ENABLE UNWIND => NULL;
IF onto=NIL THEN RETURN WITH ERROR CD.Error[other, "NIL Object"];
onto.properties _ Properties.PutProp[onto.properties, prop, val]
};

PutInstanceProp: PUBLIC ENTRY PROC[onto: CD.Instance, prop: REF, val: REF] = {
ENABLE UNWIND => NULL;
IF onto=NIL THEN RETURN WITH ERROR CD.Error[other, "NIL Instance"];
onto.properties _ Properties.PutProp[onto.properties, prop, val]
};

PutDesignProp: PUBLIC ENTRY PROC [onto: CD.Design, prop: REF, val: REF] = {
ENABLE UNWIND => NULL;
IF onto=NIL OR onto.properties=NIL THEN 
RETURN WITH ERROR CD.Error[other, "NIL property field"];
onto.properties^ _ Properties.PutProp[onto.properties^, prop, val]
};

PutTechnologyProp: PUBLIC ENTRY PROC[onto: CD.Technology, prop: REF, val: REF] = {
ENABLE UNWIND => NULL;
IF onto=NIL OR onto.properties=NIL THEN 
RETURN WITH ERROR CD.Error[other, "nil property field"];
onto.properties^ _ Properties.PutProp[onto.properties^, prop, val]
};

PutObjectClassProp: ENTRY PROC[onto: CD.ObjectClass, prop: REF, val: REF] = {
ENABLE UNWIND => NULL;
IF onto=NIL OR onto.properties=NIL THEN 
RETURN WITH ERROR CD.Error[other, "nil property field"];
onto.properties^ _ Properties.PutProp[onto.properties^, prop, val]
};

PutAtomProp: PUBLIC PROC[onto: ATOM, prop: REF, val: REF] = {
PutPropOnRef[onto: onto, prop: prop, val: val]
};

PutLayerProp: PUBLIC ENTRY PROC[onto: CD.Layer, prop: REF, val: REF] = {
ENABLE UNWIND => NULL;
CDPrivate.layers[onto].properties^ _ Properties.PutProp[CDPrivate.layers[onto].properties^, prop, val]
};

PutPropertyClassProp: ENTRY PROC[onto: PropertyProcs, prop: REF, val: REF] = {
ENABLE UNWIND => NULL;
IF onto=NIL OR onto.properties=NIL THEN 
RETURN WITH ERROR CD.Error[other, "nil PropertyProcs"];
onto.properties _ Properties.PutProp[onto.properties, prop, val]
};

PutPropOnRef: ENTRY PROC[onto: REF, prop: REF, val: REF] = {
x: REF;
found: BOOL;
pp: REF CD.PropList;
[found, x] _ RefTab.Fetch[atomTab, onto];
IF found THEN pp _ NARROW[x, REF CD.PropList]
ELSE {
IF prop=NIL THEN RETURN;
pp _ NEW[CD.PropList_NIL];
[] _ RefTab.Store[atomTab, onto, pp];
};
pp^ _ Properties.PutProp[pp^, prop, val];
IF pp^=NIL THEN [] _ RefTab.Delete[atomTab, onto];
};

GetRefAnyPropf: PROC [from: REF, prop: REF] RETURNS [REF] = INLINE {
x: REF; found: BOOL;
pp: REF CD.PropList;
[found, x] _ RefTab.Fetch[atomTab, from];
IF NOT found THEN RETURN[NIL];
pp _ NARROW[x, REF CD.PropList];
RETURN [Properties.GetProp[pp^, prop]]
};

GetObjectProp: PUBLIC PROC [from: CD.Object, prop: REF] RETURNS [REF] = {
ENABLE UNWIND => NULL;
RETURN[Properties.GetProp[from.properties, prop]]
};

GetInstanceProp: PUBLIC PROC [from: CD.Instance, prop: REF] RETURNS [REF] = {
ENABLE UNWIND => NULL;
RETURN[Properties.GetProp[from.properties, prop]]
};

GetDesignProp: PUBLIC PROC [from: CD.Design, prop: REF] RETURNS [REF] = {
ENABLE UNWIND => NULL;
RETURN[Properties.GetProp[from.properties^, prop]]
};

GetTechnologyProp: PUBLIC PROC [from: CD.Technology, prop: REF] RETURNS [REF] = {
ENABLE UNWIND => NULL;
RETURN[Properties.GetProp[from.properties^, prop]]
};

GetLayerProp: PUBLIC PROC [from: CD.Layer, prop: REF] RETURNS [REF] = {
ENABLE UNWIND => NULL;
RETURN[Properties.GetProp[CDPrivate.layers[from].properties^, prop]]
};

GetAtomProp: PUBLIC ENTRY PROC [from: ATOM, prop: REF] RETURNS [REF] = {
ENABLE UNWIND => NULL;
RETURN[GetRefAnyPropf[from: from, prop: prop]];
};


Register: PUBLIC PROC [prop: ATOM, procs: PropertyProcsRec, registrationKey: REF] RETURNS [sameProp: ATOM] = {
[] _ RegisterProperty[prop, registrationKey];
InstallProcs[prop, procs];
sameProp _ prop;
};

InstallProcs: PUBLIC ENTRY PROC [prop: REF, procs: PropertyProcsRec] = {
ENABLE UNWIND => NULL;
pp: PropertyProcs;
IF (pp _ FetchProcs[prop])#NIL THEN {
IF procs.exclusive THEN pp.exclusive_TRUE;
IF procs.autoRem THEN pp.autoRem_TRUE;
IF procs.reserved THEN pp.reserved_TRUE;
IF procs.makeCopy#NIL THEN pp.makeCopy _ procs.makeCopy;
IF procs.internalWrite#NIL THEN pp.internalWrite _ procs.internalWrite;
IF procs.internalRead#NIL THEN pp.internalRead _ procs.internalRead;
IF procs.properties#NIL THEN
FOR l: PropList _ procs.properties, l.rest WHILE l#NIL DO
pp.properties _ Properties.PutProp[pp.properties, l.first.key, l.first.val];
ENDLOOP;
}
};

FetchProcs: PUBLIC PROC [prop: REF] RETURNS [pp: PropertyProcs] = {
pp _ NARROW[RefTab.Fetch[propertyNameTab, prop].val];
};

CopyVal: PUBLIC PROC [prop: REF, val: REF, purpose: REF] RETURNS [valCopy: REF] = {
valCopy _ val;
};

DontCopy: PUBLIC PROC [prop: REF, val: REF, purpose: REF] RETURNS [nil: REF_NIL] = {
};

PutOn: PROC [putOnto: REF, propList: PropList] = {
WITH putOnto SELECT FROM
a: CD.Instance => a.properties _ propList;
o: CD.Object => o.properties _ propList;
pr: CD.PropRef => pr^ _ propList;
d: CD.Design => d.properties^ _ propList;
t: CD.Technology => t.properties^ _ propList;
class: REF CD.ObjectClass => class.properties^ _ propList;
pp: PropertyProcs  => pp.properties _ propList;
at: ATOM => ERROR;
ENDCASE => ERROR Err
};

CopyProps: PUBLIC ENTRY PROC [propList: PropList, putOnto: REF, purpose: REF_NIL] = {
ENABLE UNWIND => NULL;
PutOn[putOnto, InternalDangerousCopyProps[propList, purpose] ! 
RuntimeError.UNCAUGHT => GOTO crashed];
EXITS crashed => RETURN WITH ERROR Err
};

AppendProps: PUBLIC ENTRY PROC [winner, looser: PropList_NIL, putOnto: REF, purpose: REF_NIL] = {
ENABLE UNWIND => NULL;
PutOn[putOnto, InternalDangerousAppendProps[winner, looser, purpose] ! 
RuntimeError.UNCAUGHT => GOTO crashed]
EXITS crashed => RETURN WITH ERROR Err
};
DCopyProps: PUBLIC ENTRY PROC [propList: PropList, purpose: REF] RETURNS [copy: PropList_NIL] = {
ENABLE UNWIND => NULL;
copy _ InternalDangerousCopyProps[propList, purpose]
};

DAppendProps: PUBLIC ENTRY PROC [winner, looser: CDProperties.PropList, purpose: REF] RETURNS [copy: CDProperties.PropList] = {
ENABLE UNWIND => NULL;
copy _ InternalDangerousAppendProps[winner, looser, purpose]
};

InternalDangerousCopyProps: PROC [propList: PropList, purpose: REF] RETURNS [copy: PropList_NIL] = {
FOR l: PropList _ propList, l.rest WHILE l#NIL DO
copy _ InternalCopyItem[copy, l.first, purpose]
ENDLOOP;
};

InternalDangerousAppendProps: PROC [winner, looser: CDProperties.PropList, purpose: REF] RETURNS [copy: CDProperties.PropList] = {
copy _ InternalDangerousCopyProps[looser, purpose];
FOR l: PropList _ winner, l.rest WHILE l#NIL DO
copy _ InternalCopyItem[copy, l.first, purpose]
ENDLOOP;
};

InternalCopyItem: PROC[list: CDProperties.PropList, item: Properties.KeyVal, purpose: REF] RETURNS [newList: CDProperties.PropList] = {
class: CDProperties.PropertyProcs = FetchProcs[item.key];
IF class#NIL AND class.makeCopy#NIL THEN {
newVal: REF = class.makeCopy[prop: item.key, val: item.val, purpose: purpose];
IF newVal=NIL THEN newList _ list
ELSE newList _ Properties.PutProp[list, item.key, newVal];
}
ELSE IF ISTYPE[item.key, ATOM] AND item.val#NIL THEN 
WITH item.val SELECT FROM
r: Rope.ROPE => newList _ Properties.PutProp[list, item.key, r];
at: ATOM => newList _ Properties.PutProp[list, item.key, at];
ri: REF INT => newList _ Properties.PutProp[list, item.key, NEW[INT_ri^]];
pl: CD.PropList => newList _ Properties.PutProp[list, item.key, InternalDangerousCopyProps[pl, purpose]];
rl: LIST OF Rope.ROPE => newList _ Properties.PutProp[list, item.key, RopeList.CopyTopList[rl]];
ENDCASE => newList _ list
ELSE newList _ list; 
};

DoWithinLock: PUBLIC ENTRY PROC [p: PROC] = {
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => 
IF UserProfile.Boolean["ChipNDale.CatchLowLevelErrors", TRUE] THEN CONTINUE;
};
IF p#NIL THEN p[];
};
DontPWrite: PUBLIC PROC [h: TokenIO.Handle, prop: REF, val: REF] = {
ERROR
};

RopePWrite: PUBLIC PROC [h: TokenIO.Handle, prop: REF, val: REF] = {
WITH val SELECT FROM
r: Rope.ROPE => TokenIO.WriteRope[h, r];
at: ATOM => TokenIO.WriteRope[h, Atom.GetPName[at]];
ENDCASE => TokenIO.WriteRope[h, "bad property value"];
};

AtomPWrite: PUBLIC PROC [h: TokenIO.Handle, prop: REF, val: REF] = {
WITH val SELECT FROM
at: ATOM => TokenIO.WriteAtom[h, at];
r: Rope.ROPE => TokenIO.WriteAtom[h, Atom.MakeAtom[r]];
ENDCASE => TokenIO.WriteAtom[h, $Bad];
};

IntPWrite: PUBLIC PROC [h: TokenIO.Handle, prop: REF, val: REF] = {
WITH val SELECT FROM
ri: REF INT => TokenIO.WriteInt[h, ri^];
rc: REF CARDINAL => TokenIO.WriteInt[h, rc^];
rn: REF NAT => TokenIO.WriteInt[h, rn^];
ENDCASE => TokenIO.WriteInt[h, 0];
};

SomePWrite: PUBLIC PROC [h: TokenIO.Handle, prop: REF, val: REF] = {
WITH val SELECT FROM
at: ATOM => TokenIO.WriteAtom[h, at];
r: Rope.ROPE => TokenIO.WriteRope[h, r];
ri: REF INT => TokenIO.WriteInt[h, ri^];
rc: REF CARDINAL => TokenIO.WriteInt[h, rc^];
rn: REF NAT => TokenIO.WriteInt[h, rn^];
ENDCASE => TokenIO.WriteAtom[h, $Unknown];
};

RopePRead: PUBLIC PROC [h: TokenIO.Handle, prop: ATOM] RETURNS [val: REF] = {
val _ TokenIO.ReadRope[h]
};

AtomPRead: PUBLIC PROC [h: TokenIO.Handle, prop: ATOM] RETURNS [val: REF] = {
val _ TokenIO.ReadAtom[h]
};

IntPRead: PUBLIC PROC [h: TokenIO.Handle, prop: ATOM] RETURNS [val: REF] = {
val _ NEW[INT_TokenIO.ReadInt[h]]
};

SomePRead: PUBLIC PROC [h: TokenIO.Handle, prop: ATOM] RETURNS [val: REF] = {
t: TokenIO.Token _ TokenIO.Read[h];
WITH t SELECT FROM
int: TokenIO.Token.int => val _ NEW[INT_int.value];
rope: TokenIO.Token.rope => val _ rope.value;
atom: TokenIO.Token.atom => val _ atom.value;
ENDCASE => val _ $Error; 
};


GetPropProp: PUBLIC PROC [from: REF, key1, key2: REF_] RETURNS [REF] = {
WITH GetProp[from, key1] SELECT FROM
pl: Properties.PropList => RETURN [Properties.GetProp[pl, key2]];
ENDCASE  => RETURN [NIL];
};

PutPropProp: PUBLIC PROC [onto: REF, key1, key2: REF_, val: REF_NIL] = {
WITH GetProp[onto, key1] SELECT FROM
pl: CD.PropList => {
pl1: Properties.PropList _ Properties.PutProp[pl, key2, val];
IF pl1#pl THEN PutProp[onto, key1, pl1];
}
ENDCASE => PutProp[onto, key1, Properties.PutProp[NIL, key2, val]]
};

TiogaPCopy: PROC [prop: REF, val: REF, purpose: REF] RETURNS [copy: REF] = {
contents, formatting: Rope.ROPE _ NIL;
WITH val SELECT FROM
t: ViewerTools.TiogaContents => {contents _ t.contents; formatting _ t.formatting};
r: Rope.ROPE => contents _ r;
ENDCASE => contents _ "$Error";
copy _ NEW[ViewerTools.TiogaContentsRec_[contents: contents, formatting: formatting]]
};

TiogaPWrite: PROC [h: TokenIO.Handle, prop: REF, val: REF] = {
contents, formatting: Rope.ROPE _ NIL;
WITH val SELECT FROM
t: ViewerTools.TiogaContents => {contents _ t.contents; formatting _ t.formatting};
r: Rope.ROPE => contents _ r;
ENDCASE => NULL;
TokenIO.WriteRope[h, contents];
TokenIO.WriteRope[h, formatting];
};

TiogaPRead: PROC [h: TokenIO.Handle, prop: ATOM] RETURNS [val: REF] = {
contents: Rope.ROPE _ TokenIO.ReadRope[h];
formatting: Rope.ROPE _ TokenIO.ReadRope[h];
val _ NEW[ViewerTools.TiogaContentsRec_[contents: contents, formatting: formatting]]
};

Atomize: PROC [r: Rope.ROPE] RETURNS [ATOM_NIL] = {
IF Rope.Length[r]>1 AND Rope.Fetch[r]='$ THEN r _ Rope.Substr[r, 1, Rope.Length[r]-1];
IF ~Rope.IsEmpty[r] THEN RETURN [Atom.MakeAtom[r]]
};

IsExclusive: PUBLIC PROC [key: REF] RETURNS [BOOL_TRUE] = {
pType: CDProperties.PropertyProcs ~ CDProperties.FetchProcs[key];
RETURN [pType#NIL AND pType.exclusive]
};

associationRoot: CDProperties.PropRef _ CDProperties.InitPropRef[];

RemoveProperties: PUBLIC PROC[root: ATOM] = {
RemovePropFromRegistrations: PROC [atom: ATOM] = {
WITH GetProp[associationRoot, atom] SELECT FROM
lora: LIST OF REF ANY => {
FOR l: LIST OF REF ANY _ lora, l.rest WHILE l#NIL DO
WITH l.first SELECT FROM
a: ATOM => {
IF ~IsExclusive[a] THEN PutAtomProp[atom, a, NIL];
PutAtomProp[a, atom, NIL];
}
ENDCASE => NULL;
ENDLOOP; 
}; 
ENDCASE => NULL;
};
RemovePropFromLayers: PROC [atom: ATOM] = {
FOR l: CD.Layer IN CD.Layer DO
reg: ATOM _ CD.LayerKey[l];
IF reg#NIL THEN {
PutAtomProp[atom, reg, NIL];
PutAtomProp[reg, atom, NIL];
};
PutLayerProp[l, atom, NIL];
ENDLOOP;
};
IF ~IsExclusive[root] THEN { 
PutAtomProp[root, root, NIL];
RemovePropFromRegistrations[root];
RemovePropFromLayers[root];
};
};

RemovePropCommand: Commander.CommandProc = {
FOR rl: LIST OF Rope.ROPE _ CommandTool.ParseToList[cmd].list, rl.rest WHILE rl#NIL DO
atom: ATOM _ Atomize[rl.first]; --this atoms registrations should be removed
IF IsExclusive[atom] THEN 
msg _ Rope.Cat[msg, " ", rl.first, " not removed (no or exclusive atom)\n"]
ELSE RemoveProperties[atom];
ENDLOOP;
};

Associate: PUBLIC PROC [root, key: ATOM] = {
IF ~IsExclusive[root] AND ~IsExclusive[key] THEN {
list: LIST OF REF ANY _ 
WITH GetProp[associationRoot, root] SELECT FROM
lora: LIST OF REF ANY => lora,
ENDCASE => NIL;
IF ~List.Memb[key, list] THEN {
new: LIST OF REF ANY _ List.Nconc1[list, key];
IF new#list THEN PutProp[associationRoot, root, new];
};
};
};

AssociatePropCommand: Commander.CommandProc = {
root: ATOM _ NIL;
rl: LIST OF Rope.ROPE _ CommandTool.ParseToList[cmd].list;
IF rl=NIL OR IsExclusive[root_Atomize[rl.first]] THEN {
msg _ "no or exclusive root\n"; result _ $Failure;
RETURN
};
IF rl.rest=NIL THEN {
msg _ "no properties to associate with root\n"; result _ $Failure;
RETURN
};
FOR l: LIST OF Rope.ROPE _ rl.rest, l.rest WHILE l#NIL DO
a: ATOM _ Atomize[l.first];
IF IsExclusive[a] THEN msg _ Rope.Cat[msg, l.first, " not allowed\n"]
ELSE Associate[root, a];
ENDLOOP;
};

Commander.Register[
key: "///ChipNDale/CDRemoveRegistration", --used by ChipNDale command files only
proc: RemovePropCommand,
doc: "removes properties from all ChipNDale layers"
];
Commander.Register[
key: "///ChipNDale/CDRemoveRegistrations", --used by ChipNDale command files only
proc: RemovePropCommand,
doc: "removes properties from all ChipNDale layers"
];
Commander.Register[
key: "///ChipNDale/CDAssociateRegistration", --used by ChipNDale command files only
proc: AssociatePropCommand,
doc: "associate ChipNDale properties for removal"
];

[] _ CDProperties.RegisterProperty[$SignalName];
[] _ CDProperties.RegisterProperty[$InstanceName];
[] _ CDProperties.RegisterProperty[$Tioga];
[] _ CDProperties.RegisterProperty[$CreatedBy, $chj];
CDProperties.InstallProcs[prop: $SignalName, procs: 
CDProperties.PropertyProcsRec[
makeCopy: CDProperties.CopyVal,
internalWrite: CDProperties.RopePWrite,
internalRead: CDProperties.RopePRead
]];
CDProperties.InstallProcs[prop: $InstanceName, procs: 
CDProperties.PropertyProcsRec[
makeCopy: CDProperties.CopyVal,
internalWrite: CDProperties.RopePWrite,
internalRead: CDProperties.RopePRead
]];
CDProperties.InstallProcs[prop: $Tioga, procs: 
CDProperties.PropertyProcsRec[
makeCopy: TiogaPCopy,
internalWrite: TiogaPWrite,
internalRead: TiogaPRead
]];
CDProperties.InstallProcs[prop: $CreatedBy, procs: 
CDProperties.PropertyProcsRec[
exclusive: TRUE,
autoRem: TRUE,
makeCopy: CDProperties.CopyVal,
internalWrite: CDProperties.AtomPWrite,
internalRead: CDProperties.AtomPRead
]];
END.


CDPropertiesImpl.mesa   a ChipNDale module
Copyright c 1983, 1986 by Xerox Corporation.  All rights reserved.
Created by: Christian Jacobi,  September 27, 1983 2:06 pm
Last edited by: Christian Jacobi, March 23, 1987 2:53:55 pm PST
--Registration
--Usage
--speed ups  
--a NIL val removes the property
--here onto MUST NOT be a ChipNDale ref pointing to a record with properties,
--since then the properties must be used, not the hash table
--NIL if prop is not found
--here from MUST NOT be a ChipNDale ref pointing to a record with properties,
--since then the properties must be used, not the hash table
--property procedures
--dangerous procedure; might crash


--------------------------

--------------------------
--now some special properties

--not entry! would wedge
--Allows to do un-registration from commandfiles which may run
--before the tool they are un-registrating 
--This command is handy for lots of tools which set op their parameters with command file 
--cant be entry!
--does not really belong into this module
ΚQ˜
codeš
œ*™*Kšœ
Οm
œ7™BKš
œ9™9K™?K˜—š
Οk	˜	K˜
K˜Kšžœ
˜K˜
K˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜	Kšœ
žœžœ˜Kš
œ˜Kšœžœ˜Kšœžœ#˜4—K˜šΟnœžœ
žœ
˜ Kšžœ
žœ†
˜
Kšžœ ˜'—Kš
ž˜K˜Kšœ
žœžœ
˜Kšœžœ˜1Kšœžœ!˜7K˜š
œ'˜'Kš
Οc?˜?—K˜Kš
œ™K˜Kšœ/ +˜ZKšœ/ ˜KK˜šŸœžœ
ž
œžœžœ
žœžœ	ž	œ˜hKšœžœ
žœ	žœ
˜Kšœ5 ˜Ršžœžœ˜Kšžœžœ
žœžœ
žœžœ˜CKšžœ
žœ
žœ
žœ˜.K˜
—šžœ˜Kšœžœ˜6Kšœ/ ˜7Kšœ< ˜KK˜—Kš
œ˜K˜K˜—Kš
œ™K˜Kšœžœžœ
˜K˜šŸœžœ
žœžœžœžœ˜9šžœžœ
ž˜Kšœžœ+˜0Kšœžœ'˜,Kšœžœ'˜-Kšœžœ'˜,Kšœžœ/˜4Kšœžœ˜'Kšœžœ5˜>Kš
œ:˜:Kšœžœ ˜IKšžœžœ˜ —Kš
œ˜K˜—šŸœžœ
ž
œžœžœžœžœ˜CKšžœ
žœžœ
˜šžœžœ
ž˜Kšœžœ
žœ)˜AKšœžœžœ)˜?Kšœžœ ˜8Kšœžœ˜8Kšœžœžœ˜-Kšœžœžœ*˜@Kšœžœžœ*˜DKšœžœžœ.˜MKšœžœ*˜EKšžœžœ˜!—Kš
œ˜—K˜šŸœžœ
žœžœžœžœ˜PKšžœ
žœžœ
˜Jšžœ%˜+Jš
œ˜K˜—Kš
œ
™
K˜šŸœžœ
žœ
žœžœžœžœ˜JKšžœ
žœžœ
˜Kšžœžœ
žœ
žœ
žœ
žœ
žœ$˜IKš
œ,˜,Kš
œ˜K˜—šŸ
œžœ
žœ
žœžœžœžœ˜KKšžœ
žœž˜Kšžœžœ
žœ
žœ
žœ
žœ
žœ˜AKš
œ@˜@Kš
œ˜K˜—šŸœžœ
žœ
žœžœžœžœ˜NKšžœ
žœž˜Kšžœžœ
žœ
žœ
žœ
žœ
žœ˜CKš
œ@˜@Kš
œ˜K˜—šŸ
œžœ
žœ
žœžœžœžœ˜KKšžœ
žœž˜šžœžœ
žœžœ
˜(Kšžœ
žœ
žœ
žœ$˜8—Kš
œB˜BKš
œ˜K˜—šŸœžœ
žœ
žœžœžœžœ˜RKšžœ
žœž˜šžœžœ
žœžœ
˜(Kšžœ
žœ
žœ
žœ$˜8—Kš
œB˜BKš
œ˜K˜—šŸœžœ
žœžœžœžœ˜MKšžœ
žœžœ
˜š
žœžœ
žœžœ
žœ
˜(Kšžœ
žœ
žœ
žœ$˜8—Kš
œB˜BKš
œ˜K˜—šŸœžœ
žœžœžœžœ˜=Kš
œ.˜.Kš
œ˜K˜—šŸœžœ
žœ
žœžœžœžœ˜HKšžœ
žœž˜Kš
œf˜fKš
œ˜K˜—š
Ÿœžœ
žœžœžœ˜NKšžœ
žœžœ
˜š
žœžœ
žœžœ
žœ
˜(Kšžœ
žœ
žœ
žœ#˜7—Kš
œ@˜@Kš
œ˜K˜—šŸœžœ
žœžœžœžœ˜<Kš
œ ™ Kš
œM™MKš
œ<™<Kšœžœ
˜Kšœžœ
˜Kšœžœ
žœ
˜Kš
œ)˜)Kš
žœžœžœžœ
žœ
˜-šžœ˜Kšžœžœ
žœ
žœ
˜Kšœžœ
žœ
žœ˜Kš
œ%˜%K˜—Kš
œ)˜)Kšžœžœ
žœ#˜2Kš
œ˜K˜—šŸœžœžœžœžœžœžœ
˜DKš
œ™Kš
œM™MKš
œ<™<Kšœžœ	žœ
˜Kšœžœ
žœ
˜Kš
œ)˜)Kš
žœ
žœžœ
žœ
žœ˜Kšœžœžœ
žœ˜ Kšžœ˜&Kš
œ˜K˜—šŸ
œžœ
žœžœžœžœžœ˜IKšžœ
žœžœ
˜Kšžœ+˜1Kš
œ˜K˜—šŸœžœ
žœžœžœžœžœ˜MKšžœ
žœžœ
˜Kšžœ+˜1Kš
œ˜K˜—šŸ
œžœ
žœžœžœžœžœ˜IKšžœ
žœžœ
˜Kšžœ,˜2Kš
œ˜K˜—šŸœžœ
žœžœžœžœžœ˜QKšžœ
žœžœ
˜Kšžœ,˜2Kš
œ˜—K˜šŸœžœ
žœžœžœžœžœ˜GKšžœ
žœžœ
˜Kšžœ>˜DKš
œ˜K˜—šŸœžœ
ž
œžœžœžœžœ˜HKšžœ
žœžœ
˜Kšžœ)˜/Kš
œ˜—K˜Kš
œ™K˜šŸœžœžœ,žœžœžœ˜nKš
œ-˜-Kš
œ˜Kš
œ˜Kš
œ˜K˜—š
Ÿœžœ
žœ
žœžœ˜HKšžœ
žœž˜Kš
œ˜šžœžœ
žœ˜%Kšžœžœžœ
˜*Kšžœžœžœ
˜&Kšžœžœ
žœ
˜(Kšžœžœ
žœ˜8Kšžœžœ
žœ(˜GKšžœžœ
žœ&˜Dšžœžœ
ž˜šžœ(žœžœ
ž˜9Kš
œL˜LKšžœ
˜——Kš
œ
˜
—Kš
œ˜K˜—š
Ÿ
œžœ
žœžœžœ˜CKšœžœ*˜5Kš
œ˜K˜—šŸœžœ
žœžœžœžœžœžœ˜SK˜Kš
œ˜K˜—šŸœžœ
žœžœžœžœžœžœ
žœ˜TKš
œ˜K˜—šŸœžœžœ˜2Kš
œ"™"šžœ	žœ
ž˜Kšœžœ%˜*Kšœžœ#˜(Kšœžœ˜!Kšœžœ$˜)Kšœžœ(˜-Kšœžœ
žœ-˜:Kš
œ/˜/Kšœžœžœ
˜Kšžœžœ˜—Kšœ
ž
˜—K˜šŸ	œžœ
žœ
žœžœžœ
žœ˜UKšžœ
žœžœ
˜š
œ?˜?Kšœ
žœžœ
˜'—Kšžœžœ
žœ
žœ˜&Kš
œ˜K˜—šŸœžœ
žœ
žœžœžœžœ
žœ˜aKšžœ
žœžœ
˜š
œG˜GKšœ
žœžœ	˜&—Kšžœžœ
žœ
žœ˜&š
œ˜K™——šŸ
œžœ
žœ
žœžœžœžœ˜aKšžœ
žœžœ
˜Kš
œ4˜4Kš
œ˜K˜—šŸœžœ
ž
œ'žœ	žœžœ"˜Kšžœ
žœžœ
˜Kš
œ<˜<Kš
œ˜K˜—š
Ÿœžœžœžœžœ˜dšžœ žœžœ
ž˜1Kš
œ/˜/Kšžœ
˜—Kš
œ˜K˜—š
Ÿœžœ'žœ	žœžœ"˜‚
Kš
œ3˜3šžœžœžœ
ž˜/Kš
œ/˜/Kšžœ
˜—Kš
œ˜K˜—šŸœžœ@žœžœ%˜‡
Kš
œ9˜9š
žœžœ
žœžœ
žœ˜*KšœžœC˜NKšžœžœ
žœ˜!Kšžœ6˜:K˜
—šžœ
žœ
žœžœžœ
žœ
žœ
˜5šžœ
žœ
ž˜Kšœžœ4˜@Kšœžœ5˜=Kš	œžœ
žœ1žœ
žœ˜JKšœžœc˜iKšœžœ
žœžœK˜`Kšžœ˜——Kšžœ˜Kš
œ˜—K˜š
Ÿœžœ
žœ
žœžœ˜-šžœ˜Kšžœžœ
˜šœ
žœ˜Kšžœ6žœžœ
žœ
˜L—Kš
œ˜—Kšžœžœ
žœ˜Kš
œ˜K™—š
Πbn
œžœ
žœžœžœ˜DKš
ž˜K˜—K˜š
‘
œžœ
žœžœžœ˜Dšžœžœ
ž˜Kšœžœ˜(Kšœžœ,˜4Kšžœ/˜6—Kš
œ˜K˜—š
‘
œžœ
žœžœžœ˜Dšžœžœ
ž˜Kšœžœ˜%Kšœžœ+˜7Kšžœ˜&—Kš
œ˜K˜—š
‘	œžœ
žœžœžœ˜Cšžœžœ
ž˜Kšœžœ
žœ˜(Kšœžœ
žœ˜-Kšœžœ
žœ˜(Kšžœ˜"—Kš
œ˜K˜—š
‘
œžœ
žœžœžœ˜Dšžœžœ
ž˜Kšœžœ˜%Kšœžœ˜(Kšœžœ
žœ˜(Kšœžœ
žœ˜-Kšœžœ
žœ˜(Kšžœ#˜*—Kš
œ˜K˜—š‘	œžœ
žœžœžœžœ˜MKš
œ˜Kš
œ˜K˜—š‘	œžœ
žœžœžœžœ˜MKš
œ˜Kš
œ˜K˜—š‘œžœ
žœžœžœžœ˜LKšœžœ
žœ˜!Kš
œ˜K˜—š‘	œžœ
žœžœžœžœ˜MKš
œ#˜#šžœžœ
ž˜Jšœ žœ
žœ˜3Jš
œ-˜-Jš
œ-˜-Jšžœ˜—Kš
œ˜K˜—Kš
œ™J˜šŸœžœžœžœžœžœ˜Hšžœžœ
ž˜$Jšœžœ ˜AJšžœžœžœ˜—J˜—J˜šŸœžœžœžœžœ
žœ˜Hšžœžœ
ž˜$šœžœ˜Jš
œ=˜=Jšžœžœ˜(Jš
œ
˜
—Jšžœ+žœ
˜B—J˜—K™Kš
œ™Kš
œ™K˜šŸ
œžœžœžœžœžœžœ˜LKšœžœžœ
˜&šžœžœ
ž˜Kš
œS˜SKšœžœ˜Kšžœ˜—KšœžœK˜UKš
œ˜—K˜šŸœžœžœžœ˜>Kšœžœžœ
˜&šžœžœ
ž˜Kš
œS˜SKšœžœ˜Kšžœžœ
˜—Kš
œ˜Kš
œ!˜!Kš
œ˜K˜—š
Ÿ
œžœžœžœžœ˜GKšœžœ˜*Kšœžœ˜,KšœžœK˜TKš
œ˜—K™J˜šŸœžœ
žœžœžœ
žœ˜3Kšžœžœžœ)˜VKšžœžœ
žœ˜2K˜—K˜šŸœžœžœžœžœ
žœ˜;Kš
œA˜AKšžœžœ
žœ˜&Kš
œ˜—K˜Kš
œC˜CK˜šŸœžœ
žœžœ˜-Kš
œ™šŸœžœžœ˜2šžœ žœ
ž˜/š	œžœ
žœ
žœ
žœ˜šžœžœ
žœ
žœ
žœžœžœ
ž˜4šžœ	žœ
ž˜šœžœ˜Jšžœžœžœ˜2Jšœžœ˜J˜
—Jšžœžœ
˜—Jšžœ˜	—Jš
œ˜—Jšžœžœ
˜—Kš
œ˜—šŸœžœžœ˜+š	žœžœžœ
žœž˜Jšœžœžœ
˜šžœžœ
žœ˜Jšœžœ˜Jšœžœ˜J˜—Jšœžœ˜Jšžœ
˜—Kš
œ˜—šžœžœ˜Jšœžœ˜Jš
œ"˜"Kš
œ˜J˜—Kš
œ˜—K˜š‘œ˜,Kš
œ>™>Kš
œ+™+Kš
œZ™Zš
žœžœ
žœžœ.žœžœ
ž˜VJšœžœ ,˜Lšžœžœ
˜Kš
œK˜K—Kšžœ˜Jšžœ
˜—Kš
œ˜K˜—šŸ	œžœ
žœ˜,Kš
œ™šžœžœžœ˜2š	œžœ
žœ
žœ
žœ˜šžœ žœ
ž˜/Kš	œžœ
žœ
žœ
žœ	˜Kšžœžœ
˜——šžœžœ˜Kš	œžœ
žœ
žœ
žœ˜.Kšžœ
žœ%˜5K˜—K˜—Kš
œ˜—K˜šΟbœ˜/Kšœžœžœ
˜Kšœžœ
žœžœ%˜:šžœžœ
žœ%žœ˜7Kš
œ2˜2Kš
ž˜K˜—šžœ	žœ
žœ˜Kš
œB˜BKš
ž˜K˜—š
žœžœ
žœžœžœžœ
ž˜9Kšœžœ˜Kšžœžœ/˜EKšžœ˜Kš
ž˜—Kš
œ˜—K˜š
œ˜Kšœ* &˜PKš
œ˜Kš
œ3˜3Kš
œ˜—š
œ˜Kšœ+ &˜QKš
œ˜Kš
œ3˜3Kš
œ˜—š
œ˜Kšœ- &˜SKš
œ˜Kš
œ1˜1Kš
œ˜—K˜Kš
œ)™)Kš
œ0˜0Kš
œ2˜2Kš
œ+˜+Kš
œ5˜5š
œ4˜4š
œ˜Kš
œ˜Kš
œ'˜'Kš
œ$˜$Kš
œ˜——š
œ6˜6š
œ˜Kš
œ˜Kš
œ'˜'Kš
œ$˜$Kš
œ˜——š
œ/˜/š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜——š
œ3˜3š
œ˜Kšœžœ
˜Kšœ	žœ
˜Kš
œ˜Kš
œ'˜'Kš
œ$˜$Kš
œ˜——Kšžœ
˜K˜K˜—…—FJd«