DIRECTORY
Atom,
JaMBasic,
JaMOps,
JaMVM,
MessageWindow,
NameSymbolTable,
NodeProps,
NodeStyle,
NodeStyleExtra,
NodeStyleObject,
Process,
Rope,
TiogaNode;

NodeStyleExtraImpl: MONITOR
IMPORTS Atom, JaMOps, JaMVM, MessageWindow, NameSymbolTable, NodeProps, NodeStyle, NodeStyleExtra, Process, Rope
EXPORTS NodeStyle, NodeStyleExtra, NodeStyleObject =
BEGIN
OPEN NodeStyle, NodeStyleExtra;


FrameInfo: TYPE = REF FrameInfoBody;
FrameInfoBody: TYPE = RECORD [ frame: Frame, style: Ref, rest: FrameInfo ];
defaultStyleRope: Rope.Text;
defaultStyleName: PUBLIC Name;
defaultStylesForExtensions: PUBLIC LIST OF ExtObjPair;

SetDefaultStyle: PUBLIC SAFE PROC [name: Rope.ROPE] = TRUSTED {
defaultStyleRope _ Rope.Flatten[name];
defaultStyleName _ ForceLower[MakeName[
LOOPHOLE[defaultStyleRope, REF READONLY TEXT]]];
defaultStyle.name[style] _ defaultStyleName;
FlushCaches[] };

SetExtensionStyles: PUBLIC SAFE PROC [value: LIST OF Rope.ROPE] = TRUSTED {
ForceRopeLower: PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = TRUSTED {
ForceCharLower: SAFE PROC [old: CHAR] RETURNS [new: CHAR] = TRUSTED {
RETURN [Rope.Lower[old]] };
RETURN [Rope.Translate[base: r, translator: ForceCharLower]] };
defaultStylesForExtensions _ NIL;
UNTIL value=NIL OR value.rest=NIL DO
ext: ATOM _ Atom.MakeAtom[ForceRopeLower[value.first]]; -- the extension
styleObject: NameSymbolTable.Object _
NameSymbolTable.MakeObject[LOOPHOLE[Rope.Flatten[
Rope.Cat["\"", ForceRopeLower[value.rest.first], "\" style"]]]];
defaultStylesForExtensions _ CONS[[ext, styleObject], defaultStylesForExtensions];
value _ value.rest.rest;
ENDLOOP;
FlushCaches[] };

GetFrame: PUBLIC SAFE PROC [style: Ref, styleName: Name, kind: OfStyle]
RETURNS [frame: Frame] = TRUSTED {
found: BOOLEAN;
AllocFrame: ENTRY PROC [name: Name, kind: OfStyle] = { 
ENABLE UNWIND => NULL;
allocFrameCalls _ allocFrameCalls+1;
IF name # NameSymbolTable.nullName THEN {
IF name=styleName1 AND kind=styleKind1 AND freeFrame1 # NIL THEN
{ frame _ freeFrame1; freeFrame1 _ NIL; RETURN };
IF name=styleName2 AND kind=styleKind2 AND freeFrame2 # NIL THEN
{ frame _ freeFrame2; freeFrame2 _ NIL; RETURN };
IF name=styleName3 AND kind=styleKind3 AND freeFrame3 # NIL THEN
{ frame _ freeFrame3; freeFrame3 _ NIL; RETURN };
IF name=styleName4 AND kind=styleKind4 AND freeFrame4 # NIL THEN
{ frame _ freeFrame4; freeFrame4 _ NIL; RETURN }};
IF freeFrame1 # NIL THEN { frame _ freeFrame1; freeFrame1 _ NIL }
ELSE IF freeFrame2 # NIL THEN { frame _ freeFrame2; freeFrame2 _ NIL }
ELSE IF freeFrame3 # NIL THEN { frame _ freeFrame3; freeFrame3 _ NIL }
ELSE IF freeFrame4 # NIL THEN { frame _ freeFrame4; freeFrame4 _ NIL }
ELSE {
frame _ JaMOps.NewFrame[]; frameAlloc _ frameAlloc+1;
JaMOps.Begin[frame,sysdict];
JaMOps.Begin[frame,styledict] }};
SaveStyleInfo: ENTRY PROC = {
ENABLE UNWIND => NULL;
IF frame1 = NIL THEN { frame1 _ frame; style1 _ style }
ELSE IF frame2 = NIL THEN { frame2 _ frame; style2 _ style }
ELSE IF frame3 = NIL THEN { frame3 _ frame; style3 _ style }
ELSE IF frame4 = NIL THEN { frame4 _ frame; style4 _ style }
ELSE FOR lst: FrameInfo _ frameList, lst.rest UNTIL lst=NIL DO
IF lst.frame = NIL THEN { lst.frame _ frame; lst.style _ style; EXIT };
REPEAT FINISHED => frameList _ NEW[FrameInfoBody _ [frame,style,frameList]];
ENDLOOP };
AllocFrame[styleName,kind]; -- use styleName and kind as hint about which to allocate
IF styleName # NameSymbolTable.nullName THEN {
styleNameObj: Object;
done: BOOLEAN _ FALSE;
[found,styleNameObj] _ JaMOps.TryToLoad[frame,NameToObject[styleDictName]];
IF found THEN { -- some style dictionary on stack already
IF TypeCheckName[styleNameObj]=styleName THEN {	-- still must check kind of style
kindNameObj: Object;
[found,kindNameObj] _ JaMOps.TryToLoad[frame,NameToObject[styleKindName]];
IF found AND TypeCheckName[kindNameObj]=kindNames[kind] THEN
done _ TRUE }; -- already there
IF ~done THEN -- get rid of top dictionary
WHILE JaMOps.TopDict[frame.dictstk] # styledict DO
JaMOps.End[frame]; ENDLOOP };
IF ~done THEN JaMOps.Begin[frame,GetStyleDict[frame,styleName,kind]] }
ELSE WHILE JaMOps.TopDict[frame.dictstk] # styledict DO JaMOps.End[frame]; ENDLOOP;
SaveStyleInfo };


frame1, frame2, frame3, frame4: Frame _ NIL;
frameAlloc: INT _ 0; -- number of frames allocated from JaM
frameFree: INT _ 0; -- number of frames freed by JaM
allocFrameCalls: INT _ 0; -- number of times called AllocFrame
freeFrameCalls: INT _ 0; -- number of times called FreeFrame. should = allocFrameCalls
style1, style2, style3, style4: Ref;
frameList: FrameInfo;

debugStyle: Ref;

StyleForFrame: PUBLIC SAFE PROC [frame: Frame] RETURNS [style: Ref] = TRUSTED {
GetIt: ENTRY PROC RETURNS [s: Ref] = INLINE {
ENABLE UNWIND => NULL;
SELECT frame FROM
frame1 => RETURN [style1];
frame2 => RETURN [style2];
frame3 => RETURN [style3];
frame4 => RETURN [style4];
ENDCASE => FOR lst: FrameInfo _ frameList, lst.rest UNTIL lst=NIL DO
IF lst.frame=frame THEN RETURN [lst.style];
ENDLOOP };
IF (style _ GetIt[]) = NIL THEN { -- failed to find the frame
IF frame=JaMOps.defaultFrame THEN { -- so can look at style results from JaM typescript
IF debugStyle=NIL THEN debugStyle _ Create[];
RETURN [debugStyle] };
ERROR };
RETURN [style] };


freeFrame1, freeFrame2, freeFrame3, freeFrame4: Frame _ NIL;
styleName1, styleName2, styleName3, styleName4: Name _ NameSymbolTable.nullName;
styleKind1, styleKind2, styleKind3, styleKind4: OfStyle _ screen;

FreeFrame: PUBLIC ENTRY SAFE PROC [frame: Frame, name: Name, kind: OfStyle] = TRUSTED {
ENABLE UNWIND => NULL;
freeFrameCalls _ freeFrameCalls+1;
IF freeFrame1 = NIL THEN {
freeFrame1 _ frame; styleName1 _ name; styleKind1 _ kind }
ELSE IF freeFrame2 = NIL THEN {
freeFrame2 _ frame; styleName2 _ name; styleKind2 _ kind }
ELSE IF freeFrame3 = NIL THEN { 
freeFrame3 _ frame; styleName3 _ name; styleKind3 _ kind }
ELSE IF freeFrame4 = NIL THEN {
freeFrame4 _ frame; styleName4 _ name; styleKind4 _ kind }
ELSE { frameFree _ frameFree+1; JaMOps.FreeFrame[frame] }; -- really free it
SELECT frame FROM
frame1 => { frame1 _ NIL; style1 _ NIL };
frame2 => { frame2 _ NIL; style2 _ NIL };
frame3 => { frame3 _ NIL; style3 _ NIL };
frame4 => { frame4 _ NIL; style4 _ NIL };
ENDCASE => FOR lst: FrameInfo _ frameList, lst.rest UNTIL lst=NIL DO
IF lst.frame = frame THEN { lst.frame _ NIL; lst.style _ NIL; EXIT };
ENDLOOP;
};


ReadSpecsProc: SAFE PROC [
name: ATOM, specsRope: Rope.ROPE, start, len: INT, n: TiogaNode.Ref]
RETURNS [value: REF] = 
TRUSTED {
localStyle: LocalStyle _ NEW[LocalStyleRec];
localStyle.name _ NameSymbolTable.MakeNameFromRope[Atom.GetPName[Atom.Gensym['S]]];
localStyle.def _ Rope.Substr[specsRope, start, len];
[] _ DefineStyle[localStyle.name, localStyle.def];
RETURN [localStyle] };

WriteSpecsProc: SAFE PROC [
name: ATOM, value: REF, n: TiogaNode.Ref] RETURNS [specs: Rope.ROPE] = 
TRUSTED {
localStyle: LocalStyle _ NARROW[value];
RETURN [IF localStyle=NIL THEN NIL ELSE localStyle.def] };

CopyInfoProc: SAFE PROC [
name: ATOM, value: REF, from, to: TiogaNode.Ref] RETURNS [new: REF] = 
TRUSTED { RETURN [value] };


LoadStyle: PUBLIC SAFE PROC [name: Name] RETURNS [ok: BOOLEAN] = TRUSTED {
frame: Frame _ GetFrame[NIL,NameSymbolTable.nullName,screen];
[] _ GetStyleDict[frame,name,screen];
FreeFrame[frame,NameSymbolTable.nullName,screen];
RETURN [TRUE] };

DefineStyle: PUBLIC SAFE PROC [name: Name, def: Rope.ROPE] RETURNS [ok: BOOLEAN] = TRUSTED {
frame: Frame _ GetFrame[NIL,NameSymbolTable.nullName,screen];
IF def=NIL THEN BadStyleFile[frame,name]
ELSE [] _ GetStyleDict[frame,name,screen,def];
FreeFrame[frame,NameSymbolTable.nullName,screen];
RETURN [TRUE] };

ReloadStyle: PUBLIC SAFE PROC [name: Name] RETURNS [ok: BOOLEAN] = TRUSTED {
frame: Frame _ GetFrame[NIL,NameSymbolTable.nullName,screen];
name _ ForceLower[name];
ok _ RunStyle[frame,name];
IF ~ok THEN BadStyleFile[frame,name];
FreeFrame[frame,NameSymbolTable.nullName,screen ] };

GetStyleDict: PROC [frame: Frame, name: Name, kind: OfStyle, def: Rope.ROPE _ NIL]
RETURNS [d: dict Object] = {
found, ok: BOOL;
name _ ForceLower[name];
[d, found] _ CheckStyleDict[name,kind];
IF found THEN RETURN;
ok _ IF def # NIL THEN RunStyleString[frame,name,def] ELSE RunStyle[frame,name];
IF ok THEN [d,found] _ CheckStyleDict[name,kind];
IF ~found THEN {
BadStyleFile[frame,name];
[d, found] _ CheckStyleDict[name,kind] }};

BadStyleFile: PROC [frame: Frame, name: Name] = {
{ ENABLE BEGIN
WhatStyle => { styleName _ name; RESUME };
StartOfStyle => RESUME;
EndOfStyle => RESUME;
END;
BeginStyleOp[frame];
IF name # defaultStyleName THEN {
PushName[frame,defaultStyleName]; AttachStyleOp[frame] };
EndStyleOp[frame] };
Process.Detach[FORK BadStyleMessage[name]];
PushName[frame,name];
PushText[frame,"style was bad."];
StyleError[frame,2] };

BadStyleMessage: PROC [name: Name] = {
MessageWindow.Append[NameSymbolTable.RopeFromName[name],TRUE];
MessageWindow.Append[".style could not be loaded."] };

CreateStyleDict: PROC RETURNS [d: dict Object] = { -- creates dict for style
RETURN [JaMOps.Dict[50]] };

EnterStyleDict: PROC [name: Name, d: Object, kind: OfStyle] = INLINE {
JaMOps.Put[stylesDicts[kind],NameToObject[name],d] };

CheckStyleDict: PROC [name: Name, kind: OfStyle] RETURNS [d: dict Object, found: BOOLEAN] = {
obj: Object;
[found,obj] _ JaMOps.TryToGet[stylesDicts[kind],NameToObject[name]];
IF found THEN d _ TypeCheckDict[obj] };

RunStyle: PROC [frame: Frame, name: Name] RETURNS [ok: BOOLEAN] = {
txt: REF TEXT _ NEW[TEXT[64]];
ext: STRING = ".style";
txtlen: NAT;
hasExt, started, finished: BOOLEAN _ FALSE;
NameSymbolTable.FromName[name,txt];
txtlen _ txt.length;
FOR i:NAT IN [0..txtlen) DO -- see if has an extension already
IF txt[i] = '. THEN { hasExt _ TRUE; EXIT }; ENDLOOP;
FOR i:NAT IN [0..ext.length) DO txt[txtlen+i] _ ext[i]; ENDLOOP;
txt.length _ txtlen+ext.length;
PushText[frame,LOOPHOLE[txt,LONG STRING]];
JaMOps.Put[attachmentsDict, NameToObject[name], JaMOps.Array[0]];
JaMOps.Execute[frame, run ! 
WhatStyle => { styleName _ name; RESUME };
StartOfStyle => { started _ TRUE; RESUME };
EndOfStyle => { finished _ TRUE; RESUME };
];
RETURN [started AND finished] };

RunStyleString: PROC [frame: Frame, name: Name, def: Rope.ROPE]
RETURNS [ok: BOOLEAN] = {
started, finished: BOOLEAN _ FALSE;
JaMOps.Put[attachmentsDict, NameToObject[name], JaMOps.Array[0]];
JaMOps.Execute[frame,
CVX[JaMOps.MakeString[LOOPHOLE[Rope.Flatten[def],LONG STRING]]] ! 
WhatStyle => { styleName _ name; RESUME };
StartOfStyle => { started _ TRUE; RESUME };
EndOfStyle => { finished _ TRUE; RESUME };
];
RETURN [started AND finished] };



styleDictName: Name = MakeName["##styleDictName"];
styleKindName: Name = MakeName["##styleKindName"];

StartOfStyle: SIGNAL = CODE; -- raised to indicate start of loading style
EndOfStyle: SIGNAL = CODE; -- raised to indicate successful loading
WhatStyle: SIGNAL RETURNS [styleName: Name] = CODE; -- raised to find name of style being loaded

ForceLower: PROC [n: Name] RETURNS [Name] = { OPEN JaMBasic;
nameObj: Object = NameToObject[n];
name: name Object = WITH x:nameObj SELECT FROM name => x, ENDCASE => ERROR;
str: string Object = JaMOps.NameToString[name];
force: PROC [c: CHAR] RETURNS [stop: BOOLEAN] = {
string[i] _ IF c IN ['A..'Z] THEN c-'A+'a ELSE c;
i _ i+1;
RETURN [FALSE] };
string: STRING _ [100];
i: CARDINAL _ 0;
JaMOps.StringForAll[str, force];
string.length _ i;
RETURN [TypeCheckName[JaMOps.MakeName[string,name.tag]]] };

BeginStyleOp: PROC [frame: Frame] = {
name: Name _ ForceLower[SIGNAL WhatStyle]; -- get style name from RunStyle
screenDict, printDict, baseDict: dict Object;
ResetDict: PROC [dict: dict Object] = { JaMOps.ClrDict[dict]; JaMOps.DetachAll[dict] };
MakeDict: PROC [kind: OfStyle] RETURNS [dict: dict Object] = {
dict _ CreateStyleDict[]; EnterStyleDict[name,dict,kind] };
InitDict: PROC [dict: dict Object, kind: OfStyle] = {
JaMOps.Put[baseDict,NameToObject[styleRuleDictNames[kind]],JaMOps.Dict[50]];
JaMOps.Put[dict,NameToObject[styleKindName],NameToObject[kindNames[kind]]];
};
found: BOOLEAN;
[baseDict,found] _ CheckStyleDict[name,base]; -- check if reloading
IF found THEN {
ResetDict[baseDict];
[printDict,] _ CheckStyleDict[name,print];
ResetDict[printDict];
[screenDict,] _ CheckStyleDict[name,screen];
ResetDict[screenDict];
FlushCaches[] }
ELSE {
baseDict _ MakeDict[base];
screenDict _ MakeDict[screen];
printDict _ MakeDict[print] };
InitDict[baseDict,base]; InitDict[screenDict,screen]; InitDict[printDict,print];

JaMOps.AttachDict[screenDict,baseDict];
JaMOps.AttachDict[printDict,baseDict];

JaMOps.Put[baseDict,NameToObject[styleDictNames[screen]],screenDict];
JaMOps.Put[baseDict,NameToObject[styleDictNames[print]],printDict];
JaMOps.Put[baseDict,NameToObject[styleDictNames[base]],baseDict];

JaMOps.Put[baseDict,NameToObject[styleDictName],NameToObject[name]];

JaMOps.Begin[frame,baseDict];
PushObject[frame,baseDict]; -- leave this around for EndStyleOp
SIGNAL StartOfStyle --caught by RunStyle-- };

StyleName: PROC [frame: Frame] = { -- expects style dictionary on op stack
PushObject[frame,JaMOps.Load[frame,NameToObject[styleDictName]]] };

EndStyleOp: PROC [frame: Frame] = {
d1, d2: dict Object;
d1 _ JaMOps.TopDict[frame.dictstk]; -- the current dictionary
d2 _ JaMOps.PopDict[frame.opstk]; -- pushed by StyleOp
IF d1 # d2 THEN {
PushText[frame,"mismatched Style and EndStyle commands"];
StyleError[frame,1] }
ELSE { -- change attachments so look in own basicDict before any attached dicts
name: Name _ SIGNAL WhatStyle;
screenDict: dict Object = CheckStyleDict[name,screen].d;
printDict: dict Object = CheckStyleDict[name,print].d;
JaMOps.DetachDict[screenDict,d1];
JaMOps.DetachDict[printDict,d1];
JaMOps.AttachDict[screenDict,d1];
JaMOps.AttachDict[printDict,d1];
JaMOps.End[frame] };
SIGNAL EndOfStyle --caught by RunStyle-- };

styleRuleDictNames: REF ARRAY OfStyle OF Name = NEW[ARRAY OfStyle OF Name];
styleDictNames: REF ARRAY OfStyle OF Name = NEW[ARRAY OfStyle OF Name];

StyleRuleOp: PROC [frame: Frame] = { DefineStyleRule[frame,base] };

PrintRuleOp: PROC [frame: Frame] = { DefineStyleRule[frame,print] };

ScreenRuleOp: PROC [frame: Frame] = { DefineStyleRule[frame,screen] };

DefineStyleRule: PROC [frame: Frame, kind: OfStyle] = { -- expects <name> <comment> <definition> on op stack
definition: Object _ PopObject[frame];
comment: Object _ PopObject[frame];
STKname: Name _ PopName[frame];
name: Name _ ForceLower[STKname];
nameObj: Object _ NameToObject[name];
dict: dict Object _ LoadStyleDict[frame,kind];
WITH x:definition SELECT FROM
array => JaMOps.ABind[x,bindingDict];
ENDCASE; -- def may be a string
JaMOps.Put[dict,nameObj,CVX[definition]]; -- save the definition
IF name#STKname THEN JaMOps.Put[dict,NameToObject[STKname],CVX[definition]];
JaMOps.Put[LoadStyleRuleDict[frame,kind],nameObj,comment]; -- save the comment in the rule name dict
};

LoadStyleDict: PROC [frame: Frame, kind: OfStyle] RETURNS [dict Object] = {
RETURN [TypeCheckDict[JaMOps.Load[frame,NameToObject[styleDictNames[kind]]]]] };

LoadStyleRuleDict: PROC [frame: Frame, kind: OfStyle] RETURNS [dict Object] = {
RETURN [TypeCheckDict[JaMOps.Load[frame,NameToObject[styleRuleDictNames[kind]]]]] };

OpenStyle: PROC [frame: Frame, kind: OfStyle] = {
name: Name _ PopName[frame];
IF ~LoadStyle[name] THEN RETURN;
WHILE JaMOps.TopDict[frame.dictstk] # sysdict DO JaMOps.End[frame]; ENDLOOP;
JaMOps.Begin[frame,styledict];
JaMOps.Begin[frame,GetStyleDict[frame,name,kind]] };

OpenPrintStyleOp: PROC [frame: Frame] = { -- expects style name on op stack
OpenStyle[frame, print] };

OpenScreenStyleOp: PROC [frame: Frame] = { -- expects style name on op stack
OpenStyle[frame, screen] };

ResetTestStyle: PROC [frame: Frame] = { 
IF debugStyle=NIL THEN debugStyle _ Create[];
debugStyle^ _ defaultStyle^ };

StyleRuleDict: PROC [frame: Frame] = { GetRuleDict[frame,base] };

PrintRuleDict: PROC [frame: Frame] = { GetRuleDict[frame,print] };

ScreenRuleDict: PROC [frame: Frame] = { GetRuleDict[frame,screen] };

GetRuleDict: PROC [frame: Frame, kind: OfStyle] = {
PushName[frame,styleRuleDictNames[kind]];
JaMOps.Execute[frame,get] };

ForEachAttachedStyle: PUBLIC SAFE PROC [
dictName: Name, proc: PROC [attached: Name] RETURNS [stop: BOOLEAN]] = TRUSTED {
val: Object;
array: array Object;
found: BOOLEAN;
dictName _ ForceLower[dictName];
[found,val] _ JaMOps.TryToGet[attachmentsDict, NameToObject[dictName]];
IF ~found THEN RETURN;
WITH val:val SELECT FROM
array => array _ val;
ENDCASE => ERROR;
FOR i: CARDINAL IN [0..array.length) DO
ob: Object _ JaMVM.GetElem[array,i];
IF proc[TypeCheckName[ob]] THEN RETURN;
ENDLOOP;
};

AttachStyleOp: PROC [frame: Frame] = { -- expects opstk to contain style name
name: Name _ ForceLower[PopName[frame]];
found: BOOLEAN;
printDict, screenDict: dict Object;
array: array Object;
styleName: Name _ SIGNAL WhatStyle;
val: Object;
[printDict,found] _ CheckStyleDict[name,print];
IF ~found THEN {
IF RunStyle[frame,name] THEN [printDict,found] _ CheckStyleDict[name,print];
IF ~found THEN {
BadStyleFile[frame,name];
RETURN }};
[screenDict,found] _ CheckStyleDict[name,screen];
IF ~found THEN ERROR;
JaMOps.AttachDict[LoadStyleDict[frame,screen],screenDict];
JaMOps.AttachDict[LoadStyleDict[frame,print],printDict];
[found,val] _ JaMOps.TryToGet[attachmentsDict, NameToObject[styleName]];
IF ~found THEN array _ JaMOps.Array[1] -- this is the first attachment
ELSE { -- add new item to the array
WITH val:val SELECT FROM
array => array _ val;
ENDCASE => ERROR;
array _ JaMOps.ACopy[array,1] };
JaMOps.APut[array,array.length-1,NameToObject[name]];
JaMOps.Put[attachmentsDict, NameToObject[styleName], array];
};

ClearTabStopsOp: PROC [frame: Frame] = {
ref: Ref _ StyleForFrame[frame];
ref.tabStops _ NIL; ref.numTabStops _ 0 };


PushText: PUBLIC SAFE PROC [frame: Frame, txt: LONG STRING] = TRUSTED {
JaMOps.Push[frame.opstk,JaMOps.MakeString[txt]] };

PushObject: PUBLIC SAFE PROC [frame: Frame, ob: Object] = TRUSTED {
JaMOps.Push[frame.opstk,ob] };

PopObject: PUBLIC SAFE PROC [frame: Frame] RETURNS [Object] = TRUSTED {
RETURN[JaMOps.Pop[frame.opstk]] };

PushName: PUBLIC SAFE PROC [frame: Frame, name: Name] = TRUSTED {
JaMOps.Push[frame.opstk,NameToObject[name]] };

PopName: PUBLIC SAFE PROC [frame: Frame] RETURNS [Name] = TRUSTED {
obj: Object _ JaMOps.Pop[frame.opstk];
WITH x:obj SELECT FROM
name => RETURN [LOOPHOLE[x.id]];
string => {
nameObj: name Object _ JaMOps.StringToName[x];
RETURN [LOOPHOLE[nameObj.id]] };
ENDCASE => {
PushText[frame," -- found where expected a name"];
PushObject[frame,obj];
StyleError[frame,2] };
ERROR };

TryToPopReal: PUBLIC SAFE PROC [frame: Frame] RETURNS [value: Real, ok: BOOLEAN] = TRUSTED {
obj: Object;
IF frame.opstk.head = NIL THEN RETURN [0.0, FALSE];
obj _ JaMOps.Top[frame.opstk];
WITH x:obj SELECT FROM
integer => { [] _ PopObject[frame]; RETURN [x.ivalue, TRUE] };
real => { [] _ PopObject[frame]; RETURN [x.rvalue, TRUE] };
ENDCASE => RETURN [0.0, FALSE] };

TryToPopString: PUBLIC SAFE PROC [frame: Frame]
RETURNS [string: string JaMBasic.Object, ok: BOOLEAN] = TRUSTED {
obj: Object;
IF frame.opstk.head = NIL THEN { ok _ FALSE; RETURN };
obj _ JaMOps.Top[frame.opstk];
WITH x:obj SELECT FROM
name => { [] _ PopObject[frame]; RETURN [JaMOps.NameToString[x], TRUE] };
string => { [] _ PopObject[frame]; RETURN [x, TRUE] };
ENDCASE => ok _ FALSE };

TryToPopName: PUBLIC SAFE PROC [frame: Frame] RETURNS [name: Name, ok: BOOLEAN] = TRUSTED {
obj: Object;
IF frame.opstk.head = NIL THEN RETURN [NameSymbolTable.nullName,FALSE];
obj _ JaMOps.Top[frame.opstk];
WITH x:obj SELECT FROM
name => { [] _ PopObject[frame]; RETURN [LOOPHOLE[x.id],TRUE] };
string => {
nameObj: name Object _ JaMOps.StringToName[x];
[] _ PopObject[frame];
RETURN [LOOPHOLE[nameObj.id],TRUE] };
ENDCASE => RETURN [NameSymbolTable.nullName,FALSE] };

TypeCheckName: PUBLIC SAFE PROC [obj: Object] RETURNS [Name] = TRUSTED {
WITH x:obj SELECT FROM
name => RETURN [LOOPHOLE[x.id]];
string => {
nameObj: name Object _ JaMOps.StringToName[x];
RETURN [LOOPHOLE[nameObj.id]] };
ENDCASE;
ERROR };

TypeCheckDict: PUBLIC SAFE PROC [obj: Object] RETURNS [dict Object] = TRUSTED {
WITH x:obj SELECT FROM
dict => RETURN [x];
ENDCASE;
ERROR };

TypeCheckCommand: PUBLIC SAFE PROC [obj: Object] RETURNS [command Object] = TRUSTED {
WITH x:obj SELECT FROM
command => RETURN [x];
ENDCASE;
ERROR };


StyleCommand: PUBLIC SAFE PROC [frame: Frame, text: REF READONLY TEXT, proc: PROC [Frame]] 
RETURNS [name: Name]= TRUSTED {
name _ MakeName[text];
JaMOps.RegisterExplicit[frame,LOOPHOLE[text,LONG STRING],proc];
JaMOps.Put[bindingDict,NameToObject[name],
CVX[JaMOps.Load[frame,NameToObject[name]]]] };

StyleLiteral: PUBLIC SAFE PROC [frame: Frame, text: REF READONLY TEXT]
RETURNS [name: Name] = TRUSTED {
name _ MakeName[text];
JaMOps.Put[bindingDict,NameToObject[name],CVLit[NameToObject[name]]];
JaMOps.Def[frame,NameToObject[name],CVLit[NameToObject[name]]] };

InitDict: PROC [txt: REF READONLY TEXT, size: CARDINAL _ 100]
RETURNS [name: Name, dictionary: dict Object] = {
found: BOOLEAN;
d: Object;
name _ MakeName[txt];
[found,d] _ JaMOps.TryToGet[sysdict,NameToObject[name]];
IF found THEN dictionary _ TypeCheckDict[d]
ELSE {	dictionary _ JaMOps.Dict[size];
JaMOps.Put[sysdict,NameToObject[name],dictionary] }};

bindingDictName, attachmentsDictName, styledictName: Name;

bindingDict, attachmentsDict: dict Object;

stylesDictsNames: REF ARRAY OfStyle OF Name _ NEW[ARRAY OfStyle OF Name];
stylesDictNames: REF ARRAY OfStyle OF Name _ NEW[ARRAY OfStyle OF Name];

stylesDicts: REF ARRAY OfStyle OF dict Object _ NEW[ARRAY OfStyle OF dict Object];

InitStylesDict: PROC = {
[stylesDictsNames[base], stylesDicts[base]] _ InitDict["TiogaBaseStylesDictionary"];
[stylesDictsNames[print], stylesDicts[print]] _ InitDict["TiogaPrintStylesDictionary"];
[stylesDictsNames[screen], stylesDicts[screen]] _ InitDict["TiogaScreenStylesDictionary"] };

InitBindingDict: PROC = {
[bindingDictName, bindingDict] _ InitDict["TiogaBindingDictionary",200] };

InitAttachmentsDict: PROC = {
[attachmentsDictName, attachmentsDict] _ InitDict["TiogaAttachedStylesDictionary"] };

InitStyleDict: PROC = {
[styledictName, styledict] _ InitDict["TiogaStylesDictionary"];
JaMOps.AttachDict[styledict,userdict];
};

RegCom: PROC [frame: Frame, txt: REF READONLY TEXT, proc: PROC[Frame]]
RETURNS [c: command Object] = {
JaMOps.RegisterExplicit[frame,LOOPHOLE[txt,LONG STRING],proc];
c _ GetCommand[frame,MakeName[txt]] };

sysdict, userdict, styledict: PUBLIC dict Object;

styleerror: PUBLIC Name;

GetCommand: PUBLIC SAFE PROC [frame: Frame, name: Name]
RETURNS [command Object] = TRUSTED {
flag: BOOLEAN;
obj: Object;
[flag,obj] _ JaMOps.TryToLoad[frame,NameToObject[name]];
IF ~flag THEN ERROR;
RETURN [TypeCheckCommand[obj]] };

GetObject: PROC [frame: Frame, name: Name] RETURNS [ob: Object] = {
RETURN [JaMOps.Load[frame,NameToObject[name]]] };

ReportStyleError: PROC [frame: Frame] = {
num: CARDINAL _ JaMOps.PopCardinal[frame.opstk];
string: string JaMBasic.Object;
ok: BOOLEAN;
MessageWindow.Clear[];
IF executingName # NameSymbolTable.nullName THEN {
PushText[frame,"style rule. "];
PushName[frame,executingName];
PushText[frame,"Error in"];
num _ num+3 };
UNTIL num=0 DO
GetChar: SAFE PROC RETURNS [c: CHAR] = TRUSTED
{ c _ JaMVM.GetChar[string, i];  i _ i+1 };
i: CARDINAL;
[string, ok] _ TryToPopString[frame];
IF ~ok THEN EXIT;
i _ 0;
MessageWindow.Append[Rope.FromProc[string.length, GetChar]];
num _ num-1;
IF num # 0 THEN MessageWindow.Append[" "];
ENDLOOP;
};

RunFile: PROC [frame: Frame, name: Name, dictname: LONG STRING]
RETURNS [BOOLEAN] = {
known: BOOLEAN;
[known,] _ JaMOps.TryToLoad[frame,NameToObject[name]];
IF known THEN RETURN [FALSE];
PushText[frame,dictname];
JaMOps.Execute[frame,run];
RETURN [TRUE] };

load, get, run: PUBLIC command Object;

kindNames: REF ARRAY OfStyle OF Name _ NEW[ARRAY OfStyle OF Name];

started: BOOLEAN _ FALSE;

StartExtra: PUBLIC SAFE PROCEDURE =
TRUSTED BEGIN
frame, frame1, frame2, frame3, frame4: Frame _ NIL;
topDictName: Name;

IF started THEN RETURN; started _ TRUE;

frame _ JaMOps.defaultFrame;

get _ GetCommand[frame,MakeName[".get"]];
run _ GetCommand[frame,MakeName[".run"]];
load _ GetCommand[frame,MakeName[".load"]];

sysdict _ TypeCheckDict[GetObject[frame,MakeName[".sysdict"]]];

IF ~RunFile[frame,MakeName["user"],"start.jam"] THEN
JaMOps.Execute[frame,CVX[NameToObject[MakeName[".start"]]]];

userdict _ JaMOps.TopDict[frame.dictstk];
InitStyleDict[];
JaMOps.End[frame]; -- replace userdict by styledict for rest of startup
JaMOps.Begin[frame,styledict];

topDictName _ MakeName["topDictName"];
JaMOps.Put[sysdict,NameToObject[topDictName],NameToObject[MakeName[".sysdict"]]];
JaMOps.Put[userdict,NameToObject[topDictName],NameToObject[MakeName["userdict"]]];
JaMOps.Put[styledict,NameToObject[topDictName],
NameToObject[MakeName["TiogaStylesDictionary"]]];

styleerror _ MakeName["StyleError"];

kindNames[screen] _ MakeName["screen"];
kindNames[print] _ MakeName["print"];
kindNames[base] _ MakeName["base"];

styleRuleDictNames[base] _ MakeName["##BaseStyleRuleDictName"];
styleRuleDictNames[screen] _ MakeName["##ScreenStyleRuleDictName"];
styleRuleDictNames[print] _ MakeName["##PrintStyleRuleDictName"];

styleDictNames[base] _ MakeName["##BaseStyleDictName"];
styleDictNames[screen] _ MakeName["##ScreenStyleDictName"];
styleDictNames[print] _ MakeName["##PrintStyleDictName"];

InitStylesDict[]; InitBindingDict[]; InitAttachmentsDict[];

[] _ RunFile[frame,styleerror,"TiogaUtils.jam"];

[] _ RegCom[frame,"ReportStyleError",ReportStyleError];
[] _ RegCom[frame,"StyleName",StyleName];
[] _ RegCom[frame,"StyleRuleDict",StyleRuleDict];
[] _ RegCom[frame,"PrintRuleDict",PrintRuleDict];
[] _ RegCom[frame,"ScreenRuleDict",ScreenRuleDict];
[] _ RegCom[frame,"OpenPrintStyle",OpenPrintStyleOp];
[] _ RegCom[frame,"OpenScreenStyle",OpenScreenStyleOp];
[] _ RegCom[frame,"ResetTestStyle",ResetTestStyle];

[] _ StyleCommand[frame,"BeginStyle",BeginStyleOp];
[] _ StyleCommand[frame,"EndStyle",EndStyleOp];
[] _ StyleCommand[frame,"StyleRule",StyleRuleOp];
[] _ StyleCommand[frame,"PrintRule",PrintRuleOp];
[] _ StyleCommand[frame,"ScreenRule",ScreenRuleOp];
[] _ StyleCommand[frame,"AttachStyle",AttachStyleOp];

[] _ StyleCommand[frame,"clearTabStops",ClearTabStopsOp];
[] _ StyleCommand[frame,"tabStop",TabStopOp];
[] _ StyleCommand[frame,"defaultTabStops",DefaultTabStopsOp];
[] _ StyleCommand[frame,"tabStopLocations",RelativeTabStopsOp];

frame1 _ GetFrame[NIL, NameSymbolTable.nullName, screen];
frame2 _ GetFrame[NIL, NameSymbolTable.nullName, screen];
frame3 _ GetFrame[NIL, NameSymbolTable.nullName, screen];
frame4 _ GetFrame[NIL, NameSymbolTable.nullName, screen];
FreeFrame[frame1, NameSymbolTable.nullName, screen];
FreeFrame[frame2, NameSymbolTable.nullName, screen];
FreeFrame[frame3, NameSymbolTable.nullName, screen];
FreeFrame[frame4, NameSymbolTable.nullName, screen];

NodeProps.Register[name: $StyleDef,
reader: ReadSpecsProc,
writer: WriteSpecsProc,
copier: CopyInfoProc];

END;

StartExtra;

END.



¼NodeStyleExtraImpl.mesa
Written by Bill Paxton, January 1981
Last changed by Paxton, August 30, 1983 10:05 am
Styles, StyleNames, and Frames
style is the StyleRef you will be using with the frame
styleName tells which style dictionary you want
will give you default style if requested one bombs during load
first try to find one that already has the right style 
look for any free one
get the proper style dictionary on the frame dictionary stack
info about active frames
info about free frames
name and kind are just a hint about what style dictionary is on the frame stack
add it to cache of free frames or really free it if cache full
remove it from active frame info
Local styles
Load style procedures
fake it so looks as if had a file saying BeginStyle (default) AttachStyle EndStyle
need to fork this so to avoid monitor deadlock in viewers
Registered commands
create rule name dict in baseDict
record the style kind
support procs
Initialization
add it to the binding dictionary
add it to the binding dictionary
add it to the current dictionary
check if have done (start.jam) .run
check if have done (TiogaUtils.jam) .run
style commands for tabs
allocate and free some frames to initialize the cache
�Êû˜Jš
œ™Jš
œ$™$Jš
œ0™0J˜š
Ïk	˜	J˜J˜	J˜J˜J˜J˜J˜
J˜
J˜J˜J˜J˜J˜
J˜—šœ�˜Jš�œi˜pJš�œ-˜4—Jš
�˜Jš�œ˜J˜š
œ™J˜Jšœ�œ�œ˜$Jšœ�œ�œ/˜KJ˜Jšœ�œ˜Jšœ�œ
�œ
�œ˜6J˜šÏnœ�œ
�œ
�œ
�œ�œ˜?Jš
œ&˜&š
œ'˜'Jš�œ�œ
�œ
�œ˜0—J˜,Jš
œ˜J˜—šžœ�œ
�œ
�œ	�œ
�œ�œ�œ˜Kšžœ�œ
�œ�œ�œ�œ˜Cšžœ�œ
�œ�œ�œ�œ�œ˜EJš�œ˜—Jš�œ9˜?—Jšœ�œ
˜!š	�œ�œ
�œ�œ
�˜$Jšœ�œ?˜Hš
œ%˜%šœ�œ˜1Jš
œ@˜@——Jšœ�œ1˜RJ˜Jš
�˜—Jš
œ˜J˜—šžœ�œ-˜GJš�œ�œ˜"Jš
œ6™6Jš
œ/™/Jš
œ>™>Jšœ�œ
˜šž
œ�œ
�œ!˜7Jš�œ
�œ�œ
˜J˜$š�œ!�œ˜)Jš
œ7™7š	�œ�œ�œ�œ
�˜@Jšœ#�œ�œ˜1—š	�œ�œ�œ�œ
�˜@Jšœ#�œ�œ˜1—š	�œ�œ�œ�œ
�˜@Jšœ#�œ�œ˜1—š	�œ�œ�œ�œ
�˜@Jšœ#�œ�œ˜2——Jš
œ™Jš�œ�œ
�œ$�œ˜AJš
�œ
�œ�œ
�œ$�œ˜FJš
�œ
�œ�œ
�œ$�œ˜FJš
�œ
�œ�œ
�œ$�œ˜Fš�œ˜J˜5J˜J˜!——šž
œ�œ
�œ˜Jš�œ
�œ�œ
˜Jš�œ
�œ
�œ#˜7Jš�œ
�œ
�œ
�œ#˜<Jš�œ
�œ
�œ
�œ#˜<Jš�œ
�œ
�œ
�œ#˜<š	�œ
�œ&�œ�œ
�˜>Jš�œ
�œ
�œ)�œ˜GJš�œ
�œ�œ*˜LJš�œ˜
——JšœÏc9˜Uš�œ&�œ˜.Jš
œ=™=J˜Jšœ�œ�œ
˜J˜Kš�œ�œŸ)˜9š�œ'�œŸ!˜QJ˜J˜Jš�œ�œ,�˜<Jšœ�œŸ˜——š�œ�œ
Ÿ˜*š�œ+�˜2Jšœ�œ˜———Jš�œ�œ9˜F—Jš�œ
�œ+�œ�œ
˜SJ˜—J˜—š
œ™J˜Jšœ(�œ
˜,Jšœ�œŸ&˜;Jšœ�œŸ ˜4Jšœ�œŸ$˜>Jšœ�œŸ=˜VJ˜$J˜J˜J˜J˜šž
œ�œ
�œ
�œ�œ�œ˜Oš
žœ�œ
�œ
�œ�œ˜-Jš�œ
�œ�œ
˜š�œ�˜Jšœ
�œ
˜Jšœ
�œ
˜Jšœ
�œ
˜Jšœ
�œ
˜š	�œ�œ&�œ�œ
�˜DJš�œ�œ
�œ
˜+Jš�œ˜
———š�œ�œ
�œŸ˜=š�œ�œŸ3˜WJš�œ�œ
�œ˜-Jš�œ˜—Jš�œ˜—Jš�œ˜—J˜—š
œ™J˜Jšœ8�œ
˜<J˜PJ˜AJ˜šž	œ�œ
�œ-�œ˜WJš
œO™OJš�œ
�œ�œ
˜J˜"Jš
œ>™>š�œ�œ
�œ˜J˜:—š�œ
�œ�œ
�œ˜J˜:—š�œ
�œ�œ
�œ˜ J˜:—š�œ
�œ�œ
�œ˜J˜:—Jš�œ7Ÿ˜LJš
œ ™ š�œ�˜Jšœ�œ�œ˜)Jšœ�œ�œ˜)Jšœ�œ�œ˜)Jšœ�œ�œ˜)š	�œ�œ&�œ�œ
�˜DJš
�œ�œ�œ�œ�œ˜EJš�œ
˜——J˜—J˜—š
œ™J˜šž
œ�œ
�œ˜Jšœ�œ�œ�œ˜DJš�œ	�œ˜Jš�œ˜	Jšœ�œ˜,Jš
œS˜SJš
œ4˜4Jš
œ2˜2Jš�œ˜—J˜šžœ�	œ˜Jš	œ�œ	�œ�œ�œ˜GJš�œ˜	Jšœ�œ˜'Jš�œ�œ�œ
�œ
�œ
�œ˜:—J˜šžœ�	œ˜Jš	œ�œ	�œ�œ�œ˜FJš�œ�œ˜—J˜—š
œ™J˜šž	œ�œ
�œ
�œ�œ�œ�œ˜JJšœ�œ"˜=J˜%J˜1Jš�œ�œ˜J˜—šžœ�œ
�œ
�œ�œ�œ�œ�œ˜\Jšœ�œ"˜=Jš�œ�œ
�œ˜(Jš�œ*˜.J˜1Jš�œ�œ˜J˜—šžœ�œ
�œ
�œ�œ�œ�œ˜LJšœ�œ"˜=J˜J˜Jš�œ�œ˜%J˜4J˜—šžœ�œ5�œ�œ
˜RJš�œ˜Jšœ�œ
˜J˜J˜'Jš�œ�œ
�œ
˜Jš	œ�œ�œ
�œ �œ˜PJš�œ�œ'˜1š�œ�œ˜J˜J˜*J˜——šžœ�œ˜1Jš
œR™Ršœ�œ
�˜Jšœ!�œ˜*Jšœ�œ
˜Jšœ�œ
˜Jš�œ
˜—J˜š�œ�œ˜!J˜9—J˜Jšœ�œ˜+J˜J˜!J˜J˜—šžœ�œ˜&Jš
œ9™9Jšœ8�œ˜>J˜6J˜—šžœ�œ
�œŸ˜LJš�œ˜J˜—šžœ�œ*�œ˜FJ˜5J˜—šžœ�œ�œ�œ˜]J˜J˜DJš�œ�œ˜'J˜—šžœ�œ�œ�œ˜CJš	œ�œ
�œ�œ
�œ˜Jšœ�œ˜Jšœ�œ
˜Jšœ�œ�œ
˜+J˜#J˜š	�œ�œ
�œ
�œ
Ÿ"˜>Jš
�œ
�œ�œ�œ�œ
˜5—Jš
�œ�œ
�œ�œ�œ
˜@J˜Jšœ�œ�œ
�œ˜*J˜A˜Jšœ!�œ˜*Jšœ�œ�œ˜+Jšœ�œ�œ˜*Jš
œ˜—Jš�œ
�œ
˜ J˜—šžœ�œ&�œ
˜?Jš�œ�œ˜Jšœ�œ�œ
˜#J˜Aš
œ˜Jš�œ�œ�œ
�œ˜BJšœ!�œ˜*Jšœ�œ�œ˜+Jšœ�œ�œ˜*Jš
œ˜—Jš�œ
�œ
˜ J˜J˜——š
œ™J˜J˜2J˜2J˜Jšœ�œ�œŸ,˜IJšœ�œ�œŸ(˜CJšœ�œ
�œ�œŸ,˜`J˜šž
œ�œ�œ�œ
˜<J˜"Jšœ�œ�œ
�œ�œ�œ
˜KJ˜/š	œ�œ�œ�œ�œ˜1Jš	œ�œ�œ
�œ	�œ˜1J˜Jš�œ�œ˜—Jšœ�œ	˜Jšœ�œ˜J˜ J˜Jš�œ5˜;J˜—šžœ�œ˜%Jšœ�œ
Ÿ˜JJ˜-Jšž	œ�œH˜Wšžœ�œ�œ˜>J˜;—šžœ�œ'˜5J˜LJš
œ!™!J˜KJš
œ™J˜—Jšœ�œ
˜Jšœ.Ÿ˜Cš�œ�œ˜J˜J˜*J˜J˜,J˜J˜—š�œ˜J˜J˜J˜—J˜PJ˜J˜'J˜&J˜J˜EJ˜CJ˜AJ˜J˜DJ˜J˜JšœŸ#˜?Jš�œŸœ˜-J˜—šž	œ�œŸ'˜JJ˜CJ˜—šž
œ�œ˜#J˜Jšœ$Ÿ˜=Jšœ"Ÿ˜6š�œ	�œ˜J˜9J˜—š�œŸH˜OJšœ
�œ˜J˜8J˜6J˜!J˜ J˜!J˜ J˜—Jš�œŸœ˜+J˜—Jš
œ�œ
�œ	�œ�œ
�œ	�œ˜KJš
œ�œ
�œ	�œ�œ
�œ	�œ˜GJ˜Jšžœ�œ2˜CJ˜Jšžœ�œ3˜DJ˜Jšžœ�œ4˜FJ˜šžœ�œ#Ÿ4˜lJ˜&J˜#J˜J˜!Jš
œ%˜%J˜.š�œ�œ
�˜J˜%Jš�œŸ˜—Jšœ�œŸ˜@Jš�œ�œ'�œ˜LJšœ;Ÿ)˜dJ˜J˜—šž
œ�œ�œ˜KJš�œJ˜PJ˜—šžœ�œ�œ˜OJš�œN˜TJ˜—šž	œ�œ"˜1J˜Jš�œ�œ
�œ
˜ Jš�œ)�œ�œ
˜LJ˜J˜4J˜—šžœ�œŸ!˜KJ˜J˜—šžœ�œŸ!˜LJ˜J˜—šžœ�œ˜(Jš�œ�œ
�œ˜-J˜J˜—Jšž
œ�œ.˜AJ˜Jšž
œ�œ/˜BJ˜Jšžœ�œ0˜DJ˜šžœ�œ"˜3J˜)J˜J˜—šžœ�œ˜(Jš	œ�œ�œ�œ�œ˜PJ˜J˜Jšœ�œ
˜J˜ J˜GJš�œ�œ
�œ
˜š�œ	�œ
�˜J˜Jš�œ�œ
˜—š�œ�œ
�œ�˜'J˜$Jš�œ�œ
�œ
˜'Jš�œ
˜—J˜J˜—šž
œ�œŸ&˜MJ˜(Jšœ�œ
˜J˜#J˜Jšœ�œ˜#J˜J˜/š�œ�œ˜Jš�œ�œ0˜Lš�œ�œ˜J˜Jš�œ˜
——J˜1Jš�œ�œ
�œ
˜J˜:J˜8J˜HJš�œ�œŸ˜Fš�œŸ˜#š�œ	�œ
�˜J˜Jš�œ�œ
˜—J˜ —J˜5J˜<J˜—J˜šžœ�œ˜(Jš
œ ˜ Jšœ�œ˜*J˜——š
œ
™
J˜šžœ�œ
�œ
�œ�œ
�œ�œ˜GJ˜2J˜—š
ž
œ�œ
�œ
�œ�œ˜CJ˜J˜—šž	œ�œ
�œ
�œ�œ�œ˜GJš�œ˜"J˜—š
žœ�œ
�œ
�œ�œ˜AJ˜.J˜—šžœ�œ
�œ
�œ�œ
�œ˜CJ˜&š�œ�œ
�˜Jšœ�œ�œ˜ ˜J˜.Jš�œ�œ˜ —š�œ˜J˜2J˜J˜——Jš�œ˜J˜—šžœ�œ
�œ
�œ�œ�œ�œ˜\J˜Jš
�œ�œ
�œ
�œ�œ˜3J˜š�œ�œ
�˜Jšœ$�œ�œ˜>Jšœ	�
œ�œ�œ˜;Jš�œ�œ�œ˜!J˜——šžœ�œ˜/Jš�œ&�œ�œ˜AJ˜Jš
�œ�œ
�œ�œ�œ˜6J˜š�œ�œ
�˜Jšœ!�œ�œ˜IJšœ�
œ�œ�œ˜6Jš�œ	�œ˜J˜——šžœ�œ
�œ
�œ�œ�œ�œ˜[J˜Jš
�œ�œ
�œ
�œ�œ˜GJ˜š�œ�œ
�˜Jšœ!�œ�œ�œ˜@˜J˜.J˜Jš�œ�œ
�œ˜%—Jš�œ�œ�œ˜5J˜——šž
œ�œ
�œ
�œ�œ
�œ˜Hš�œ�œ
�˜Jšœ�œ�œ˜ ˜J˜.Jš�œ�œ˜ —Jš�œ
˜—Jš�œ˜J˜—šž
œ�œ
�œ
�œ�œ�œ˜Oš�œ�œ
�˜Jšœ�œ˜Jš�œ
˜—Jš�œ˜J˜—šžœ�œ
�œ
�œ�œ�œ˜Uš�œ�œ
�˜Jšœ�œ˜Jš�œ
˜—Jš�œ˜J˜——š
œ™J˜šžœ�œ�œ
�œ
�œ�œ
˜[Jš�œ�œ˜J˜Jšœ�œ�œ
�œ˜?Jš
œ ™ ˜*Jš�œ+˜.J˜——š
žœ�œ�œ
�œ
�œ
˜FJš�œ�œ˜ J˜Jš
œ ™ J˜EJš
œ ™ J˜AJ˜—šžœ�œ�œ
�œ
�œ�œ˜=Jš�œ*˜1Jšœ�œ
˜J˜
J˜J˜8Jš�œ�œ˜+š�œ"˜&J˜5J˜——J˜:J˜J˜*J˜Jš
œ�œ
�œ	�œ�œ
�œ	�œ˜IJš
œ�œ
�œ	�œ�œ
�œ	�œ˜HJ˜Jš
œ
�œ
�œ	�œ�œ
�œ	�œ˜RJ˜šžœ�œ˜J˜TJ˜WJ˜\J˜—šžœ�œ˜J˜JJ˜—šžœ�œ˜J˜UJ˜—šž
œ�œ˜J˜?J˜&J˜J˜—šžœ�œ�œ
�œ
�œ�œ˜FJš�œ˜Jšœ�œ�œ
�œ˜>J˜&J˜—Jšœ�œ
˜1J˜Jšœ�œ˜J˜šž
œ�œ˜7Jš�œ�œ˜$Jšœ�œ
˜J˜J˜8Jš�œ�œ
�œ
˜Jš�œ˜!J˜—šž	œ�œ�œ˜CJš�œ+˜1J˜—šžœ�œ˜)Jšœ�œ#˜0Jš
œ˜Jšœ�œ
˜J˜š�œ*�œ˜2J˜Jš
œ˜J˜Jš
œ˜—š�œ�˜š	žœ�	œ
�œ�œ�˜.Jš
œ+˜+—Jšœ�œ
˜J˜%Jš�œ�œ
�œ
˜J˜J˜<J˜Jš�œ	�œ˜*Jš�œ
˜—J˜J˜—šžœ�œ&�œ
�œ
˜?Jš�œ�œ˜Jšœ�œ
˜J˜6Jš�œ�œ
�œ�œ˜J˜J˜Jš�œ�œ˜J˜—Jšœ�œ˜&J˜Jš
œ�œ
�œ	�œ�œ
�œ	�œ˜BJ˜Jšœ	�œ�œ
˜J˜šž
œ�œ˜#Jš�œ
�˜
Jšœ/�œ
˜3J˜J˜Jš�œ	�œ
�œ�œ
˜'J˜J˜J˜J˜)J˜)J˜+J˜J˜?J˜Jš
œ#™#š�œ.�˜4Jšœ�œ$˜<J˜—J˜)J˜JšœŸ4˜GJ˜J˜J˜&J˜QJ˜R˜/J˜1J˜—J˜$J˜J˜'J˜%J˜#J˜J˜?J˜CJ˜AJ˜J˜7J˜;J˜9J˜J˜;J˜Jš
œ(™(J˜0J˜J˜7J˜)J˜1J˜1J˜3J˜5J˜7J˜3J˜J˜3J˜/J˜1J˜1J˜3J˜5J˜Jš
œ™Jš
œ9˜9Jš
œ-˜-Jš
œ=˜=Jš
œ?˜?J˜Jš
œ5™5Jšœ�œ$˜9Jšœ�œ$˜9Jšœ�œ$˜9Jšœ�œ$˜9J˜4J˜4J˜4J˜4J˜š
œ#˜#J˜J˜J˜—J˜š�œ
˜J˜——J˜J˜—Jš�œ
˜J˜J˜J˜—…—iTŠ