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: BOOLEAN_TRUE] =
BEGIN
val: RefTab.Val;
found: BOOL;
[found, val] _ RefTab.Fetch[x: registrationTab, key: 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];
pp.key _ prop;
[] _ RefTab.Insert[propertyNameTab, prop, pp]; -- procs
[] _ RefTab.Insert[registrationTab, prop, registrationKey]; -- registration
};
END;



HasNoCDProperties: ERROR = CODE;

PutProp: PUBLIC PROC [onto: REF, prop: REF, val: REF] =
BEGIN
WITH onto SELECT FROM
a: CD.Instance => PutPropOnInstance[a, prop, val];
o: CD.Object => PutPropOnObject[o, prop, val];
pr: CD.PropRef => PutPropOnPropRef[pr, prop, val];
d: CD.Design => PutPropOnDesign[d, prop, val];
t: CD.Technology => PutPropOnTechnology[t, prop, val];
at: ATOM => PutPropOnAtom[at, prop, val];
class: REF CD.ObjectClass => PutPropOnClass[class, prop, val];
pp: PropertyProcs  => PutPropOnPropertyProcs[pp, prop, val];
ENDCASE => ERROR HasNoCDProperties
END;

GetProp: PUBLIC PROC [from: REF, prop: REF] RETURNS [REF] =
BEGIN
RETURN [WITH from SELECT FROM
a: CD.Instance => GetPropFromList[a.properties, prop],
o: CD.Object => GetPropFromList[o.properties, prop],
pr: CD.PropRef => GetPropFromList[pr^, prop],
pl: CD.PropList => GetPropFromList[pl, prop],
at: ATOM => GetPropFromAtom[at, prop],
d: CD.Design => GetPropFromList[d.properties^, prop],
t: CD.Technology => GetPropFromList[t.properties^, prop],
class: REF CD.ObjectClass => GetPropFromList[class.properties^, prop],
pp: PropertyProcs => GetPropFromList[pp.properties, prop],
ENDCASE => ERROR HasNoCDProperties]
END;

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


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

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

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

PutPropOnDesign: PUBLIC ENTRY PROC [onto: CD.Design, prop: REF, val: REF] =
BEGIN
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]
END;

PutPropOnTechnology: PUBLIC ENTRY PROC[onto: CD.Technology, prop: REF, val: REF] =
BEGIN
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]
END;

PutPropOnClass: PUBLIC ENTRY PROC[onto: REF CD.ObjectClass, prop: REF, val: REF] =
BEGIN
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]
END;

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

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

PutPropOnPropertyProcs: PUBLIC ENTRY PROC[onto: PropertyProcs, prop: REF, val: REF] =
BEGIN
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]
END;

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

GetPropFromRef: ENTRY PROC [from: REF, prop: REF] RETURNS [REF] =
INLINE BEGIN
x: REF;
found: BOOL;
pp: REF CD.PropList;
[found, x] _ RefTab.Fetch[x: atomTab, key: from];
IF NOT found THEN RETURN[NIL];
pp _ NARROW[x, REF CD.PropList];
RETURN[Properties.GetProp[propList: pp^, prop: prop]]
END;

GetPropFromObject: PUBLIC PROC [from: CD.Object, prop: REF] RETURNS [REF] =
BEGIN
ENABLE UNWIND => NULL;
RETURN[Properties.GetProp[from.properties, prop]]
END;

GetPropFromInstance: PUBLIC PROC [from: CD.Instance, prop: REF] RETURNS [REF] =
BEGIN
ENABLE UNWIND => NULL;
RETURN[Properties.GetProp[from.properties, prop]]
END;

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

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

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

GetPropFromAtom: PUBLIC PROC [from: ATOM, prop: REF] RETURNS [REF] =
BEGIN
RETURN[GetPropFromRef[from: from, prop: prop]];
END;


InstallProcs: PUBLIC ENTRY PROC [prop: REF, new: PropertyProcsRec] =
BEGIN
ENABLE UNWIND => NULL;
class: PropertyProcs _ FetchProcs[prop];
IF class#NIL THEN {
IF new.exclusive THEN class.exclusive_TRUE;
IF new.makeCopy#NIL THEN class.makeCopy _ new.makeCopy;
IF new.internalWrite#NIL THEN class.internalWrite _ new.internalWrite;
IF new.internalRead#NIL THEN class.internalRead _ new.internalRead;
IF new.properties#NIL THEN
FOR l: PropList _ new.properties, l.rest WHILE l#NIL DO
class.properties _ Properties.PutProp[class.properties, l.first.key, l.first.val];
ENDLOOP;
}
END;

FetchProcs: PUBLIC PROC [prop: REF] RETURNS [PropertyProcs] =
BEGIN
x: REF;
found: BOOL;
[found: found, val: x] _ RefTab.Fetch[propertyNameTab, prop];
IF found THEN RETURN [NARROW[x, PropertyProcs]] ELSE RETURN [NIL] 
END;

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

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

PutOn: PROC [putOnto: REF, propList: PropList] = 
BEGIN
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 HasNoCDProperties
END;

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

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

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

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

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

InternalCopyItem: PROC[list: CDProperties.PropList, item: Properties.KeyVal, purpose: REF] RETURNS [newList: CDProperties.PropList] =
BEGIN
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; 
END;

DoWithinLock: PUBLIC ENTRY PROC [p: PROC] =
BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => 
IF UserProfile.Boolean["ChipNDale.CatchLowLevelErrors", TRUE] THEN CONTINUE;
};
IF p#NIL THEN p[];
END;
RopePWrite: PUBLIC PROC [prop: REF, val: REF] =
BEGIN
WITH val SELECT FROM
r: Rope.ROPE => TokenIO.WriteRope[r];
at: ATOM => TokenIO.WriteRope[Atom.GetPName[at]];
ENDCASE => TokenIO.WriteRope["bad property value"];
END;

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

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

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

RopePRead: PUBLIC PROC [prop: ATOM] RETURNS [val: REF] =
BEGIN
val _ TokenIO.ReadRope[]
END;

AtomPRead: PUBLIC PROC [prop: ATOM] RETURNS [val: REF] =
BEGIN
val _ TokenIO.ReadAtom[]
END;

IntPRead: PUBLIC PROC [prop: ATOM] RETURNS [val: REF] =
BEGIN
val _ NEW[INT_TokenIO.ReadInt[]]
END;

SomePRead: PUBLIC PROC [prop: ATOM] RETURNS [val: REF] =
BEGIN
t: TokenIO.Token _ TokenIO.ReadToken[];
SELECT t.kind FROM
atom, int, rope => val _ t.ref;
ENDCASE => val _ $Error;
END;


TiogaPCopy: PROC [prop: REF, val: REF, purpose: REF] RETURNS [copy: REF] =
BEGIN
contents: Rope.ROPE _ NIL;
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]]
END;

TiogaPWrite: PROC [prop: REF, val: REF] =
BEGIN
contents: Rope.ROPE _ NIL;
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[contents];
TokenIO.WriteRope[formatting];
END;

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

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: PROC [a: ATOM] RETURNS [BOOL_TRUE] = 
BEGIN
IF a#NIL THEN {
pType: CDProperties.PropertyProcs = CDProperties.FetchProcs[a];
RETURN [pType#NIL AND pType.exclusive]
}
END;

RemovePropFromRegistrations: PROC [atom: ATOM] = 
BEGIN
RemProps: PROC [atom: ATOM, 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 PutPropOnAtom[onto: atom, prop: a, val: NIL];
PutPropOnAtom[onto: a, prop: atom, val: NIL];
}
ENDCASE => NULL;
ENDLOOP; 
};
IF atom=$RegistrationRoot THEN ERROR; --don't do this
WITH GetProp[$RegistrationRoot, atom] SELECT FROM
loa: LIST OF ATOM => TRUSTED {RemProps[atom, LOOPHOLE[loa]]}; 
lora: LIST OF REF ANY => RemProps[atom, lora]; 
a: ATOM => RemProps[atom, LIST[a]]
ENDCASE => NULL;
END;

RemovePropFromLayers: PROC [atom: ATOM] = 
BEGIN
FOR l: CD.Layer IN CD.Layer DO
reg: ATOM _ CD.LayerKey[l];
IF reg#NIL THEN {
PutPropOnAtom[onto: atom, prop: reg, val: NIL];
PutPropOnAtom[onto: reg, prop: atom, val: NIL];
};
PutPropOnLayer[onto: l, prop: atom, val: NIL];
ENDLOOP;
END;

RemoveProperties: PUBLIC PROC[key: ATOM] =
BEGIN
IF ~IsExclusive[key] THEN { 
PutPropOnAtom[onto: key, prop: key, val: NIL];
RemovePropFromRegistrations[key];
RemovePropFromLayers[key];
};
END;

RemovePropCommand: Commander.CommandProc = 
BEGIN
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;
END;

Associate: PUBLIC PROC [key, a: ATOM] = 
TRUSTED BEGIN
IF ~IsExclusive[a] AND ~IsExclusive[key] THEN {
list: LIST OF REF ANY _ WITH GetPropFromAtom[$RegistrationRoot, key] SELECT FROM
lora: LIST OF REF ANY => lora,
loa: LIST OF ATOM => LOOPHOLE[loa],
a: ATOM => LIST[a],
ENDCASE => NIL;
IF ~List.Memb[a, list] THEN {
n: LIST OF REF ANY _ List.Nconc1[list, a];
IF n#list THEN PutPropOnAtom[onto: $RegistrationRoot, prop: key, val: n];
};
};
END;

AssociatePropCommand: Commander.CommandProc = 
BEGIN
key: ATOM _ NIL;
rl: LIST OF Rope.ROPE _ CommandTool.ParseToList[cmd].list;
IF rl=NIL OR IsExclusive[key_Atomize[rl.first]] THEN {
msg _ "no or exclusive key\n";
result _ $Failure;
RETURN
};
IF rl.rest=NIL THEN {
msg _ "no properties to associate with key\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[key, a];
ENDLOOP
END;


[] _ RegisterProperty[$RegistrationRoot];
InstallProcs[$RegistrationRoot, CDProperties.PropertyProcsRec[exclusive: TRUE]];
Commander.Register[
key: "///ChipNDale/CDRemoveRegistration", --command used by ChipNDale command files only
proc: RemovePropCommand,
doc: "removes properties from all ChipNDale layers"
];
Commander.Register[
key: "///ChipNDale/CDAssociateRegistration", --command used by ChipNDale command files only
proc: AssociatePropCommand,
doc: "associate ChipNDale properties for removal"
];


[] _ CDProperties.RegisterProperty[$SignalName];
[] _  CDProperties.RegisterProperty[$InstanceName];
[] _  CDProperties.RegisterProperty[$Tioga];
CDProperties.InstallProcs[prop: $SignalName, new: 
CDProperties.PropertyProcsRec[
makeCopy: CDProperties.CopyVal,
internalWrite: CDProperties.RopePWrite,
internalRead: CDProperties.RopePRead
]];
CDProperties.InstallProcs[prop: $InstanceName, new: 
CDProperties.PropertyProcsRec[
makeCopy: CDProperties.CopyVal,
internalWrite: CDProperties.RopePWrite,
internalRead: CDProperties.RopePRead
]];
CDProperties.InstallProcs[prop: $Tioga, new: 
CDProperties.PropertyProcsRec[
makeCopy: TiogaPCopy,
internalWrite: TiogaPWrite,
internalRead: TiogaPRead
]];
END.


²CDPropertiesImpl.mesa   a ChipNDale module
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
by Ch. Jacobi,  September 27, 1983 2:06 pm
last edited Christian Jacobi,  January 28, 1986 3:09:49 pm PST
--Registration
--registers "prop" in a table; any program which wants to use an ATOM 
--as a "prop" gets to know if it is already in use. 
--Usage
--a NIL val removes the property
--NIL if prop is not found
--speed ups  
--a NIL val removes the property
--a NIL val removes the property
--a NIL val removes the property
--a NIL val removes the property
--a NIL val removes the property
--a NIL val removes the property
--a NIL val removes the property
--a NIL val removes the property
--a NIL val removes the property
--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
--NIL if prop is not found
--NIL if prop is not found
--NIL if prop is not found
--NIL if prop is not found
--NIL if prop is not found
--NIL if prop is not found
--property procedures
--prop must be registered and yours
--overwrites values for which new has non NIL entries
--never copy PropertyProcs^; it can be extended by future calls of InstallProcs
--dangerous procedure; might crash
--Copies properties individually using their MakeCopyProc's and defaults for some types 
--The resulting propList is put on putOnto 


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

--removes from this atom all properties hanging on $RegistrationRoot
--removes this atom's property from all atoms hanging on $RegistrationRoot
--removes atom-property from all layers, all layer's registrationkeys,
--and the layers registrationkeys-properties from atom
--not entry!
--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 atom command file 
--not entry!

--module initialization
--does not really belong into this module
ΚΕ˜
codeš
œ*™*Kšœ
Οm
œ7™BKš
œ*™*Kš
œ>™>K˜—š
Οk	˜	K˜
K˜Kšžœ
˜K˜
K˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜	Kšœ
žœžœ˜Kš
œ˜Kšœžœ˜Kšœžœ#˜4—K˜šΠlnœžœ
žœ
˜ Kšžœ‰
˜
Kšžœ ˜'—Kš
ž˜K˜Kšœ
žœžœ
˜Kšœžœ˜1Kšœžœ!˜7K˜Kšœ'Οc?˜fK˜Kš
œ™K˜Kšœ/ +˜ZKšœ/ ˜KK˜šΟnœžœ
ž
œžœžœ
žœžœ	žœ˜iKš
œF™FKš
œ4™4Kš
ž˜Kš
œ˜Kšœžœ
˜Kšœ= ˜Zšžœžœ˜Kšžœžœ
žœžœ
žœžœ˜CKšžœ
žœ
žœ
žœ˜.K˜
—šžœ˜Kšœžœ˜*Kš
œ˜Kšœ/ ˜7Kšœ< ˜KK˜—Kšžœ
˜K˜K˜—Kš
œ™K˜Kšœžœžœ
˜ K˜š‘œžœ
žœžœžœžœ˜7Kš
œ ™ Kš
ž˜šžœžœ
ž˜Kšœžœ-˜2Kšœžœ)˜.Kšœžœ,˜2Kšœžœ)˜.Kšœžœ1˜6Kšœžœ!˜)Kšœžœ1˜>Kš
œ<˜<Kšžœžœ˜"—Kšžœ
˜K˜—š‘œžœ
žœžœžœžœžœ˜;Kš
œ™Kš
ž˜šžœžœžœ
ž˜Kšœžœ1˜6Kšœžœ/˜4Kš
œ-˜-Kš
œ-˜-Kšœžœ˜&Kšœžœ0˜5Kšœžœ4˜9Kšœžœ9˜FKš
œ:˜:Kšžœžœ˜#—Kšžœ
˜—K˜š‘œžœ
žœžœžœžœ˜TKšžœ
žœžœ
˜Jšžœ%˜+Jš
œ˜K˜—Kš
œ
™
K˜š‘œžœ
žœ
žœžœžœžœ˜MKš
œ ™ Kš
ž˜Kšžœ
žœžœ
˜Kšžœžœ
žœ
žœ
žœ
žœ
žœ$˜IKš
œ,˜,Kšžœ
˜K˜—š‘œžœ
žœ
žœžœžœžœ˜KKš
œ ™ Kš
ž˜Kšžœ
žœž˜Kšžœžœ
žœ
žœ
žœ
žœ
žœ˜AKš
œ@˜@Kšžœ
˜K˜—š‘œžœ
žœ
žœžœžœžœ˜NKš
œ ™ Kš
ž˜Kšžœ
žœž˜Kšžœžœ
žœ
žœ
žœ
žœ
žœ˜CKš
œ@˜@Kšžœ
˜K˜—š‘œžœ
žœ
žœžœžœžœ˜KKš
œ ™ Kš
ž˜Kšžœ
žœž˜šžœžœ
žœžœ
˜(Kšžœ
žœ
žœ
žœ$˜8—Kš
œB˜BKšžœ
˜K˜—š‘œžœ
žœ
žœžœžœžœ˜RKš
œ ™ Kš
ž˜Kšžœ
žœž˜šžœžœ
žœžœ
˜(Kšžœ
žœ
žœ
žœ$˜8—Kš
œB˜BKšžœ
˜K˜—š‘œžœ
žœ
žœžœ
žœžœžœ˜RKš
œ ™ Kš
ž˜Kšžœ
žœžœ
˜š
žœžœ
žœžœ
žœ
˜(Kšžœ
žœ
žœ
žœ$˜8—Kš
œB˜BKšžœ
˜K˜—š‘
œžœ
žœžœžœžœ˜?Kš
œ ™ Kš
œ.˜.Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœ˜HKš
œ ™ Kš
ž˜Kšžœ
žœž˜Kš
œf˜fKšžœ
˜K˜—š‘œžœ
žœ
žœžœžœ˜UKš
œ ™ Kš
ž˜Kšžœ
žœžœ
˜š
žœžœ
žœžœ
žœ
˜(Kšžœ
žœ
žœ
žœ#˜7—Kš
œ@˜@Kšžœ
˜K˜—š‘œžœ
žœžœžœžœ˜:Kš
œ ™ Kš
œM™MKš
œ<™<Kš
ž˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
žœ
˜Kš
œ1˜1Kš
žœžœžœžœ
žœ
˜-šžœ˜Kšžœžœ
žœ
žœ
˜Kšœžœ
žœ
žœ˜Kš
œ2˜2K˜—Kš
œ>˜>Kšžœžœ
žœ+˜:Kšžœ
˜K˜—š‘œž
œžœžœžœžœ˜AKš
œ™Kš
œM™MKš
œ<™<Kš
ž˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
žœ
˜Kš
œ1˜1Kš
žœ
žœžœ
žœ
žœ˜Kšœžœžœ
žœ˜ Kšžœ/˜5Kšžœ
˜K˜—š‘œžœ
žœžœžœžœžœ˜KKš
œ™Kš
ž˜Kšžœ
žœžœ
˜Kšžœ+˜1Kšžœ
˜K˜—š‘œžœ
žœžœžœžœžœ˜OKš
œ™Kš
ž˜Kšžœ
žœžœ
˜Kšžœ+˜1Kšžœ
˜K˜—š‘œžœ
žœžœžœžœžœ˜KKš
œ™Kš
ž˜Kšžœ
žœžœ
˜Kšžœ,˜2Kšžœ
˜K˜—š‘œžœ
žœžœžœžœžœ˜SKš
œ™Kš
ž˜Kšžœ
žœžœ
˜Kšžœ,˜2Kšžœ
˜—K˜š‘œžœ
žœžœžœžœžœ˜IKš
œ™Kš
ž˜Kšžœ
žœžœ
˜Kšžœ>˜DKšžœ
˜K˜—š‘œžœ
žœžœžœžœžœ˜DKš
œ™Kš
ž˜Kšžœ)˜/Kšžœ
˜—K˜Kš
œ™K˜š
‘œžœ
žœ
žœžœ˜DKš
œ#™#Kš
œ5™5Kš
ž˜Kšžœ
žœž˜K˜(šžœžœ
žœ˜Kšžœžœžœ
˜+Kšžœžœ
žœ˜7Kšžœžœ
žœ)˜FKšžœžœ
žœ'˜Cšžœž	˜šžœ&žœžœ
ž˜7Kš
œR˜RKšžœ
˜——Kš
œ
˜
—Kšžœ
˜K˜—š
‘
œžœ
žœžœžœ˜=Kš
œO™OKš
ž˜Kšœžœ
˜Kšœžœ
˜K˜=Kšžœžœ
žœžœžœ
žœžœ˜BKšžœ
˜K˜—š‘œžœ
žœžœžœžœžœžœ˜QKš
ž˜K˜Kšžœ
˜K˜—š‘œžœ
žœžœžœžœžœžœ
žœ˜RKš
ž˜Kšžœ
˜K˜—š‘œžœžœ˜1Kš
œ"™"Kš
ž˜šžœ	žœ
ž˜Kšœžœ%˜*Kšœžœ#˜(Kšœžœ˜!Kšœžœ$˜)Kšœžœ(˜-Kšœžœ
žœ-˜:Kš
œ/˜/Kšœžœžœ
˜Kšžœžœ˜"—Kš
ž˜—K˜š‘	œžœ
žœ
žœžœžœ
žœ˜SKš
œX™XKš
œ+™+Kš
ž˜Kšžœ
žœžœ
˜š
œ?˜?Kšœ
žœžœ
˜'—Kšžœžœ
žœ
žœ˜4Kšžœ
˜K˜—š‘œžœ
žœ
žœžœžœžœ
žœ˜_Kš
ž˜Kšžœ
žœžœ
˜š
œG˜GKšœ
žœžœ	˜&—Kšžœžœ
žœ
žœ˜4šžœ
˜K™——š‘œžœ
žœ
žœžœžœžœ˜gKš
ž˜Kšžœ
žœžœ
˜Kš
œ4˜4Kšžœ
˜K˜—š‘œžœ
ž
œ'žœ	žœžœ ˜…
š
ž˜Kšžœ
žœžœ
˜Kš
œ<˜<Kšžœ
˜—K˜—š
‘œžœžœžœžœ˜bKš
ž˜šžœ žœžœ
ž˜1Kš
œ/˜/Kšžœ
˜—Kšžœ
˜K˜—š
‘œžœ'žœ	žœžœ ˜€
š
ž˜Kš
œ3˜3šžœžœžœ
ž˜/Kš
œ/˜/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šžœžœ
˜šœ
žœ˜Kšžœ6žœžœ
žœ
˜L—Kš
œ˜—Kšžœžœ
žœ˜Kšžœ
˜K™—šΟb
œžœžœžœ˜/Kš
ž˜šžœžœ
ž˜Kšœžœ˜%Kšœžœ)˜1Kšžœ,˜3—Kšžœ
˜K˜—š’
œžœžœžœ˜/Kš
ž˜šžœžœ
ž˜Kšœžœ˜"Kšœžœ(˜4Kšžœ˜#—Kšžœ
˜K˜—š
Πbn	œžœ
žœžœžœ˜.Kš
ž˜šžœžœ
ž˜Kšœžœ
žœ˜%Kšœžœ
žœ˜*Kšœžœ
žœ˜%Kšžœ˜—Kšžœ
˜K˜—š
£
œžœ
žœžœžœ˜/Kš
ž˜šžœžœ
ž˜Kšœžœ˜"Kšœžœ˜%Kšœžœ
žœ˜%Kšœžœ
žœ˜*Kšœžœ
žœ˜%Kšžœ ˜'—Kšžœ
˜K˜—š
’	œžœžœžœžœ˜8Kš
ž˜K˜Kšžœ
˜K˜—š
’	œžœžœžœžœ˜8Kš
ž˜K˜Kšžœ
˜K˜—š£œžœ
žœžœžœžœ˜7Kš
ž˜Kšœžœ
žœ˜ Kšžœ
˜K˜—š£	œžœ
žœžœžœžœ˜8Kš
ž˜Kš
œ'˜'šžœž˜Kš
œ˜Kšžœ˜—Kšžœ
˜K˜—Kš
œ™Kš
œ™K˜š‘
œžœžœžœžœžœžœ˜JKš
ž˜Kšœžœžœ
˜Kšœžœžœ
˜šžœžœ
ž˜š
œ!˜!Kš
œ˜Kš
œ˜—Kšœžœ˜Kšžœ˜—KšœžœK˜UKšžœ
˜—K˜š‘œžœžœžœ˜)Kš
ž˜Kšœžœžœ
˜Kšœžœžœ
˜šžœžœ
ž˜š
œ!˜!Kš
œ˜Kš
œ˜—Kšœžœ˜Kšžœžœ
˜—Kš
œ˜Kš
œ˜Kšžœ
˜K˜—š
‘
œžœžœžœžœ˜2Kš
ž˜Kšœžœ˜)Kšœžœ˜+KšœžœK˜TKšžœ
˜—K™J˜š‘œžœ
žœžœžœ
žœ˜3Kšžœžœžœ)˜VKšžœžœ
žœ˜2K˜—K˜š‘œžœžœžœžœ
žœ˜2Kš
ž˜šžœžœ
žœ˜Kš
œ?˜?Kšžœžœ
žœ˜&K˜
—Kšžœ
˜—J˜š‘œžœžœ˜1Jš
œD™DJš
œJ™JJš
ž˜š‘œžœžœžœ
žœ
žœ
žœ˜6šžœžœ
žœ
žœ
žœžœžœ
ž˜4šžœ	žœ
ž˜šœžœ˜Jšžœžœ)žœ˜EJšœ(žœ˜-J˜
—Jšžœžœ
˜—Jšžœ˜	—J˜—Jšžœžœ
žœ ˜5šžœ"žœ
ž˜1Jšœžœ
žœ
žœžœžœ	˜>Jš	œžœ
žœ
žœ
žœ˜/Jšœžœžœ˜"Jšžœžœ
˜—Kšžœ
˜—K˜š‘œžœžœ˜*Jš
œF™FJš
œ6™6Jš
ž˜š	žœžœžœ
žœž˜Jšœžœžœ
˜šžœžœ
žœ˜Jšœ*žœ˜/Jšœ*žœ˜/J˜—Jšœ)žœ˜.Jšžœ
˜—Kš
ž˜—K˜š‘œžœ
žœžœ˜*Kš
œ™Kš
ž˜šžœžœ˜Jšœ)žœ˜.Jš
œ!˜!Kš
œ˜J˜—Kšžœ
˜—K˜š’œ˜+Kš
œ>™>Kš
œ+™+Kš
œ_™_Kš
ž˜š
žœžœ
žœžœ.žœžœ
ž˜VJšœžœ ,˜Lšžœžœ
˜Kš
œK˜K—Kšžœ˜Jšžœ
˜—Kšžœ
˜K˜—š‘	œžœ
žœ˜(Kš
œ™Kš
ž
˜
šžœžœžœ˜/šœžœ
žœ
žœ
žœžœ)žœ
ž˜PKš	œžœ
žœ
žœ
žœ	˜Kš	œžœ
žœ
žœžœ˜#Kšœžœžœ˜Kšžœžœ
˜—šžœžœ˜Kš	œžœ
žœ
žœ
žœ˜*Kšžœžœ;˜IK˜—K˜—Kšžœ
˜—K˜š’œ˜.Kš
ž˜Kšœžœžœ
˜Kšœžœ
žœžœ%˜:šžœžœ
žœ$žœ˜6Kš
œ˜Kš
œ˜Kš
ž˜K˜—šžœ	žœ
žœ˜Kš
œ.˜.Kš
œ˜Kš
ž˜K˜—š
žœžœ
žœžœžœžœ
ž˜9Kšœžœ˜Kšžœžœ/˜EKšžœ˜Kš
ž˜—Kšžœ
˜K˜—K™K™K˜Kš
œ)˜)KšœIžœ˜Pš
œ˜Kšœ* .˜XKš
œ˜Kš
œ3˜3Kš
œ˜—š
œ˜Kšœ- .˜[Kš
œ˜Kš
œ1˜1Kš
œ˜—K˜K˜Kš
œ)™)Kš
œ0˜0Kš
œ3˜3Kš
œ,˜,š
œ2˜2š
œ˜Kš
œ˜Kš
œ'˜'Kš
œ$˜$Kš
œ˜——š
œ4˜4š
œ˜Kš
œ˜Kš
œ'˜'Kš
œ$˜$Kš
œ˜——š
œ-˜-š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜——Kšžœ
˜K˜K˜—…—Chgί