DIRECTORY
NodeStyleExtra,
NodeStyle,
NodeStyleObject,
TiogaNode,
TiogaNodeOps,
TiogaLooks,
TiogaLooksOps,
TiogaPathOps,
EditNotify,
NodeProps,
NameSymbolTable,
Inline,
JaMOps;

NodeStyleApplyImpl: CEDAR MONITOR
IMPORTS EditNotify, Inline, JaMOps, NameSymbolTable, NodeProps, NodeStyle, NodeStyleExtra, TiogaPathOps
EXPORTS NodeStyle, NodeStyleExtra =
BEGIN
OPEN NodeStyle, NodeStyleExtra;


defaultStyle: PUBLIC Ref; -- contains initial values for the style parameters
defaultName, rootName: Name;

ApplyAll: PUBLIC PROC [ref: Ref, path: TiogaNode.Path, kind: OfStyle _ screen] = {
[] _ DoApplyAll[ref, path, kind] };

DoApplyAll: PROC [ref: Ref, path: TiogaNode.Path, kind: OfStyle] RETURNS [depth: CARDINAL] = {
found: BOOLEAN;
parent: TiogaNode.Path;
alt: Name;
IF path.node=NIL THEN { ref^ _ defaultStyle^; RETURN [0] };
[found, depth] _ FindInApplyAllCache[ref, path, kind];
IF found THEN RETURN [depth+1];
parent _ TiogaPathOps.Parent[path];
alt _ IF parent=TiogaNode.nullPath THEN rootName ELSE defaultName;
depth _ DoApplyAll[ref, parent, kind];
ApplyForNode[ref, path, alt, kind];
EnterInApplyAllCache[ref, path, depth];
RETURN [depth+1] };

applyCacheInfo: REF ApplyCacheRecord _ NEW[ApplyCacheRecord];
ApplyCacheRecord: TYPE = RECORD [
applyCacheDepth: CARDINAL _ 0,  -- next free entry
applyCacheResults: REF ApplyCacheResults,
applyCachePaths: REF ApplyCachePaths,
applyCacheProbes, applyCacheHits, applyCacheSaves: INT _ 0 ];
applyCacheSize: CARDINAL = 8; -- number of levels deep in tree
ApplyCachePaths: TYPE = ARRAY [0..applyCacheSize) OF TiogaNode.Path;
ApplyCacheResults: TYPE = ARRAY [0..applyCacheSize) OF StyleBody;	

InitApplyCacheRecord: PROC = { OPEN applyCacheInfo;
applyCacheResults _ NEW[ApplyCacheResults];
applyCachePaths _ NEW[ApplyCachePaths] };

RemoveAllFromApplyAllCache: PUBLIC PROC = { FlushApplyAllCache[] };

FlushApplyAllCache: PUBLIC ENTRY PROC [init: BOOLEAN _ FALSE] = {
ENABLE UNWIND => NULL;
ClearApplyAllCache[init] };

ClearApplyAllCache: PROC [init: BOOLEAN] = { OPEN applyCacheInfo;
paths: REF ApplyCachePaths _ applyCachePaths;
FOR i:CARDINAL IN [0..applyCacheSize) DO paths[i] _ TiogaNode.nullPath; ENDLOOP;
applyCacheDepth _ 0 };

RemoveNodeFromApplyAllCache: PUBLIC ENTRY PROC [node: TiogaNode.Ref] = {
OPEN applyCacheInfo;
ENABLE UNWIND => NULL;
paths: REF ApplyCachePaths _ applyCachePaths;
FOR i:CARDINAL IN [0..applyCacheDepth) DO 
IF paths[i].node=node THEN { -- clear from here on
FOR j:CARDINAL IN [i..applyCacheSize) DO
paths[j] _ TiogaNode.nullPath; ENDLOOP;
applyCacheDepth _ i; EXIT };
ENDLOOP };

FindInApplyAllCache: ENTRY PROC [ref: Ref, path: TiogaNode.Path, kind: OfStyle]
RETURNS [found: BOOLEAN, depth: CARDINAL] = { OPEN applyCacheInfo;
ENABLE UNWIND => NULL;
node: TiogaNode.Ref = path.node;
paths: REF ApplyCachePaths _ applyCachePaths;
print: BOOL = (kind=print); -- if true, then find result with print true also
applyCacheProbes _ applyCacheProbes+1;
FOR i:CARDINAL DECREASING IN [0..applyCacheDepth) DO
IF paths[i].node=node AND print=applyCacheResults[i].print AND
TiogaPathOps.Equal[paths[i], path] THEN { -- found it
applyCacheHits _ applyCacheHits+1;
applyCacheSaves _ applyCacheSaves+i+1;
ref^ _ applyCacheResults[i];
RETURN [TRUE, i] };
ENDLOOP;
RETURN [FALSE, 0] };

EnterInApplyAllCache: ENTRY PROC [ref: Ref, path: TiogaNode.Path, depth: CARDINAL] = {
OPEN applyCacheInfo;
ENABLE UNWIND => NULL;
paths: REF ApplyCachePaths _ applyCachePaths;
IF depth >= applyCacheSize THEN RETURN;
paths[depth] _ path;
applyCacheResults[depth] _ ref^;
FOR i:CARDINAL IN [depth+1..applyCacheSize) DO paths[i] _ TiogaNode.nullPath; ENDLOOP;
applyCacheDepth _ depth+1 };

prefixAtom: ATOM = NodeProps.PrefixAtom[];
postfixAtom: ATOM = NodeProps.PostfixAtom[];

Notify: PROC [change: REF READONLY EditNotify.Change] = TRUSTED {
HasSubstructure: PROC [node: TiogaNode.Ref] RETURNS [BOOL] = TRUSTED {
path: TiogaNode.Path = [node, NIL];
IF TiogaPathOps.Contents[path] # TiogaNode.nullPath THEN RETURN [TRUE];
IF TiogaPathOps.BranchChild[path] # TiogaNode.nullPath THEN RETURN [TRUE];
RETURN [FALSE] }; 
DoNode: PROC [node: TiogaNode.Ref] = TRUSTED {
IF HasSubstructure[node] THEN FlushApplyAllCache
ELSE RemoveNodeFromApplyAllCache[node] };
WITH x:change SELECT FROM
InsertingNode => IF HasSubstructure[x.new] THEN FlushApplyAllCache;
MovingNodes, MovingGroup => FlushApplyAllCache;
NodeNesting => IF x.first = x.last -- only changing one node
AND ~HasSubstructure[x.first] -- node has no substructure
THEN SELECT x.change FROM
1 => FlushApplyAllCache; -- increasing nesting in tree
-1 => RemoveNodeFromApplyAllCache[x.first]; -- decreasing nesting in tree
ENDCASE => FlushApplyAllCache
ELSE FlushApplyAllCache;
ChangingFormat => DoNode[x.node];
ChangingProp => SELECT x.propAtom FROM
prefixAtom, postfixAtom, $Comment, $StyleDef => DoNode[x.node];
ENDCASE;
ENDCASE => ERROR; -- not expecting notify for any other kinds of changes
};

ApplyForNode: PUBLIC PROC [ref: Ref, path: TiogaNode.Path, alt: Name, kind: OfStyle] = {
ext: ATOM;
node: TiogaNode.Ref = path.node;
ref.isComment _ node.comment;
ref.print _ (kind=print);
ref.nestingLevel _ MIN[TiogaPathOps.Level[path], MaxNestingLevel];
EvalFreeVars[ref, node];
IF node.hasstyledef THEN {
localStyle: LocalStyle _ NARROW[NodeProps.GetProp[node, $StyleDef]];
IF localStyle # NIL THEN ref.name[style] _ localStyle.name };
IF node.hasprefix THEN ApplyObject[ref, NodeProps.GetPrefixObject[node], kind]
ELSE IF ref.nestingLevel=0 -- root node -- AND -- check for file extension default
(ext _ NARROW[NodeProps.GetProp[node, $FileExtension]])#NIL THEN
FOR list: LIST OF ExtObjPair _ defaultStylesForExtensions, list.rest UNTIL list=NIL DO
IF list.first.fileExtension # ext THEN LOOP;
ApplyObject[ref, list.first.styleObject, kind];
EXIT;
ENDLOOP;
ApplyFormat[ref, node.format, alt, kind];
IF node.haspostfix THEN ApplyObject[ref, NodeProps.GetPostfixObject[node], kind] };

ApplyFormat: PUBLIC PROC [ref: Ref, name, alt: Name, kind: OfStyle _ screen] = {
OPEN ruleCacheInfo;
BITXOR: PROC[CARDINAL, CARDINAL] RETURNS[CARDINAL] = LOOPHOLE[Inline.BITXOR];
names: REF RuleCacheNames _ ruleCacheNames;
inputs: REF RuleCacheBodies _ ruleCacheInputs;
input: StyleBody;
initloc, loc: CARDINAL;
ok: BOOLEAN;
frame: Frame _ NIL;
styleName: Name;

FindInRuleCache: ENTRY PROC RETURNS [BOOLEAN] = {
ENABLE UNWIND => NULL;
ruleCacheProbes _ ruleCacheProbes+1;
DO -- search cache
SELECT names[loc] FROM
name => IF inputs[loc] = ref^ THEN {
ref^ _ ruleCacheResults[loc];
ruleCacheHits _ ruleCacheHits+1;
RETURN [TRUE] };
NameSymbolTable.nullName => RETURN [FALSE]; -- this is an unused entry
ENDCASE;
SELECT (loc _ loc+1) FROM
ruleCacheSize => IF (loc _ 0)=initloc THEN RETURN [FALSE];
initloc => RETURN [FALSE];
ENDCASE;
ENDLOOP };

PutInRuleCache: ENTRY PROC = {
ENABLE UNWIND => NULL;
IF ruleCacheCount = ruleCacheMax THEN ClearRuleCache[];
loc _ initloc;
DO -- search cache for place to put the entry
SELECT names[loc] FROM
name => IF inputs[loc] = input THEN RETURN; -- already in cache
NameSymbolTable.nullName => EXIT; -- this is an unused entry
ENDCASE;
SELECT (loc _ loc+1) FROM
ruleCacheSize => IF (loc _ 0)=initloc THEN ERROR; -- cache full
initloc => ERROR; -- cache full
ENDCASE;
ENDLOOP;
ruleCacheCount _ ruleCacheCount+1;
inputs[loc] _ input;
ruleCacheResults[loc] _ ref^;
names[loc] _ name };

IF name = NameSymbolTable.nullName AND
(name _ alt) = NameSymbolTable.nullName THEN RETURN;
loc _ initloc _ BITXOR[LOOPHOLE[name, CARDINAL], Hash[ref]] MOD ruleCacheSize;
IF FindInRuleCache[] THEN RETURN;
frame _ GetFrame[ref, styleName _ ref.name[style], kind];
input _ ref^; -- save the input value of the record
ok _ ExecuteName[frame, name];
FreeFrame[frame, styleName, kind]; frame _ NIL;
IF ok THEN PutInRuleCache[] -- save results in cache
ELSE IF name # alt THEN ApplyFormat[ref, alt, NameSymbolTable.nullName] };

ruleCacheInfo: REF RuleCacheInfoRecord _ NEW[RuleCacheInfoRecord];
RuleCacheInfoRecord: TYPE = RECORD [
ruleCacheCount: CARDINAL _ 0, -- number of entries currently in use
ruleCacheNames: REF RuleCacheNames,
ruleCacheInputs: REF RuleCacheBodies,
ruleCacheResults: REF RuleCacheBodies,
ruleCacheProbes, ruleCacheHits: INT _ 0 ];
ruleCacheSize: CARDINAL = 64; -- should be a power of 2
ruleCacheMax: CARDINAL = (ruleCacheSize*4)/5; -- don't fill too full
RuleCacheNames: TYPE = ARRAY [0..ruleCacheSize) OF Name;
RuleCacheBodies: TYPE = ARRAY [0..ruleCacheSize) OF StyleBody;

InitRuleCacheInfo: PROC = { OPEN ruleCacheInfo;
ruleCacheNames _ NEW[RuleCacheNames];
ruleCacheInputs _ NEW[RuleCacheBodies];
ruleCacheResults _ NEW[RuleCacheBodies] };

FlushRuleCache: ENTRY PROC [init: BOOLEAN _ FALSE] = {
ENABLE UNWIND => NULL;
ClearRuleCache[] };

ClearRuleCache: PROC [init: BOOLEAN _ FALSE] = { OPEN ruleCacheInfo;
names: REF RuleCacheNames _ ruleCacheNames;
IF ~init AND ruleCacheCount = 0 THEN RETURN;
ruleCacheCount _ 0;
FOR i: CARDINAL IN [0..ruleCacheSize) DO
names[i] _ NameSymbolTable.nullName; ENDLOOP };

Hash: PROC [ref: Ref] RETURNS [CARDINAL] = { 
BITXOR: PROC[CARDINAL, CARDINAL] RETURNS[CARDINAL] = LOOPHOLE[Inline.BITXOR];
RETURN [LOOPHOLE[
BITXOR[LOOPHOLE[ref.name[style]],
BITXOR[LOOPHOLE[ref.name[fontFamily], CARDINAL],
BITXOR[ref.real[fontSize],
BITXOR[ref.real[leftIndent],
ref.real[leading]]]]], CARDINAL]] };

ApplyLooks: PUBLIC PROC [ref: Ref, looks: TiogaLooks.Looks, kind: OfStyle] = {
OPEN looksCacheInfo;
BITXOR: PROC[CARDINAL, CARDINAL] RETURNS[CARDINAL] = LOOPHOLE[Inline.BITXOR];
lks: REF LooksCacheLooks _ looksCacheLooks;
inputs: REF LooksCacheBodies _ looksCacheInputs;
initloc, loc: CARDINAL;
input: StyleBody;
frame: Frame _ NIL;
styleName: Name;

FindInLooksCache: ENTRY PROC RETURNS [BOOLEAN] = {
ENABLE UNWIND => NULL;
looksCacheProbes _ looksCacheProbes+1;
DO -- search cache
SELECT lks[loc] FROM
looks => IF inputs[loc] = ref^ THEN {
ref^ _ looksCacheResults[loc];
looksCacheHits _ looksCacheHits+1;
RETURN [TRUE] };
TiogaLooks.noLooks => RETURN [FALSE]; -- this is an unused entry
ENDCASE;
SELECT (loc _ loc+1) FROM
looksCacheSize => IF (loc _ 0)=initloc THEN RETURN [FALSE];
initloc => RETURN [FALSE];
ENDCASE;
ENDLOOP };

PutInLooksCache: ENTRY PROC = {
ENABLE UNWIND => NULL;
IF looksCacheCount = looksCacheMax THEN ClearLooksCache[];
loc _ initloc;
DO -- search cache
SELECT lks[loc] FROM
looks => IF inputs[loc] = input THEN RETURN; -- already in cache
TiogaLooks.noLooks => EXIT; -- this is an unused entry
ENDCASE;
SELECT (loc _ loc+1) FROM
looksCacheSize => IF (loc _ 0)=initloc THEN ERROR; -- cache full
initloc => ERROR; -- cache full
ENDCASE;
ENDLOOP;
looksCacheResults[loc] _ ref^;
lks[loc] _ looks;
inputs[loc] _ input;
looksCacheCount _ looksCacheCount+1 };

IF looks = TiogaLooks.noLooks THEN RETURN;
loc _ initloc _
BITXOR[LOOPHOLE[looks, TiogaLooksOps.LooksBytes].byte0,
BITXOR[LOOPHOLE[looks, TiogaLooksOps.LooksBytes].byte1,
BITXOR[LOOPHOLE[looks, TiogaLooksOps.LooksBytes].byte2,
Hash[ref]]]] MOD looksCacheSize;
IF FindInLooksCache[] THEN RETURN;
frame _ GetFrame[ref, styleName _ ref.name[style], kind];
input _ ref^; -- save the input value of the record
FOR c: CHARACTER IN TiogaLooks.Look DO
IF looks[c] THEN [] _ ExecuteName[frame, lookNames[c]]
ENDLOOP;
FreeFrame[frame, styleName, kind]; frame _ NIL;
PutInLooksCache[] };

looksCacheInfo: REF LooksCacheInfoRecord _ NEW[LooksCacheInfoRecord];
LooksCacheInfoRecord: TYPE = RECORD [
looksCacheCount: CARDINAL _ 0,
looksCacheLooks: REF LooksCacheLooks,
looksCacheInputs: REF LooksCacheBodies,
looksCacheResults: REF LooksCacheBodies,
looksCacheProbes, looksCacheHits: INT _ 0 ];
looksCacheSize: CARDINAL = 16; -- should be a power of 2
looksCacheMax: CARDINAL = (looksCacheSize*4)/5; -- don't fill too full
LooksCacheLooks: TYPE = ARRAY [0..looksCacheSize) OF TiogaLooks.Looks;
LooksCacheBodies: TYPE = ARRAY [0..looksCacheSize) OF StyleBody;

InitLooksCacheInfo: PROC = { OPEN looksCacheInfo;
looksCacheLooks _ NEW[LooksCacheLooks];
looksCacheInputs _ NEW[LooksCacheBodies];
looksCacheResults _ NEW[LooksCacheBodies] };

lookNames: ARRAY TiogaLooks.Look OF Name; 

FlushLooksCache: ENTRY PROC [init: BOOLEAN _ FALSE] = {
ENABLE UNWIND => NULL;
ClearLooksCache[] };

ClearLooksCache: PROC [init: BOOLEAN _ FALSE] = { OPEN looksCacheInfo;
IF ~init AND looksCacheCount = 0 THEN RETURN;
looksCacheCount _ 0;
FOR i: CARDINAL IN [0..looksCacheSize) DO
looksCacheLooks[i] _ TiogaLooks.noLooks; ENDLOOP };

nullObject: NameSymbolTable.Object = NameSymbolTable.NullObject[];

ApplyObject: PUBLIC PROC [ref: Ref, object: NameSymbolTable.Object, kind: OfStyle _ screen] = {
OPEN objectCacheInfo;
BITXOR: PROC[CARDINAL, CARDINAL] RETURNS[CARDINAL] = LOOPHOLE[Inline.BITXOR];
objects: REF ObjectCacheObjects _ objectCacheObjects;
inputs: REF ObjectCacheBodies _ objectCacheInputs;
input: StyleBody;
initloc, loc: CARDINAL;
initDepth, finalDepth: CARDINAL;
obj: Object _ LOOPHOLE[object];
frame: Frame _ NIL;
styleName: Name;

FindInObjectCache: ENTRY PROC RETURNS [BOOLEAN] = {
ENABLE UNWIND => NULL;
objectCacheProbes _ objectCacheProbes+1;
DO -- search cache
SELECT objects[loc] FROM
object => IF inputs[loc] = ref^ THEN {
ref^ _ objectCacheResults[loc];
objectCacheHits _ objectCacheHits+1;
RETURN [TRUE] };
nullObject => RETURN [FALSE]; -- this is an unused entry
ENDCASE;
SELECT (loc _ loc+1) FROM
objectCacheSize => IF (loc _ 0)=initloc THEN RETURN [FALSE];
initloc => RETURN [FALSE];
ENDCASE;
ENDLOOP };

PutInObjectCache: ENTRY PROC = {
ENABLE UNWIND => NULL;
IF objectCacheCount = objectCacheMax THEN ClearObjectCache[];
loc _ initloc;
DO -- search cache for place to put the entry
SELECT objects[loc] FROM
object => IF inputs[loc] = input THEN RETURN; -- already in cache
nullObject => EXIT; -- this is an unused entry
ENDCASE;
SELECT (loc _ loc+1) FROM
objectCacheSize => IF (loc _ 0)=initloc THEN ERROR; -- cache full
initloc => ERROR; -- cache full
ENDCASE;
ENDLOOP;
objectCacheCount _ objectCacheCount+1;
inputs[loc] _ input;
objectCacheResults[loc] _ ref^;
objects[loc] _ object };

HashObject: PROC RETURNS [CARDINAL] = {
ob: RECORD [ a, b, c, d: CARDINAL ] _ LOOPHOLE[object];
RETURN [ob.b] };

IF object = nullObject THEN RETURN;
loc _ initloc _ BITXOR[HashObject[], Hash[ref]] MOD objectCacheSize;
IF FindInObjectCache[] THEN RETURN;
frame _ GetFrame[ref, styleName _ ref.name[style], kind];
input _ ref^; -- save the input value of the record
TRUSTED {
initDepth _ JaMOps.CountStack[frame.opstk];
JaMOps.Execute[frame, CVX[obj]];
IF (finalDepth _ JaMOps.CountStack[frame.opstk]) # initDepth THEN {
PushObject[frame, obj];
PushText[frame, "Failed to leave stack at same depth after execution."];
StyleError[frame, 2] }
ELSE PutInObjectCache[]};
FreeFrame[frame, styleName, kind]; frame _ NIL };

objectCacheInfo: REF ObjectCacheInfoRecord _ NEW[ObjectCacheInfoRecord];
ObjectCacheInfoRecord: TYPE = RECORD [
objectCacheCount: CARDINAL,
objectCacheObjects: REF ObjectCacheObjects,
objectCacheInputs: REF ObjectCacheBodies,
objectCacheResults: REF ObjectCacheBodies,
objectCacheProbes, objectCacheHits: INT _ 0 ];

objectCacheSize: CARDINAL = 16; -- should be a power of 2
objectCacheMax: CARDINAL = (objectCacheSize*4)/5; -- don't fill too full
ObjectCacheObjects: TYPE = ARRAY [0..objectCacheSize) OF NameSymbolTable.Object;
ObjectCacheBodies: TYPE = ARRAY [0..objectCacheSize) OF StyleBody;

InitObjectCacheInfo: PROC = { OPEN objectCacheInfo;
objectCacheObjects _ NEW[ObjectCacheObjects];
objectCacheInputs _ NEW[ObjectCacheBodies];
objectCacheResults _ NEW[ObjectCacheBodies] };

FlushObjectCache: ENTRY PROC [init: BOOLEAN _ FALSE] = {
ENABLE UNWIND => NULL;
ClearObjectCache[] };

ClearObjectCache: PROC [init: BOOLEAN _ FALSE] = { OPEN objectCacheInfo;
IF ~init AND objectCacheCount = 0 THEN RETURN;
objectCacheCount _ 0;
FOR i: CARDINAL IN [0..objectCacheSize) DO
objectCacheObjects[i] _ nullObject; ENDLOOP };

FlushCaches: PUBLIC ENTRY PROC = {
ENABLE UNWIND => NULL;
ClearCaches[FALSE] };

ClearCaches: PROC [init: BOOLEAN] = {
ClearApplyAllCache[init]; ClearRuleCache[init];
ClearLooksCache[init]; ClearObjectCache[init] };


executingName: PUBLIC Name;

ExecuteName: PROC [frame: Frame, name: Name] RETURNS [ok: BOOLEAN] = TRUSTED {
initDepth: CARDINAL _ JaMOps.CountStack[frame.opstk];
finalDepth: CARDINAL;
nameObj: Object;
[ok, ] _ JaMOps.TryToLoad[frame, nameObj _ NameToObject[name]];
IF ~ok THEN RETURN;
executingName _ name;
JaMOps.Execute[frame, CVX[nameObj]];
executingName _ NameSymbolTable.nullName;
IF (finalDepth _ JaMOps.CountStack[frame.opstk]) # initDepth THEN {
PushText[frame, "failed to leave stack at same depth after execution."];
PushName[frame, name];
StyleError[frame, 2] }};

StyleError: PUBLIC PROC [frame: Frame, num: INTEGER] = TRUSTED {
PushInteger[frame, num];
JaMOps.Execute[frame, CVX[NameToObject[styleerror]]] };



StyleNameForNode: PUBLIC PROC [path: TiogaNode.Path] RETURNS [name: Name] = {
s: Ref _ Alloc[];
ApplyAll[s, path];
name _ GetStyleName[s];
Free[s] };



InitLookNames: PROC = TRUSTED {
txt: STRING _ [6];
txt[0] _ 'l; txt[1] _ txt[2] _ 'o; txt[3] _ 'k; txt[4] _ '.; txt.length _ 6;
FOR c: CHARACTER IN TiogaLooks.Look DO
txt[5] _ c;
lookNames[c] _ MakeName[LOOPHOLE[LONG[txt], REF READONLY TEXT]];
ENDLOOP};

StartApply: PUBLIC PROCEDURE =
BEGIN
changeSet: EditNotify.ChangeSet;
frame: Frame _ NIL;

frame _ JaMOps.defaultFrame;

changeSet[ChangingProp] _ TRUE;
changeSet[ChangingFormat] _ TRUE;
changeSet[MovingNodes] _ TRUE;
changeSet[MovingGroup] _ TRUE;
changeSet[NodeNesting] _ TRUE;
changeSet[InsertingNode] _ TRUE;
EditNotify.AddNotifyProc[Notify, after, high, changeSet];

defaultStyle _ Create[];
defaultName _ MakeName["default"];
rootName _ MakeName["root"];

InitLookNames[];
InitApplyCacheRecord[];
InitRuleCacheInfo[];
InitLooksCacheInfo[];
InitObjectCacheInfo[];
ClearCaches[TRUE];

SetDefaultStyle["Cedar"];

END;

END.

~NodeStyleApplyImpl.Mesa
written by Bill Paxton, January 1981
Last changed by Paxton, JuneAugust 2, 1983 10:11 am
Last Edited by: Maxwell, January 6, 1983 9:50 am
Apply operations
when clearing, go all the way to applyCacheSize rather than stopping at applyCacheDepth
Search for paths that end with this node and remove them.
if change invalidates one node only, remove that node
else clear entire cache
called after the edit has taken place
***** Execute
makes sure that same stack depth after execute
***** Miscellaneous
does an ApplyAll and then returns the style name
Initialization
names are "look.a", "look.b", "look.c", etc.
�Êü˜Jš
œ™Jš
œ$™$Jš
œ3™3J™0J˜š
Ïk	˜	J˜J˜
J˜J˜
J˜
Jš
œ˜Jš
œ˜Jš
œ
˜
J˜J˜
J˜J˜J˜J˜—šœ�
˜!Jš�œ`˜gJš�œ˜#—Jš
�˜Jš�œ˜J˜Jš
œ™J˜Jšœ�œÏc3˜MJ˜J˜šÏnœ�œ
�œ=˜RJ˜#J˜—šŸ
œ�œ1�œ	�œ˜^Jšœ�œ
˜Jš
œ˜J˜
Jš�œ�œ
�œ�œ˜;J˜6Jš�œ�œ
�œ˜Jš
œ#˜#Jšœ�œ�œ
�œ
˜BJ˜&J˜#J˜'Jš�œ
˜J˜—Jšœ�œ�œ˜=šœ�œ�œ˜!Jšœ�œž˜2Jšœ�œ˜)Jšœ�œ˜%Jšœ3�œ˜=—Jšœ�œž ˜>Jšœ�œ�œ�œ˜DJšœ�œ�œ�œ˜BJ˜šŸœ�œ�œ˜3Jšœ�œ˜+Jšœ�œ˜)J˜—šŸœ�œ
�œ˜CJ˜—š
Ÿœ�œ
�œ�œ�œ˜AJš�œ
�œ�œ
˜J˜J˜—šŸœ�œ�œ�œ˜AJšœ�œ#˜-Jš
œW™WJš
�œ�œ
�œ�œ �œ
˜PJ˜J˜—šŸœ�œ
�œ˜HJ™9Jš�œ˜Jš�œ
�œ�œ
˜Jšœ�œ#˜-š�œ�œ
�œ�œ
˜*š�œ�œž˜2š�œ�œ
�œ�˜(Jšœ�œ
˜'—Jšœ�œ˜—Jš�œ˜
—J˜—šŸœ�œ
�œ0˜OJš�œ	�œ	�œ�œ˜BJš�œ
�œ�œ
˜J˜ Jšœ�œ#˜-Jšœ�œž1˜MJ˜&š	�œ�œ
�
œ
�œ�˜4š�œ�œ"�˜>Jšœ#�œž˜5J˜"J˜&J˜Jš�œ�œ˜—Jš�œ
˜—Jš�œ�œ˜J˜—šŸœ�œ
�œ)�œ˜VJš�œ˜Jš�œ
�œ�œ
˜Jšœ�œ#˜-Jš�œ�œ
�œ
˜'Jš
œ˜J˜ Jš
�œ�œ
�œ�œ �œ
˜VJ˜J˜—Jšœ�œ˜*Jšœ
�œ˜,J˜š
Ÿœ�œ
�œ
�œ�œ˜AJš
œ5™5Jš
œ™J™%š
Ÿœ�œ�œ�œ�œ˜FJšœ�œ˜#Jš�œ2�œ
�œ�œ˜GJš�œ5�œ
�œ�œ˜JJš�œ�œ˜—šŸœ�œ�œ˜.Jš�œ�œ˜0Jš�œ%˜)—Jš�œ
�œ
�˜Jšœ�œ�œ˜CJ˜/šœ�œž˜<Jš�œž˜9š�œ
�œ
�˜Jšœž˜6Jšœ,ž˜IJš�œ˜—Jš�œ˜—J˜!šœ�œ�˜&J˜?Jš�œ
˜—Jš�œ�œž6˜HJ˜J˜—šŸœ�œ
�œ?˜XJšœ�œ
˜
J˜ Jš
œ˜Jš
œ˜Jšœ�œ,˜BJ˜š�œ�œ˜Jšœ�œ%˜DJš�œ�œ
�œ%˜=—Jš�œ�œ8˜Nš	�œ
�œžœ
�œ
ž#˜RJšœ�œ+�œ
�˜@š�œ�œ
�œ4�œ�œ
�˜VJš�œ �œ
�œ
˜,Jš
œ/˜/Jš�œ
˜Jš�œ
˜——Jš
œ)˜)š�œ�œ<˜SJ˜——šŸœ�œ
�œ8˜PJš�œ˜Jš�œ�œ
�œ�œ�œ
�œ�œ�œ˜MJšœ�œ!˜+Jšœ�œ#˜.J˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜J˜J˜š
Ÿœ�œ
�œ
�œ�œ˜1Jš�œ
�œ�œ
˜J˜$š�œ
ž˜š�œ�˜šœ�œ�œ˜$J˜J˜ Jš�œ�œ˜—Jšœ�œ�œž˜FJš�œ
˜—š�œ�˜Jš	œ�œ�œ
�œ�œ˜:Jšœ�œ�œ˜Jš�œ
˜—Jš�œ˜
J˜——šŸœ�œ
�œ˜Jš�œ
�œ�œ
˜Jš�œ�œ˜7J˜š�œ
ž*˜-š�œ�˜Jšœ�œ�œ
�œž˜?Jšœ�œž˜<Jš�œ
˜—š�œ�˜Jšœ�œ�œ
�œž
˜?Jšœ�œž
˜Jš�œ
˜—Jš�œ
˜—J˜"J˜J˜J˜J˜—š�œ!�˜&Jšœ(�œ
�œ
˜4—Jš	œ�œ
�œ�œ�œ˜NJš�œ�œ
�œ
˜!J˜9Jšœž%˜3J˜Jšœ+�œ
˜/Jš�œ�œž˜4Jš�œ
�œ�œ3˜JJ˜—Jšœ�œ�œ˜Bšœ�œ�œ˜$Jšœ�œž%˜CJšœ�œ˜#Jšœ�œ˜%Jšœ�œ˜&Jšœ �œ˜*—Jšœ�œž˜7Jšœ�œž˜DJšœ�œ�œ�œ˜8Jšœ�œ�œ�œ˜>J˜šŸœ�œ�œ˜/Jšœ�œ˜%Jšœ�œ˜'Jšœ�œ˜*J˜—š
Ÿœ�œ
�œ�œ�œ˜6Jš�œ
�œ�œ
˜J˜J˜—š
Ÿœ�œ�œ�œ�œ˜DJšœ�œ!˜+Jš�œ�œ�œ
�œ
˜,J˜š�œ�œ
�œ�˜(Jšœ%�œ˜/—J˜—šŸœ�œ�œ�œ˜-Jš�œ�œ
�œ�œ�œ
�œ�œ�œ˜Mš�œ�œ
˜š�œ
�œ˜!š�œ
�œ�œ˜0š�œ˜š�œ˜Jšœ�œ˜$J˜——————šŸ
œ�œ
�œ7˜NJš�œ˜Jš�œ�œ
�œ�œ�œ
�œ�œ�œ˜MJšœ�œ#˜+Jšœ�œ%˜0Jšœ�œ
˜J˜Jšœ�œ
˜J˜J˜š
Ÿœ�œ
�œ
�œ�œ˜2Jš�œ
�œ�œ
˜J˜&š�œ
ž˜š�œ
�˜šœ	�œ�œ˜%J˜J˜"Jš�œ�œ˜—Jšœ�œ�œž˜@Jš�œ
˜—š�œ�˜Jš	œ�œ�œ
�œ�œ˜;Jšœ�œ�œ˜Jš�œ
˜—Jš�œ˜
J˜——šŸœ�œ
�œ˜Jš�œ
�œ�œ
˜Jš�œ!�œ˜:J˜š�œ
ž˜š�œ
�˜Jšœ	�œ�œ
�œž˜@Jšœ�œž˜6Jš�œ
˜—š�œ�˜Jšœ�œ�œ
�œž
˜@Jšœ�œž
˜Jš�œ
˜—Jš�œ
˜—J˜J˜J˜J˜&—J˜Jš�œ�œ
�œ
˜*š
œ˜š�œ
�œ(˜7š�œ
�œ(˜7š�œ
�œ(˜7Jšœ
�œ˜ ————Jš�œ�œ
�œ
˜"J˜9Jšœž%˜3š�œ�	œ
�œ�˜&Jš�œ
�œ&˜6Jš�œ
˜—Jšœ+�œ
˜/J˜J˜—Jšœ�œ�œ˜Ešœ�œ�œ˜%Jšœ�œ˜Jšœ�œ˜%Jšœ�œ˜'Jšœ�œ˜(Jšœ"�œ˜,—Jšœ�œž˜8Jšœ�œž˜FJšœ�œ�œ�œ˜FJšœ�œ�œ�œ˜@J˜šŸœ�œ�œ˜1Jšœ�œ˜'Jšœ�œ˜)Jšœ�œ˜,J˜—Jšœ�œ�œ˜*J˜š
Ÿœ�œ
�œ�œ�œ˜7Jš�œ
�œ�œ
˜J˜J˜—š
Ÿœ�œ�œ�œ�œ˜FJš�œ�œ�œ
�œ
˜-J˜š�œ�œ
�œ�˜)Jšœ)�œ˜3—J˜—J˜BJ˜šŸœ�œ
�œG˜_Jš�œ˜Jš�œ�œ
�œ�œ�œ
�œ�œ�œ˜MJšœ	�œ)˜5Jšœ�œ'˜2J˜Jšœ�œ
˜Jšœ�œ
˜ Jšœ�œ	˜Jšœ�œ
˜J˜J˜š
Ÿœ�œ
�œ
�œ�œ˜3Jš�œ
�œ�œ
˜J˜(š�œ
ž˜š�œ�˜šœ
�œ�œ˜&J˜J˜$Jš�œ�œ˜—Jšœ�œ�œž˜8Jš�œ
˜—š�œ�˜Jš	œ�œ�œ
�œ�œ˜<Jšœ�œ�œ˜Jš�œ
˜—Jš�œ˜
J˜——šŸœ�œ
�œ˜ Jš�œ
�œ�œ
˜Jš�œ#�œ˜=J˜š�œ
ž*˜-š�œ�˜Jšœ
�œ�œ
�œž˜AJšœ�œž˜.Jš�œ
˜—š�œ�˜Jšœ�œ�œ
�œž
˜AJšœ�œž
˜Jš�œ
˜—Jš�œ
˜—J˜&J˜J˜J˜J˜—šŸ
œ�œ
�œ�œ˜'Jšœ�œ�œ�œ	˜7Jš�œ
˜J˜—Jš�œ�œ
�œ
˜#Jšœ�œ�œ˜DJš�œ�œ
�œ
˜#J˜9Jšœž%˜3š�œ˜	Jš
œ+˜+Jšœ�œ˜ š�œ;�œ˜CJ˜J˜HJ˜—Jš�œ˜—Jšœ+�œ˜1J˜—Jšœ�œ�œ˜Hšœ�œ�œ˜&Jšœ�œ
˜Jšœ�œ˜+Jšœ�œ˜)Jšœ�œ˜*Jšœ$�œ˜.J˜—Jšœ�œž˜9Jšœ�œž˜HJšœ�œ�œ�œ˜PJšœ�œ�œ�œ˜BJ˜šŸœ�œ�œ˜3Jšœ�œ˜-Jšœ�œ˜+Jšœ�œ˜.J˜—š
Ÿœ�œ
�œ�œ�œ˜8Jš�œ
�œ�œ
˜J˜J˜—š
Ÿœ�œ�œ�œ�œ˜HJš�œ�œ�œ
�œ
˜.J˜š�œ�œ
�œ�˜*Jšœ$�œ˜.—J˜—šŸœ�œ
�œ
�œ˜"Jš�œ
�œ�œ
˜Jšœ�œ˜J˜—šŸœ�œ�œ˜%J˜/J˜0J˜—Jš
œ
™
J˜Jšœ�œ˜J˜š
Ÿœ�œ�œ�œ�œ˜NJš
œ.™.Jšœ�œ"˜5Jšœ�œ
˜J˜J˜?Jš�œ�œ
�œ
˜J˜Jšœ�œ˜$Jšœ(�
˜)š�œ;�œ˜CJ˜HJ˜Jš
œ˜J˜——š
Ÿ
œ�œ
�œ�œ�œ˜@J˜Jšœ�œ˜7J˜J˜—Jš
œ™J˜šŸœ�œ
�œ�œ˜MJš
œ0™0J˜J˜J˜J˜
J˜J˜—Jš
œ™J˜šŸ
œ�œ�œ˜Jš
œ,™,Jšœ�œ˜J˜Lš�œ�	œ
�œ�˜&J˜Jšœ�œ
�œ�œ
�œ
�œ˜@Jš�œ˜	J˜——šŸ
œ�œ
�	œ˜Jš
�˜J˜ Jšœ�œ
˜J˜J˜J˜Jšœ�œ
˜Jšœ�œ
˜!Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜ J˜9J˜J˜J˜"J˜J˜J˜J˜J˜J˜J˜Jšœ�œ˜J˜J˜J˜Jš�œ
˜J˜—Jš�œ
˜J˜—…—EZ]Ô