DIRECTORY
Ascii USING [BS, CR, FF, LF, SP, TAB],
Atom USING [MakeAtom],
BasicTime USING [GMT, nullGMT, Update],
DefaultRemoteNames USING [Get],
FS USING [ComponentPositions, Error, ExpandName, FileInfo, nullOpenFile, Open, OpenFile, OpenFileFromStream, SetByteCountAndCreatedTime, StreamFromOpenFile, StreamOpen],
GPM USING [Close, Error, GetChar, GetIndex, Handle, Open],
Intime USING [EventTime],
IO USING [STREAM, Close, Error, GetIndex, int, Put, PutRope, SetLength],
Rope USING [Cat, Concat, FromRefText, ROPE, Substr],
TerminalDefs USING [BW, FL3, FL4, KeyName],
TIPPrivate USING [BadTable, EqualTables, KeyOption, nrOfErrors, ReadTIPTable, Symbol, WriteTIPTable],
TIPTables USING [TimeoutFlavor, TIPChoice, TIPChoiceSeries, TIPKeyState, TIPTableImplRep, TIPTerm, TIPTime],
TIPUser USING [TIPScreenCoords, TIPScreenCoordsRec, TIPTable, TIPTableImplRep, TIPTableRep];

TIPTableBuilder: CEDAR MONITOR
IMPORTS Atom, BasicTime, DefaultRemoteNames, FS, GPM, IO, Rope, TIPPrivate
EXPORTS TIPPrivate, TIPUser
= BEGIN OPEN TIPUser, TIPPrivate, TIPTables;

TIPTableImplRep: PUBLIC TYPE ~ TIPTables.TIPTableImplRep;

KeyName: TYPE ~ TerminalDefs.KeyName;

ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;

LORA: TYPE = LIST OF REF ANY;

errorText: PUBLIC REF ARRAY [0..nrOfErrors] OF ROPE _
NEW[ARRAY [0..nrOfErrors] OF ROPE];

keyNames: PUBLIC REF ARRAY KeyName OF ROPE _
NEW[ARRAY KeyName OF ROPE];

GData: TYPE = RECORD [
ReservedWord: REF PACKED ARRAY Symbol OF BOOL _ NIL,
fh: GPM.Handle _ NIL,
filename: ROPE _ NIL,
errlogfh: STREAM _ NIL,

fastOption: BOOL _ FALSE,
fastMouseOption: BOOL _ FALSE,
keyOption: KeyOption _ none,

ch: CHAR _ 0C,
nextch: CHAR _ 0C,
havenext: BOOL _ FALSE,
symbol: Symbol _ Illegal,
atom: ATOM _ NIL,
keyName: KeyName _ x0,
symPos: INT _ 0,
number: CARDINAL _ 0,
ident: REF TEXT _ NIL,
errcnt: CARDINAL _ 0,
printKeyTable: TIPTable _ NIL,
defaultKeyTable: TIPTable _ NIL
];

gData: REF GData _ NEW[GData _ [
ReservedWord: NEW[PACKED ARRAY Symbol OF BOOL],
ident: NEW[TEXT[100]]
]];

DefaultTable: PROC [printKeys: BOOL] RETURNS [table: TIPTable] = TRUSTED {
SELECT TRUE FROM
printKeys AND gData.printKeyTable # NIL => RETURN [gData.printKeyTable];
NOT printKeys AND gData.defaultKeyTable # NIL => RETURN [gData.defaultKeyTable];
ENDCASE => {
key: KeyName;
enableTerm: keyEnable TIPTerm _ [keyEnable[[Ctrl, up]]];
charTerm: char TIPTerm _ [char[stdChar]];
resultTerm: result TIPTerm _ [result[LIST[charTerm.ch]]];
normalDefault: TIPChoice _ ConsTerm[charTerm, ConsTerm[resultTerm]];
ctrlUpDefault: TIPChoice _ ConsTerm[enableTerm, normalDefault];
default: TIPChoice _ IF printKeys THEN ctrlUpDefault ELSE normalDefault;
impl: REF fast TIPTableImplRep _ NEW[fast TIPTableImplRep];
impl.ignore.down _ FALSE;

FOR key IN KeyName DO -- includes CR and Space!
SELECT key FROM
A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Zero, One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Dash, Slash, BackSlash, Comma, Quote, RightBracket, Period, SemiColon, Return, Arrow, Space, LeftBracket, Equal, DEL, LF, BS, ESC, TAB =>
impl.keyDown[key] _ default;
ENDCASE;
ENDLOOP;

IF printKeys THEN impl.keyDown[TAB] _ ctrlUpDefault; -- Also include TAB
table _ NEW[TIPTableRep _ [impl: impl]];
};
IF printKeys THEN gData.printKeyTable _ table ELSE gData.defaultKeyTable _ table;
RETURN[table];
}; -- DefaultTable



GetChar: PROC = {
GetGPMChar: PROC RETURNS [ch: CHAR] = INLINE {
ch _ GPM.GetChar[gData.fh
! GPM.Error => { IF ec=EndOfStream THEN ch _ 0C; CONTINUE }];
};
IF gData.havenext THEN { gData.havenext _ FALSE; gData.ch _ gData.nextch } ELSE gData.ch _ GetGPMChar[];
IF gData.ch = '- THEN {
IF (gData.nextch _ GetGPMChar[]) = '-
THEN {
DO
SELECT GetGPMChar[] FROM
Ascii.CR, 0C => EXIT;
'- => SELECT GetGPMChar[] FROM
'-, Ascii.CR => EXIT;
ENDCASE;
ENDCASE;
ENDLOOP; 
gData.ch _ Ascii.SP }
ELSE gData.havenext _ TRUE;
};
};

NCONC: PROC [list1, list2: TIPChoice] RETURNS[TIPChoice] = {
l: TIPChoice _ list1;
IF l = NIL THEN RETURN[list2];
UNTIL l.rest = NIL DO l _ l.rest; ENDLOOP;
l.rest _ list2;
RETURN[list1];
};

ForceDirectory: PROC [name: ROPE, dir: ROPE] RETURNS [ROPE] = {
cp: FS.ComponentPositions _ FS.ExpandName[name].cp;
short: ROPE _ Rope.Substr[name, cp.base.start, cp.base.length + 1 + cp.ext.length];
RETURN [FS.ExpandName[short, dir].fullFName];
};

TrySeveralDirectories: PROC [name: ROPE] RETURNS [fullName: ROPE, date: BasicTime.GMT] = {
date _ BasicTime.nullGMT;
fullName _ name;
[created: date, fullFName: fullName] _ FS.FileInfo[name: name, remoteCheck: FALSE
! FS.Error => CONTINUE];
IF date # BasicTime.nullGMT THEN RETURN;
name _ ForceDirectory[name, "///"];
[created: date, fullFName: fullName] _ FS.FileInfo[name: name, remoteCheck: FALSE
! FS.Error => CONTINUE];
IF date # BasicTime.nullGMT THEN RETURN;
name _ ForceDirectory[name, Rope.Concat[DefaultRemoteNames.Get[].current, "Tip>"]];
[created: date, fullFName: fullName] _ FS.FileInfo[name: name, remoteCheck: FALSE
! FS.Error => CONTINUE];
};

InstantiateNewTIPTable: PUBLIC PROC [file: ROPE _ NIL] RETURNS [table: TIPTable _ NIL] = {
comp: ROPE; -- name of the compiled file
tryC: BOOL _ TRUE;
stream: STREAM;
fileCD, compCD: BasicTime.GMT _ BasicTime.nullGMT;
option, newKeyOption: KeyOption;
newTable: TIPTable;
cp: FS.ComponentPositions;
file _ FS.ExpandName[file].fullFName;
[cp: cp] _ FS.ExpandName[file];
comp _ Rope.Cat["///TipC/", Rope.Substr[file, cp.base.start, cp.base.length], ".tipC"];
{
fullComp: ROPE _ comp;
[file, fileCD] _ TrySeveralDirectories[file];
IF fileCD = BasicTime.nullGMT THEN GO TO noComp;
fileCD _ BasicTime.Update[fileCD, 1];
[created: compCD, fullFName: fullComp]
_ FS.FileInfo[name: comp, wantedCreatedTime: fileCD, remoteCheck: FALSE
! FS.Error => GO TO noComp];
stream _ FS.StreamOpen[fullComp, $read ! FS.Error => GO TO noComp];
[table, option] _ ReadTIPTable[stream ! BadTable => CONTINUE];
IO.Close[stream];
IF table # NIL THEN {
IF option # none THEN {
table.link _ DefaultTable[option=printKeys];
table.opaque _ FALSE };
RETURN };
EXITS noComp => {}};
[table, option] _ BuildNewTIPTable[file];
stream _ FS.StreamOpen[comp, $create];
FS.SetByteCountAndCreatedTime[file: FS.OpenFileFromStream[stream], created: fileCD];
WriteTIPTable[table, option, stream];
IO.Close[stream];
stream _ FS.StreamOpen[comp, $read];
[newTable, newKeyOption] _ ReadTIPTable[stream];
IO.Close[stream];
IF newKeyOption # option THEN ERROR;
EqualTables[table, newTable];
};

BuildNewTIPTable: ENTRY PROC [file: ROPE] RETURNS [table: TIPTable _ NIL, option: KeyOption] = {

ENABLE UNWIND => IF gData.errcnt#0 THEN {
GPM.Close[gData.fh]; TruncateErrorLog[]; IO.Close[gData.errlogfh]};

GetFile: PROC [file: ROPE] RETURNS [fh: STREAM _ NIL] = CHECKED {
openFile: FS.OpenFile _ FS.nullOpenFile;
file _ FS.ExpandName[file].fullFName;
openFile _ FS.Open[name: file, remoteCheck: FALSE];
fh _ FS.StreamFromOpenFile[openFile];
};

errMsg: ROPE;

{ -- fake begin to get around bug where double catch phrase fails

ENABLE {
GPM.Error => {errMsg _ errorMsg; GOTO MacroCleanup};
TIPError => GOTO Cleanup;
};

statement: TIPChoiceSeries;

gData.filename _ file;
gData.fh _ GPM.Open[GetFile[file]];
gData.fh.startCall _ '[;
gData.fh.endCall _ '];
gData.fh.singleQuote _ '; -- 004 octal
gData.fh.startQuote _ '(;
gData.fh.endQuote _ ');
gData.fh.sepArg _ ',;
gData.fh.numArg _ '~;
gData.errcnt _ 0;
gData.havenext _ FALSE;
gData.fastOption _ FALSE;
gData.fastMouseOption _ FALSE;
gData.keyOption _ none;

GetChar; GetSymbol;

IF gData.symbol = OptionSym THEN Options;
option _ gData.keyOption;

IF gData.symbol = Select THEN {
GetSymbol;
IF gData.symbol = Trigger THEN {
GetSymbol;
statement _ TriggerStmt[];
}
ELSE Error[5];
IF gData.symbol # Dot THEN Error[3];
}
ELSE Error[1];

GPM.Close[gData.fh];
IF gData.errcnt=0
THEN table _ CreateTable[statement]
ELSE ErrorFinish; -- finish the error log and raise signal

EXITS
Cleanup => { ErrorFinish };
MacroCleanup => {
IF gData.errcnt=0 THEN OpenErrorLog;
gData.errcnt _ gData.errcnt+1;
IO.PutRope[gData.errlogfh, "Error from macro package\n\n"];
IO.PutRope[gData.errlogfh, errMsg];
ErrorFinish;
};

}; -- fake block (see above)

}; -- InstantiateNewTIPTable

TruncateErrorLog: PROC = {
ENABLE IO.Error => GOTO Exit;
IO.SetLength[gData.errlogfh, IO.GetIndex[gData.errlogfh]];
EXITS Exit => {};
};

ErrorFinish: PROC = {
TruncateErrorLog[];
IO.Close[gData.errlogfh];
SIGNAL InvalidTable[Rope.Concat[gData.filename," errors on TIP.ERRORS"]];
};

ConsTerm: PROC [term: TIPTerm, list: TIPChoice _ NIL] RETURNS [TIPChoice] = {
RETURN [CONS[term, list]];
};

ConsAny: PROC [x: REF, list: LORA _ NIL] RETURNS [LORA] = {
RETURN [CONS[x, list]];
};

CreateTable: PROC[series: TIPChoiceSeries] RETURNS[table: TIPTable] = TRUSTED {
IF gData.fastOption THEN {
impl: REF fast TIPTableImplRep ~ NEW[fast TIPTableImplRep];
FOR choiceSeries: TIPChoiceSeries _ series, choiceSeries.rest UNTIL choiceSeries=NIL DO
choice: TIPChoice _ choiceSeries.first;
WITH choice.first SELECT FROM
keyTrigger =>
IF keyState.state = up THEN {
impl.ignore.up _ FALSE;
IF impl.keyUp[keyState.key] # NIL THEN DoubleDef[keyState.key];
impl.keyUp[keyState.key] _ choice.rest;
}
ELSE {
impl.ignore.down _ FALSE;
IF impl.keyDown[keyState.key] # NIL THEN DoubleDef[keyState.key];
impl.keyDown[keyState.key] _ choice.rest;
};
mouseTrigger => {
impl.ignore.move _ FALSE;
IF impl.mouse # NIL THEN Error[25];
impl.mouse _ choice.rest
};
timeTrigger => Error[]; -- to be detected earlier !!!
ENDCASE;
ENDLOOP;
table _ NEW[TIPTableRep _ [impl: impl]];
}
ELSE {
impl: REF small TIPTableImplRep ~ NEW[small TIPTableImplRep];
FOR choiceSeries: TIPChoiceSeries _ series, choiceSeries.rest
UNTIL choiceSeries = NIL DO
choice: TIPChoice _ choiceSeries.first;
WITH choice.first SELECT FROM
keyTrigger => IF keyState.state = up THEN impl.ignore.up _ FALSE
ELSE impl.ignore.down _ FALSE;
mouseTrigger => impl.ignore.move _ FALSE;
timeTrigger => Error[]; -- to be detected earlier !!!
ENDCASE => ERROR;
ENDLOOP;
impl.all _ series;
table _ NEW[TIPTableRep _ [impl: impl]];
};
IF gData.keyOption # none THEN {
table.link _ DefaultTable[gData.keyOption=printKeys];
table.opaque _ FALSE;
};
IF gData.fastMouseOption THEN table.mouseTicks _ 0;
}; -- CreateTable

Options: PROC = {
GetSymbol;
DO -- until see Semicolon
SELECT gData.symbol FROM
Fast => gData.fastOption _ TRUE;
Small => gData.fastOption _ FALSE;
DefaultKeys => gData.keyOption _ defaultKeys;
PrintKeys => gData.keyOption _ printKeys;
FastMouse => gData.fastMouseOption _ TRUE;
SlowMouse => gData.fastMouseOption _ FALSE;
ENDCASE => Error[18];
GetSymbol;
SELECT gData.symbol FROM
Semicolon => EXIT;
Comma => NULL;
ENDCASE => Error[19];
GetSymbol;
ENDLOOP;
GetSymbol;
}; -- Options

TriggerStmt: PROC RETURNS[choiceSeries: TIPChoiceSeries] = {

usedSymbols: LIST OF ATOM _ NIL;

IF gData.symbol = From
THEN
GetSymbol
ELSE {
Error[6];
};
choiceSeries _ TriggerChoiceSeries[];
}; -- TriggerStmt


EnableStmt: PROC RETURNS[choiceSeries: TIPChoiceSeries] = {

usedSymbols: LIST OF ATOM _ NIL;

IF gData.symbol = From THEN
GetSymbol
ELSE {
Error[20];
};
choiceSeries _ EnableChoiceSeries[];
}; -- EnableStmt


TriggerChoiceSeries: PROC RETURNS [choiceSeries: TIPChoiceSeries _ NIL] = {
tail: TIPChoiceSeries _ NIL;
IF gData.symbol = Endcase THEN RETURN[FinalChoice[]];
DO
choice: TIPChoice = TriggerChoice[];
temp: TIPChoiceSeries = LIST[choice];
IF choiceSeries = NIL THEN choiceSeries _ temp ELSE tail.rest _ temp;
tail _ temp;
IF gData.symbol = Semicolon THEN {
GetSymbol;
IF gData.symbol # Endcase THEN LOOP;
};
IF gData.symbol = Endcase THEN {
tail.rest _ FinalChoice[];
RETURN;
};
Error[2];
ENDLOOP;
}; -- TriggerChoiceSeries

EnableChoiceSeries: PROC RETURNS[choiceSeries: TIPChoiceSeries _ NIL] = {
tail: TIPChoiceSeries _ NIL;
IF gData.symbol = Endcase THEN RETURN[FinalChoice[]];
DO
choice: TIPChoice = EnableChoice[];
temp: TIPChoiceSeries _ LIST[choice];
IF choiceSeries = NIL THEN choiceSeries _ temp ELSE tail.rest _ temp;
tail _ temp;
IF gData.symbol = Semicolon THEN {
GetSymbol;
IF gData.symbol # Endcase THEN LOOP;
};
IF gData.symbol = Endcase THEN {
tail.rest _ FinalChoice[];
RETURN;
};
Error[2];
ENDLOOP;
}; -- EnableChoiceSeries

TriggerChoice: PROC RETURNS[triggerChoice: TIPChoice] = {

term: TIPChoice _ TriggerTerm[];
triggerChoice _ NCONC[term, Expression[]];
}; -- TriggerChoice

EnableChoice: PROC RETURNS[enableChoice: TIPChoice] = {

term: TIPChoice _ EnableTerm[];
enableChoice _ NCONC[term, Expression[]];
}; -- EnableChoice

TriggerTerm: PROC RETURNS[triggerTerm: TIPChoice] = {

SELECT gData.symbol FROM
KeyIdent => {
keyTerm: keyTrigger TIPTerm;
keyTerm.keyState _ Key[];
triggerTerm _ LIST[keyTerm];
};
Mouse => {
mouseTerm: mouseTrigger TIPTerm;
triggerTerm _ LIST[mouseTerm];
GetSymbol;
};
ENDCASE => {
Error[8];
};

IF gData.symbol = Before OR gData.symbol = After THEN
triggerTerm _ ConsTerm[TimeOut[], triggerTerm];
}; -- TriggerTerm

EnableTerm: PROC RETURNS[enableTerm: TIPChoice] = {

IF gData.symbol = KeyIdent THEN enableTerm _ Keys[]
ELSE IF gData.symbol = Ident THEN {
predTerm: predEnable TIPTerm;
predTerm.predicate _ gData.atom;
enableTerm _ LIST[predTerm]; 
GetSymbol;
}
ELSE {
Error[21]
};
}; -- EnableTerm

Keys: PROC RETURNS[enableTerm: TIPChoice] = TRUSTED {

first: TIPKeyState _ Key[];

SELECT gData.symbol FROM
VertBar => {
rest: TIPChoice;
GetSymbol;
IF gData.symbol # KeyIdent THEN Error[21];
rest _ Keys[];
WITH x:rest.first SELECT FROM
keyEnable => {
keyTerm: key2Enable TIPTerm;
keyTerm.keyState1 _ first;
keyTerm.keyState2 _ x.keyState;
enableTerm _ LIST[keyTerm];
};
key2Enable => {
keyTerm: keyEnableList TIPTerm;
keyTerm.lst _ LIST[first, x.keyState1, x.keyState2];
enableTerm _ ConsTerm[keyTerm];
};
keyEnableList => {
keyTerm: keyEnableList TIPTerm;
keyTerm.lst _ CONS[first, x.lst];
enableTerm _ ConsTerm[keyTerm];
};
ENDCASE => ERROR;
};
ENDCASE => {
keyTerm: keyEnable TIPTerm;
keyTerm.keyState _ first;
enableTerm _ ConsTerm[keyTerm];
};
}; -- Keys

Key: PROC RETURNS[keySt: TIPKeyState] = {

name: KeyName _ gData.keyName;
GetSymbol;
IF gData.symbol = Up OR gData.symbol = Down THEN {
keySt _ [key: name,
state: IF gData.symbol = Up THEN up
ELSE down];
GetSymbol;
}
ELSE Error[12];
}; -- Key

TimeOut: PROC RETURNS[timeoutExpr: timeTrigger TIPTerm] = {

fl: TimeoutFlavor _ IF gData.symbol = Before THEN lt
ELSE gt;
GetSymbol;
IF gData.symbol = Number THEN {
timeoutExpr.flavor _ fl;
timeoutExpr.mSecs _ gData.number;
GetSymbol;
}
ELSE {
Error[10];
};
}; -- TimeOut

Expression: PROC RETURNS [expression: TIPChoice] = {

SELECT gData.symbol FROM
And => {
GetSymbol;
expression _ TriggerChoice[];
};
While => {
GetSymbol;
expression _ EnableChoice[];
};
RightArrow => {
GetSymbol;
expression _ Statement[];
};
ENDCASE => Error[22];
}; -- Expression

Results: PROC RETURNS [resultList: LORA, resultChoice: TIPChoice] = {

resultItem: REF;
resultExpr: REF TIPTerm;

IF gData.symbol = LeftCurly THEN {
GetSymbol;
[resultList, resultChoice] _ ResultItems[];
RETURN;
};

[resultItem, resultExpr] _ ResultItem[];
SELECT gData.symbol FROM
Comma => {
resultItemList: LORA;
resultExprList: TIPChoice;
GetSymbol;
[resultItemList, resultExprList] _ Results[];
resultList _ ConsAny[resultItem, resultItemList];
resultChoice _ IF resultExpr = NIL THEN resultExprList
ELSE ConsTerm[resultExpr^, resultExprList];
};
ENDCASE => {
userResultList: result TIPTerm;
resultList _ ConsAny[resultItem];
resultChoice _ ConsTerm[userResultList];
IF resultExpr # NIL THEN resultChoice _ ConsTerm[resultExpr^, resultChoice];
};
}; -- Results

Store: PROC [resultList: LORA, tree: TIPChoice] = {

nestedChoice: TIPChoiceSeries;
FOR choice: TIPChoice _ tree, choice.rest UNTIL choice=NIL DO TRUSTED {
WITH term: choice.first SELECT FROM
nested => 
FOR nestedChoice _ term.statement, nestedChoice.rest UNTIL nestedChoice=NIL DO
Store[resultList, nestedChoice.first];
ENDLOOP;
result => {
IF term.list = NIL
THEN
term.list _ resultList
ELSE {
Error[24];
term.list _ resultList; -- !!!
};
};
ENDCASE};
ENDLOOP;
}; -- Store

ResultItems: PROC RETURNS[resultList: LORA, resultChoice: TIPChoice] = {

resultItem: REF;
resultExpr: REF TIPTerm;
[resultItem, resultExpr] _ ResultItem[];
SELECT gData.symbol FROM
RightCurly => {
userResultList: result TIPTerm;
GetSymbol;
resultList _ LIST[resultItem];
resultChoice _ IF resultExpr = NIL
THEN ConsTerm[userResultList]
ELSE ConsTerm[resultExpr^, ConsTerm[userResultList]];
};
ENDCASE => {
resultItemList: LORA;
resultExprList: TIPChoice;
[resultItemList, resultExprList] _ ResultItems[];
resultList _ ConsAny[resultItem, resultItemList];
resultChoice _ IF resultExpr = NIL
THEN resultExprList
ELSE ConsTerm[resultExpr^, resultExprList];
};
};

ResultItem: PROC RETURNS[resultItem: REF, resultExpr: REF TIPTerm _ NIL] = {

SELECT gData.symbol FROM
Char => {
resultExpr _ NEW[char TIPTerm _ [char[resultItem _ stdChar]]];
GetSymbol;
};
Coords => {
resultExpr _ NEW[coords TIPTerm _ [coords[resultItem _ stdCoords]]];
GetSymbol;
};
Time => {
resultExpr _ NEW[time TIPTerm _ [time[resultItem _ stdTime]]];
GetSymbol;
};
KeyIdent, -- result names might be key names
Ident => {
resultItem _ gData.atom;
GetSymbol;
};
Number => {
resultItem _ NEW[INT];
WITH resultItem SELECT FROM
z: REF INT => z^ _ gData.number;
ENDCASE;
GetSymbol;
};
String => {
resultItem _ NEW[TEXT[gData.ident.length]];
WITH resultItem SELECT FROM
z: REF TEXT => {
FOR i: CARDINAL IN [0..gData.ident.length) DO
z[i] _ gData.ident[i];
ENDLOOP;
z.length _ gData.ident.length;
};
ENDCASE;
GetSymbol;
};
ENDCASE =>
IF gData.ReservedWord[gData.symbol] THEN {
resultItem _ gData.atom;
GetSymbol;
}
ELSE Error[9];
}; -- ResultItem


FinalChoice: PROC RETURNS [finalChoice: TIPChoiceSeries] = {

GetSymbol;  -- we always get here with a pending ENDCASE
IF gData.symbol = RightArrow THEN {
GetSymbol;
finalChoice _ LIST[Statement[]];
};
}; -- FinalChoice

Statement: PROC RETURNS[stmt: TIPChoice] = {

IF gData.symbol = Select
THEN {
term: nested TIPTerm;
GetSymbol;
IF gData.symbol = Trigger OR gData.symbol = Enable
THEN {
sy: Symbol _ gData.symbol;
GetSymbol;
term.statement _ IF sy = Trigger THEN TriggerStmt[] ELSE EnableStmt[];
stmt _ LIST[term];
}
ELSE {
Error[13];
};
}
ELSE {
userResults: LORA;
[userResults, stmt] _ Results[];
Store[userResults, stmt];
};
}; -- Statement



stdChar: PUBLIC REF CHAR _ NEW[CHAR];
stdCoords: PUBLIC TIPScreenCoords _ NEW[TIPScreenCoordsRec];
stdTime: PUBLIC TIPTables.TIPTime _ NEW[Intime.EventTime];

InvalidTable: PUBLIC SIGNAL [errorMsg: ROPE] = CODE;

OpenErrorLog: PROC = {
gData.errlogfh _ FS.StreamOpen["tip.errors", $create];
IO.PutRope[gData.errlogfh, gData.filename];
IO.PutRope[gData.errlogfh, " TIP TABLE error log.\n\n"];
};

DoubleDef: PROC[key: KeyName] = {
IF gData.errcnt=0 THEN OpenErrorLog[];
gData.errcnt _ gData.errcnt+1;
IO.PutRope[gData.errlogfh, keyNames[key]];
IO.PutRope[gData.errlogfh, " entry must not occur more than once in table.\n\n"];
};    

TIPError: ERROR = CODE;

Error: PROC[nr: CARDINAL _ 0] = { OPEN IO;
IF gData.errcnt=0 THEN OpenErrorLog;
gData.errcnt _ gData.errcnt+1;
PutRope[gData.errlogfh, errorText[nr]];
PutRope[gData.errlogfh, " at "];
Put[gData.errlogfh, int[gData.symPos]];
PutRope[gData.errlogfh, "\n\n"];
ERROR TIPError;
};

GetSymbol: PROC = {

GetNumber: PROC = {
gData.symbol _ Number;
gData.number _ 0;
WHILE gData.ch IN ['0..'9] DO
gData.number _ 10*gData.number + gData.ch-'0;
GetChar[];
ENDLOOP;
};

GetWord: PROC = {
dummy: KeyName = KeyName.LAST;
i: CARDINAL _ 0;
WHILE gData.ch IN ['0..'9] OR gData.ch IN ['a..'z] OR gData.ch IN ['A..'Z] DO
gData.ident[i] _ gData.ch;
i _ i + 1;
GetChar[];
ENDLOOP;
gData.ident.length _ i;

gData.atom _ Atom.MakeAtom[Rope.FromRefText[gData.ident]];
gData.symbol _ KeyIdent;
gData.keyName _ dummy;

SELECT gData.atom FROM
$OPTIONS => gData.symbol _ OptionSym;
$SELECT => gData.symbol _ Select;
$TRIGGER => gData.symbol _ Trigger;
$ENABLE => gData.symbol _ Enable;
$FROM => gData.symbol _ From;
$ENDCASE => gData.symbol _ Endcase;
$END => gData.symbol _ End;
$AND => gData.symbol _ And;
$WHILE => gData.symbol _ While;
$AFTER => gData.symbol _ After;
$BEFORE => gData.symbol _ Before;
$Up => gData.symbol _ Up;
$Down => gData.symbol _ Down;
$Mouse => gData.symbol _ Mouse;
$Char => gData.symbol _ Char;
$Coords => gData.symbol _ Coords;
$TIME => gData.symbol _ Time;

$Small => gData.symbol _ Small;
$Fast => gData.symbol _ Fast;
$FastMouse => gData.symbol _ FastMouse;
$SlowMouse => gData.symbol _ SlowMouse;
$PrintKeys => gData.symbol _ PrintKeys;
$DefaultKeys => gData.symbol _ DefaultKeys;
$x0 => gData.keyName _ x0;
$x1 => gData.keyName _ x1;
$x2 => gData.keyName _ x2;
$x3 => gData.keyName _ x3;
$x4 => gData.keyName _ x4;
$x5 => gData.keyName _ x5;
$x6 => gData.keyName _ x6;
$Pen => gData.keyName _ Pen;
$Keyset1 => gData.keyName _ Keyset1;
$Keyset2 => gData.keyName _ Keyset2;
$Keyset3 => gData.keyName _ Keyset3;
$Keyset4 => gData.keyName _ Keyset4;
$Keyset5 => gData.keyName _ Keyset5;
$Red => gData.keyName _ Red;
$Blue => gData.keyName _ Blue;
$Yellow => gData.keyName _ Yellow;
$Five => gData.keyName _ Five;
$Four => gData.keyName _ Four;
$Six => gData.keyName _ Six;
$E => gData.keyName _ E;
$Seven => gData.keyName _ Seven;
$D => gData.keyName _ D;
$U => gData.keyName _ U;
$V => gData.keyName _ V;
$Zero => gData.keyName _ Zero;
$K => gData.keyName _ K;
$Dash => gData.keyName _ Dash;
$P => gData.keyName _ P;
$Slash => gData.keyName _ Slash;
$BackSlash => gData.keyName _ BackSlash;
$Defaults => gData.keyName _ BackSlash; -- synonym
$LF => gData.keyName _ LF;
$Copy => gData.keyName _ LF; -- synonym
$BS => gData.keyName _ BS;
$Three => gData.keyName _ Three;
$Two => gData.keyName _ Two;
$W => gData.keyName _ W;
$Q => gData.keyName _ Q;
$S => gData.keyName _ S;
$A => gData.keyName _ A;
$Nine => gData.keyName _ Nine;
$I => gData.keyName _ I;
$X => gData.keyName _ X;
$O => gData.keyName _ O;
$L => gData.keyName _ L;
$Comma => gData.keyName _ Comma;
$Quote => gData.keyName _ Quote;
$RightBracket => gData.keyName _ RightBracket;
$Spare2 => gData.keyName _ Spare2;
$Keyboard => gData.keyName _ Spare2; -- synonym (DLion)
$Next => gData.keyName _ Spare2; -- synonym
$Spare1 => gData.keyName _ Spare1;
$BW => gData.keyName _ Spare1; -- synonym
$Undo => gData.keyName _ Spare1; -- synonym (DLion)
$Look => gData.keyName _ Spare1; -- synonym
$One => gData.keyName _ One;
$ESC => gData.keyName _ ESC;
$Center => gData.keyName _ ESC; -- synonym (DLion)
$TAB => gData.keyName _ TAB;
$F => gData.keyName _ F;
$Ctrl => gData.keyName _ Ctrl;
$Open => gData.keyName _ Ctrl; -- synonym (DLion)
$C => gData.keyName _ C;
$J => gData.keyName _ J;
$B => gData.keyName _ B;
$Z => gData.keyName _ Z;
$LeftShift => gData.keyName _ LeftShift;
$Period => gData.keyName _ Period;
$SemiColon => gData.keyName _ SemiColon;
$Return => gData.keyName _ Return;
$Arrow => gData.keyName _ Arrow;
$DEL => gData.keyName _ DEL;
$Move => gData.keyName _ Move;
$FL3 => gData.keyName _ Move; -- synonym
$R => gData.keyName _ R;
$T => gData.keyName _ T;
$G => gData.keyName _ G;
$Y => gData.keyName _ Y;
$H => gData.keyName _ H;
$Eight => gData.keyName _ Eight;
$N => gData.keyName _ N;
$M => gData.keyName _ M;
$Lock => gData.keyName _ Lock;
$Space => gData.keyName _ Space;
$LeftBracket => gData.keyName _ LeftBracket;
$Equal => gData.keyName _ Equal;
$RightShift => gData.keyName _ RightShift;
$Spare3 => gData.keyName _ Spare3;
$Swat => gData.keyName _ Spare3; -- synonym
$Stop => gData.keyName _ Spare3; -- synonym (DLion)
$Props => gData.keyName _ Props;
$FL4 => gData.keyName _ Props; -- synonym
$SkipNext => gData.keyName _ SkipNext; -- DLion only
$Margins => gData.keyName _ Margins; -- DLion only
$Same => gData.keyName _ Same; -- DLion only
$Find => gData.keyName _ Find; -- DLion only
$Again => gData.keyName _ Again; -- DLion only
$Help => gData.keyName _ Help; -- DLion only
$DefnExpand => gData.keyName _ DefnExpand; -- DLion only
$RightArrow => gData.keyName _ RightArrow; -- DLion only
$Bold => gData.keyName _ Bold; -- DLion only
$Italics => gData.keyName _ Italics; -- DLion only
$Underline => gData.keyName _ Underline; -- DLion only
$Superscript => gData.keyName _ Superscript; -- DLion only
$Subscript => gData.keyName _ Subscript; -- DLion only
$LargerSmaller => gData.keyName _ LargerSmaller; -- DLion only
$Font => gData.keyName _ Font; -- DLion only
ENDCASE => gData.symbol _ Ident;
};

GetString: PROC = {
i: CARDINAL _ 0;
DO  -- process the characters of the string
SELECT gData.ch _ GPM.GetChar[gData.fh] FROM
'" => EXIT;
'\\ => SELECT gData.ch _ GPM.GetChar[gData.fh] FROM
'n, 'N, 'r, 'R => gData.ch _ Ascii.CR;
't, 'T => gData.ch _ Ascii.TAB;
'b, 'B => gData.ch _ Ascii.BS;
'f, 'F => gData.ch _ Ascii.FF;
'l, 'L => gData.ch _ Ascii.LF;
'\\, '', '" => NULL;
IN ['0..'3] => {
d: CARDINAL _ gData.ch-'0;
IF (gData.ch _ GPM.GetChar[gData.fh]) NOT IN ['0..'7] THEN Error[26];
d _ d*8 + gData.ch-'0;
IF (gData.ch _ GPM.GetChar[gData.fh]) NOT IN ['0..'7] THEN Error[26];
d _ d*8 + gData.ch-'0;
gData.ch _ LOOPHOLE[d] };
ENDCASE => Error[26];
ENDCASE;
gData.ident[i] _ gData.ch;
i _ i + 1;
ENDLOOP;
gData.ident.length _ i;
GetChar;
gData.symbol _ String;
};

GetPunctuation: PROC = {
SELECT gData.ch FROM
'; => gData.symbol _ Semicolon;
', => gData.symbol _ Comma;
'> => gData.symbol _ Greater;
'. => gData.symbol _ Dot;
'| => gData.symbol _ VertBar;
'= => {
GetChar; 
IF gData.ch = '> THEN gData.symbol _ RightArrow 
ELSE gData.symbol _ Illegal; 
};
'{ => gData.symbol _ LeftCurly;
'} => gData.symbol _ RightCurly;
ENDCASE => gData.symbol _ Illegal;
GetChar[];
};

WHILE gData.ch = Ascii.SP OR gData.ch = Ascii.TAB OR gData.ch = Ascii.CR DO
GetChar[];
ENDLOOP;
gData.symPos _ GPM.GetIndex[gData.fh]-1;

SELECT gData.ch FROM
IN ['0..'9] => GetNumber[];
IN ['a..'z], IN ['A..'Z] => GetWord[];
= '"  => GetString[];
ENDCASE => GetPunctuation[];
};

InitBuilder: PUBLIC PROC = {
errorText[0] _ "Error";
errorText[1] _ "OPTIONS or CASE expected";
errorText[2] _ "ENDCASE or; expected";
errorText[3] _ "'.' expected";
errorText[4] _ "Ident expected";
errorText[5] _ "TRIGGER expected";
errorText[6] _ "OF expected";
errorText[7] _ "': expected";
errorText[8] _ "KeyIdent or Mouse expected";
errorText[9] _ "error in Action";
errorText[10] _ "Number expected";
errorText[11] _ "'> expected";
errorText[12] _ "Up or Down expected";
errorText[13] _ "TRIGGER or ENABLED expected";
errorText[14] _ "illegal option";
errorText[15] _ "enable procedures as CONDITION only";
errorText[16] _ "mouse motion as TRIGGER only";
errorText[17] _ "label used twice";
errorText[18] _ "; expected";
errorText[19] _ ", expected";
errorText[20] _ "BY expected";
errorText[21] _ "Key or Ident expected";
errorText[22] _ "AND, WHILE, =>, or : expected";
errorText[23] _ "CASE expected";
errorText[24] _ "sorry, results only at leaves implemented";
errorText[25] _ "Mouse movement entry must not occur more than once in table.";
errorText[26] _ "Illegal character following \\ in string";
errorText[27] _ "";
errorText[28] _ "";
errorText[29] _ "";
errorText[30] _ "";

keyNames[x0] _ "x0";
keyNames[x1] _ "x1";
keyNames[x2] _ "x2";
keyNames[x3] _ "x3";
keyNames[x4] _ "x4";
keyNames[x5] _ "x5";
keyNames[x6] _ "x6";
keyNames[Pen] _ "Pen";
keyNames[Keyset1] _ "Keyset1";
keyNames[Keyset2] _ "Keyset2";
keyNames[Keyset3] _ "Keyset3";
keyNames[Keyset4] _ "Keyset4";
keyNames[Keyset5] _ "Keyset5";
keyNames[Red] _ "Red";
keyNames[Blue] _ "Blue";
keyNames[Yellow] _ "Yellow";
keyNames[Five] _ "Five";
keyNames[Four] _ "Four";
keyNames[Six] _ "Six";
keyNames[E] _ "E";
keyNames[Seven] _ "Seven";
keyNames[D] _ "D";
keyNames[U] _ "U";
keyNames[V] _ "V";
keyNames[Zero] _ "Zero";
keyNames[K] _ "K";
keyNames[Dash] _ "Dash";
keyNames[P] _ "P";
keyNames[Slash] _ "Slash";
keyNames[BackSlash] _ "BackSlash";
keyNames[LF] _ "LF";
keyNames[BS] _ "BS";
keyNames[Three] _ "Three";
keyNames[Two] _ "Two";
keyNames[W] _ "W";
keyNames[Q] _ "Q";
keyNames[S] _ "S";
keyNames[A] _ "A";
keyNames[Nine] _ "Nine";
keyNames[I] _ "I";
keyNames[X] _ "X";
keyNames[O] _ "O";
keyNames[L] _ "L";
keyNames[Comma] _ "Comma";
keyNames[Quote] _ "Quote";
keyNames[RightBracket] _ "RightBracket";
keyNames[Spare2] _ "Spare2";
keyNames[TerminalDefs.BW] _ "BW";
keyNames[One] _ "One";
keyNames[ESC] _ "ESC";
keyNames[TAB] _ "TAB";
keyNames[F] _ "F";
keyNames[Ctrl] _ "Ctrl";
keyNames[C] _ "C";
keyNames[J] _ "J";
keyNames[B] _ "B";
keyNames[Z] _ "Z";
keyNames[LeftShift] _ "LeftShift";
keyNames[Period] _ "Period";
keyNames[SemiColon] _ "SemiColon";
keyNames[Return] _ "Return";
keyNames[Arrow] _ "Arrow";
keyNames[DEL] _ "DEL";
keyNames[TerminalDefs.FL3] _ "FL3";
keyNames[R] _ "R";
keyNames[T] _ "T";
keyNames[G] _ "G";
keyNames[Y] _ "Y";
keyNames[H] _ "H";
keyNames[Eight] _ "Eight";
keyNames[N] _ "N";
keyNames[M] _ "M";
keyNames[Lock] _ "Lock";
keyNames[Space] _ "Space";
keyNames[LeftBracket] _ "LeftBracket";
keyNames[Equal] _ "Equal";
keyNames[RightShift] _ "RightShift";
keyNames[Spare3] _ "Spare3";
keyNames[TerminalDefs.FL4] _ "FL4";
};

InitBuilder[];

{
FOR s: Symbol IN Symbol DO gData.ReservedWord[s] _ TRUE; ENDLOOP;
gData.ReservedWord[String] _ FALSE;
gData.ReservedWord[Semicolon] _ FALSE;
gData.ReservedWord[Comma] _ FALSE;
gData.ReservedWord[Greater] _ FALSE;
gData.ReservedWord[Dot] _ FALSE;
gData.ReservedWord[RightArrow] _ FALSE;
gData.ReservedWord[Illegal] _ FALSE;
gData.ReservedWord[LeftCurly] _ FALSE;
gData.ReservedWord[RightCurly] _ FALSE;
gData.ReservedWord[VertBar] _ FALSE;
gData.ReservedWord[Number] _ FALSE;
gData.ReservedWord[KeyIdent] _ FALSE;
};

END.


¬TIPTableBuilder.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Doug Wyatt, April 14, 1985 10:06:17 pm PST
Russ Atkinson (RRA) October 21, 1985 9:44:16 pm PDT
global scanner variables:
*** the scanner: *** 
scan over comment
go to CR or double dash
construct the tipC name from the tip name
Try to open and read the compiled (tipC) version of the tip file.  The tipC file is always stored on the ///TipC/ directory to avoid multiple copies.  The create date of the tipC file is one second later than the create date of the tip file so we can determine correspondence between the two.
At this point there is no tipC file, so we will have to make one.  We start from the tip file, and any FS.Error will propagate from here.
FS.Error will percolate up
TriggerStmt ::= SELECT TRIGGER FROM TriggerChoiceSeries
skip until choice-begin
EnableStmt ::= SELECT ENABLE FROM EnableChoiceSeries
skip until (enable)choice-begin
TriggerChoiceSeries ::= TriggerChoice; TriggerChoiceSeries
| TriggerChoice ENDCASE FinalChoice
| ENDCASE FinalChoice
skip until choice-begin or else
EnableChoiceSeries ::= EnableChoice; EnableChoiceSeries
| EnableChoice ENDCASE FinalChoice
| ENDCASE FinalChoice
skip until choice-begin or else
TriggerChoice ::= TriggerTerm Expression
EnableChoice ::= EnableTerm Expression
TriggerTerm ::= Key TimeOut | MOUSE TimeOut
skip
EnableTerm ::= Keys | PredicateIdent
Keys ::= Key | Key "|" Keys
KeyIdent UP | KeyIdent DOWN
TimeOut ::= empty | BEFORE Number | AFTER Number
skip
Expression ::= AND TriggerChoice | WHILE EnableChoice | => Statement
Results ::= ResultItem | ResultItem , Results | { ResultItem* }
find all leaves l:[result TIPTermRec] of the tree,
append the list found there to a copy of resultList, and 
store the resulting list as l.list
ResultItems ::= ResultItem } | ResultItem ResultItems
ResultItem ::= COORDS | CHAR | TIME | String | Number | ResultIdent
FinalChoice ::= empty | => Statement
Statement ::= TriggerStmt | EnableStmt | Results
note that all parameters share the same variable for notification
users must copy parameter if they want to save value after returning from notify
find next symbol
classify symbol
main code:
Reserved word initialization
Κ0ϊ–
"Mesa" style˜
codeš
œ™Kšœ
Οm
œ7™BK™*K™3—K˜š
Οk	˜	Kšœžœžœžœžœžœžœžœ˜&Kšœžœ˜Kšœ
žœžœ˜'Kšœžœ˜Kšžœ
žœ‘
˜©
Kšžœ
žœ1˜:Kšœžœ
˜Kšžœ
žœžœ8˜HKšœžœžœ
˜4Kšœ
žœžœ˜+KšœžœU˜eKšœ
žœ]˜lKšœžœO˜\—K˜šΠblœžœ
ž˜Kšžœ&žœžœžœ˜JKšžœ˜Kšœžœ
žœ ˜,K˜Kšœžœ
žœ˜9K˜Kšœ	žœ˜%K˜Kšžœžœžœ
˜Kšžœžœžœ
žœ
˜K˜Kšžœžœžœ
žœ
žœ
žœ
˜K˜šœžœ
žœ
žœžœ
žœ˜5Kšžœ
žœžœ
žœ˜#K˜—šœ
žœ
žœ
žœ	žœ
žœ˜,Kšžœ
žœ	žœ
žœ˜K˜—šœžœžœ˜Kš
œžœ
žœ
žœžœ
žœžœ
˜4Kšœžœ
žœ
˜Kšœ
žœžœ
˜Kšœ
žœžœ
˜K˜Kšœžœžœ
˜Kšœžœžœ
˜K˜K˜š
œ™Kšœžœ˜Kšœžœ˜Kšœ
žœžœ
˜Kš
œ˜Kšœžœžœ
˜Kš
œ˜Kšœžœ˜Kšœžœ˜Kšœžœ
žœžœ
˜Kšœžœ˜Kšœžœ
˜Kšœž˜—K˜—K˜šœžœ	žœ
˜ Kšœžœ
žœ
žœžœ
žœ˜/Kšœžœ
žœ˜K˜—K˜—š
Οnœžœ
žœžœžœ˜Jšžœ
žœ
ž˜Kšœ
žœžœžœ˜HKšžœžœžœžœ˜Pšžœ˜K˜
K˜8K˜)Kšœ%žœ˜9Kš
œD˜DKš
œ?˜?Kšœžœžœžœ˜HKšœžœžœ˜;Kšœžœ
˜K˜šžœžœ	žœ
Οc˜/šžœž˜š>ž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œž
œ―
žœžœžœžœžœ˜“Kš
œ˜—Kšžœ
˜—Kšžœ
˜—K˜Kšžœžœžœ‘˜HKšœžœ˜(K˜——Kšžœžœžœ˜QKšžœ˜Kšœ‘˜K˜K˜—Kš
œ™K˜š œžœ˜š
 
œžœ
žœžœžœ˜.šœžœ˜Kš	œžœžœžœ
žœ˜=—Kš
œ˜—Kšžœžœžœžœ˜hšžœžœ˜šžœ#˜%šžœ˜Kš
œ™š
ž˜Kš
œ™šžœž˜Kšœžœžœ
˜šœžœž˜Kšœ
žœžœ
˜Kšžœ
˜—Kšžœ
˜—Kšžœ˜	—Kšœžœ˜—Kšžœžœ
˜—Kš
œ˜—Kš
œ˜K˜—šžœžœžœ˜<K˜Kšžœžœ
žœ
žœ˜Kšžœ
žœ
žœ
žœ
˜*K˜Kšžœ˜Kš
œ˜K˜—š œžœžœžœžœžœ˜?Kšœžœžœ˜3KšœžœH˜SKšžœžœ#˜-K˜K˜—š œžœžœžœžœžœ˜ZKš
œ˜Kš
œ˜šœ'žœ#ž˜QKšœžœ
žœ˜—Kšžœžœ
žœ
˜(Kš
œ#˜#šœ'žœ#ž˜QKšœžœ
žœ˜—Kšžœžœ
žœ
˜(Kš
œS˜Sšœ'žœ#ž˜QKšœžœ
žœ˜—K˜K˜—š œžœ
žœžœžœžœžœ˜ZKšœžœ‘˜(Kšœžœžœ
˜Kšœžœ
˜Kšœžœ˜2K˜ K˜Kšœžœ˜Kšœžœ˜%Kš
œ)™)Kšœžœ˜Kš
œW˜Wš
œ
˜
Kš
œ€™€Kšœ
žœ˜Kš
œ-˜-Kšžœžœ
žœ
žœ˜0Kš
œ%˜%š
œ&˜&šœžœ>ž˜GKšœžœ
žœ
žœ	˜——Kš	œ	žœžœ
žœ
žœ	˜CKšœ4žœ˜>Kšžœ˜šžœ	žœ
žœ˜šžœžœ˜K˜,Kšœžœ˜—Kšžœ˜	—Kšžœ˜—Kš
œ‰
™‰
K˜)Kšœ	žœ˜&Kšžœ"žœ.˜TK˜%Kšžœ˜Kšœ	žœ˜$K˜0Kšžœ˜Kšžœžœ
žœ
˜$K˜K˜K˜—š œžœ
žœžœ
žœžœ˜`K˜šžœ
žœžœžœ˜)Kšžœ&žœ˜CK˜—š œžœžœžœžœžœžœ˜AKš
œ™Kšœ
žœžœ˜(Kšœžœ˜%Kšœžœžœ˜3Kšœžœ˜%Kš
œ˜K˜—šœžœ
˜
K˜—šœ‘?˜AK˜šžœ˜Kšžœžœ˜4Kšœžœ	˜Kš
œ˜K˜—K˜K˜Kš
œ˜Kšœžœ˜#Kš
œ˜Kš
œ˜Kšœ‘˜'Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ˜K˜K˜K˜Kšžœžœ	˜)Kš
œ˜K˜šžœžœ˜K˜
šžœžœ˜ K˜
K˜Kš
œ
˜
—Kšžœ
˜Kšžœžœ
˜$Kš
œ
˜
—Kšžœ
˜K˜Kšžœ˜šžœ˜Kšžœ˜#Kšžœ‘(˜:—K˜š
ž˜K˜˜Kšžœžœ˜$Kš
œ˜Kšžœ9˜;Kšžœ!˜#K˜˜K˜———Kšœ‘˜—K˜Kšœ‘˜K˜—š œžœ˜Kšžœ
žœ
žœ˜Kšžœžœ˜:Kšžœ˜Kš
œ˜K˜—š œžœ˜K˜Kšžœ˜KšžœC˜IKš
œ˜K˜—š œžœ#žœžœ˜MKšžœžœ˜K˜K˜—š œžœžœžœžœžœžœ˜;Kšžœžœ˜K˜K˜—š œžœžœžœ˜Ošžœžœ˜Kšœžœžœ˜;šžœ;žœžœ
ž˜WK˜'šžœžœ
ž˜˜
šžœžœ˜Kšœžœ
˜Kšžœžœ
žœ˜?K˜'Kš
œ
˜
—šžœ˜Kšœžœ
˜Kšžœžœ
žœ˜AK˜)Kš
œ˜——š
œ˜Kšœžœ
˜Kšžœžœ
žœ˜#K˜Kš
œ˜—Kšœ‘˜5Kšžœ
˜—Kšžœ
˜—Kšœžœ˜(Kš
œ
˜
—šžœ˜Kšœžœžœ˜=šžœ:˜=šžœžœ
ž˜K˜'šžœžœ
ž˜šœžœžœž˜@Kšžœžœ
˜—Kšœ#žœ
˜)Kšœ‘˜5Kšžœžœ
˜—Kšžœ
˜——K˜Kšœžœ˜(Kš
œ˜—šžœžœ˜ Kš
œ5˜5Kšœžœ
˜Kš
œ˜—Kšžœžœ˜3Kšœ‘˜K˜—š œžœ˜K˜
šžœ
‘˜šžœž˜Kšœžœ
˜ Kšœžœ
˜"Kš
œ-˜-Kš
œ)˜)Kšœ%žœ
˜*Kšœ%žœ
˜+Kšžœ˜—K˜
šžœž˜Kšœ
žœ
˜Kšœ	žœ
˜Kšžœ˜—K˜
Kšžœ
˜—K˜
Kšœ‘
˜
K˜—š œžœ
žœ#˜<Kš
œ7™7K˜Kš	œ
žœ
žœ
žœžœ
˜ K˜šžœ˜š
ž˜K˜	—šžœ˜K˜	Kš
œ™Kš
œ˜——K˜%Kšœ‘˜K˜K˜—š 
œžœ
žœ#˜;Kš
œ4™4K˜Kš	œ
žœ
žœ
žœžœ
˜ K˜šžœž˜K˜	—šžœ˜K˜
Kš
œ™Kš
œ˜—K˜$Kšœ‘
˜K˜K˜—š œžœ
žœ"žœ˜Kš
œ:™:Kš
œ#™#Kš
œ™—Kšœžœ
˜Kšžœžœ
žœ˜5š
ž˜K˜$Kšœžœ	˜%Kšžœžœ
žœžœ˜EKš
œ˜šžœžœ˜"Kš
œ
˜
Kšžœžœ
žœ
˜$K˜—šžœžœ˜ Kš
œ˜Kšžœ
˜K˜—Kš
œ™Kš
œ	˜	Kšžœ
˜—Kšœ‘˜K˜—š œžœ
žœ!žœ˜Iš
œ7™7Kš
œ"™"Kš
œ™—Kšœžœ
˜Kšžœžœ
žœ˜5š
ž˜K˜#Kšœžœ	˜%Kšžœžœ
žœžœ˜EKš
œ˜šžœžœ˜"Kš
œ
˜
Kšžœžœ
žœ
˜$K˜—šžœžœ˜ Kš
œ˜Kšžœ
˜K˜—Kš
œ™Kš
œ	˜	Kšžœ
˜—Kšœ‘˜K˜—š 
œžœ
žœ˜9Kš
œ(™(K˜K˜ Kšœžœ˜*Kšœ‘˜K˜—š œžœ
žœ˜7Kš
œ&™&K˜K˜Kšœžœ˜)Kšœ‘˜K˜—š œžœ
žœ˜5Kš
œ+™+K˜šžœž˜š
œ
˜
˜K˜—Kšœžœ
˜Kš
œ˜—š
œ
˜
K˜ Kšœžœ˜K˜
Kš
œ˜—šžœ˜K˜	Kš
œ™Kš
œ˜K˜——šžœžœž˜5Kš
œ/˜/—Kšœ‘˜K˜—š 
œžœ
žœ˜3Kš
œ$™$K˜Kšžœžœ˜3šžœ
žœžœ˜#K˜Kš
œ ˜ Kšœ
žœ˜K˜
Kš
œ
˜
—šžœ˜K˜	Kš
œ˜—Kšœ‘
˜K˜—š œžœ
žœžœ˜5Kš
œ™K˜K˜K˜šžœž˜š
œ˜K˜K˜
Kšžœžœ˜*K˜šžœžœ
ž˜š
œ˜K˜K˜K˜Kšœ
žœ
˜Kš
œ˜—š
œ˜K˜Kšœžœ"˜4Kš
œ˜Kš
œ˜—š
œ˜K˜Kšœžœ˜!Kš
œ˜Kš
œ˜—Kšžœžœ
˜Kš
œ˜——šžœ˜K˜K˜Kš
œ˜Kš
œ˜——Kšœ‘˜
K˜—š œžœ
žœ˜)Kš
œ™K˜Kš
œ˜K˜
šžœžœžœ˜2˜šœžœžœ˜#Kšžœ˜——K˜
Kš
œ
˜
—Kšžœ˜Kšœ‘˜	K˜—š œžœ
žœ&˜;Kš
œ0™0K˜šœžœžœ˜4Kšžœ˜—K˜
šžœžœ˜K˜Kš
œ!˜!K˜
Kš
œ
˜
—šžœ˜K˜
Kš
œ™Kš
œ˜—Kšœ‘
˜
K˜—š 
œžœ
žœ˜4Kš
œD™DK˜šžœž˜š
œ˜K˜
K˜Kš
œ˜—š
œ
˜
K˜
K˜Kš
œ˜—š
œ˜K˜
K˜Kš
œ˜—Kšžœ˜—Kšœ‘
˜K˜—š œžœ
žœžœ˜EKš
œ?™?K˜Kšœžœ
˜Kšœžœ	˜K˜šžœžœ˜"K˜
K˜+Kšžœ
˜Kš
œ˜K˜—K˜(šžœž˜š
œ
˜
Kšœžœ
˜K˜K˜
K˜-Kš
œ1˜1šœžœžœ
žœ˜6Kšžœ'˜+—Kš
œ˜—šžœ˜K˜Kš
œ!˜!Kš
œ(˜(Kšžœžœ
žœ4˜LKš
œ˜——Kšœ‘
˜
K˜—š œžœžœ˜3Kš
œ2™2Kš
œ9™9Kš
œ"™"K˜K˜š
žœ'žœžœ
žœ
žœ˜Gšžœžœ
ž˜#˜
šžœ2žœžœ
ž˜NK˜&Kšžœ
˜——š
œ˜šžœ
ž˜š
ž˜K˜—šžœ˜K˜
Kšœ‘˜Kš
œ˜——Kš
œ˜—Kšžœ˜	—Kšžœ
˜—Kšœ‘˜K˜—š œžœ
žœ
žœ˜HKš
œ5™5K˜Kšœžœ
˜Kšœžœ	˜K˜(šžœž˜š
œ˜K˜K˜
Kšœ
žœ
˜šœžœž˜"Kšžœ˜Kšžœ1˜5—Kš
œ˜—šžœ˜Kšœžœ
˜K˜K˜1Kš
œ1˜1šœžœž˜"Kšžœ˜Kšžœ'˜+—Kš
œ˜——Kš
œ˜K˜—š 
œžœ
žœ
žœžœžœ˜LKš
œC™CK˜šžœž˜š
œ	˜	šœ
žœ.˜>K˜
—Kš
œ˜—š
œ˜šœ
žœ4˜DK˜
—Kš
œ˜—š
œ	˜	šœ
žœ.˜>K˜
—Kš
œ˜—Kšœ
‘"˜,š
œ
˜
Kš
œ˜K˜
Kš
œ˜—š
œ˜šœ
žœ
žœ˜šžœžœ
ž˜Kšœžœ
žœ˜ Kšžœ
˜——K˜
Kš
œ˜—š
œ˜šœ
žœ
žœ˜+šžœžœ
ž˜šœžœ
žœ˜šžœžœ
žœž˜-Kš
œ˜Kšžœ
˜—Kš
œ˜——š
œ˜Kšžœ
˜——˜
Kš
œ˜——šžœ˜
šžœ"žœ˜*Kš
œ˜K˜
š
œ
˜
Kšžœ
˜————Kšœ‘
˜K˜K˜—š œžœ
žœ#˜<Kš
œ$™$K˜Kšœ‘,˜8šžœžœ˜#K˜
Kšœžœ˜ Kš
œ˜—Kšœ‘˜K˜—š 	œžœ
žœ˜,Kš
œ0™0K˜šžœ˜šžœ˜K˜K˜
šžœžœ˜2šžœ˜Kš
œ˜K˜
Kšœžœžœžœ˜FKšœžœ˜Kš
œ
˜
—šžœ˜K˜
Kš
œ˜——Kš
œ
˜
—šžœ˜Kšœ
žœ
˜K˜ K˜Kš
œ˜——Kšœ‘˜K˜K˜—Kš
œA™AKš
œP™P˜Kšœ	žœ
žœ
žœžœ
žœ˜%Kšœžœžœ˜<Kšœ	žœžœ˜:K˜Kš	œžœ
žœžœžœ
˜4K˜—š œžœ˜Kšœžœ#˜6Kšžœ)˜+Kšžœ6˜8Kš
œ˜K˜—š 	œžœ˜!Kšžœžœ˜&Kš
œ˜Kšžœ(˜*KšžœO˜QKš
œ˜K˜Kšœ
žœžœ
˜—K˜š
 œžœžœ
žœ
žœ
˜*Kšžœžœ˜$Kš
œ˜Kš
œ'˜'Kš
œ ˜ Kš
œ'˜'Kš
œ ˜ Kšžœ
˜Kš
œ˜K˜—š 	œžœ˜K˜š 	œžœ˜Kš
œ˜Kš
œ˜šžœ
žœ
ž˜Kš
œ-˜-K˜
Kšžœ
˜—Kš
œ˜K˜—š œžœ˜Kšœžœ
˜Kšœžœ˜š
žœ
žœ
žœ
žœ
žœ
žœ
ž˜MKš
œ˜K˜
K˜
Kšžœ
˜—Kš
œ˜K˜Kš
œ:˜:Kš
œ˜Kš
œ˜K˜–1.4 in tabStopsšžœž˜K–1.4 in tabStopsš
œ%˜%K–1.4 in tabStopsš
œ!˜!K–1.4 in tabStopsš
œ#˜#K–1.4 in tabStopsš
œ!˜!K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ#˜#K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ!˜!K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ!˜!K–1.4 in tabStopsš
œ˜K–1.4 in tabStops˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ'˜'K–1.4 in tabStopsš
œ'˜'K–1.4 in tabStopsš
œ'˜'K–1.4 in tabStopsš
œ+˜+K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ$˜$K–1.4 in tabStopsš
œ$˜$K–1.4 in tabStopsš
œ$˜$K–1.4 in tabStopsš
œ$˜$K–1.4 in tabStopsš
œ$˜$K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ"˜"K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsš
œ(˜(K–1.4 in tabStopsšœ(‘
˜2K–1.4 in tabStopsšœžœ
˜K–1.4 in tabStopsšœžœ‘
˜'K–1.4 in tabStopsšœžœ
˜K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsš
œ.˜.K–1.4 in tabStopsš
œ"˜"K–1.4 in tabStopsšœ%‘˜7K–1.4 in tabStopsšœ!‘
˜+K–1.4 in tabStopsš
œ"˜"K–1.4 in tabStopsšœ‘
˜)K–1.4 in tabStopsšœ!‘˜3K–1.4 in tabStopsšœ!‘
˜+K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsšœžœ
˜K–1.4 in tabStopsšœžœ‘˜2K–1.4 in tabStopsšœžœ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsšœ‘˜1K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ(˜(K–1.4 in tabStopsš
œ"˜"K–1.4 in tabStopsš
œ(˜(K–1.4 in tabStopsš
œ"˜"K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsšœžœ
˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsšœ‘
˜(K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsšœž
œ
˜K–1.4 in tabStopsš
œ˜K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsš
œ,˜,K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsš
œ*˜*K–1.4 in tabStopsš
œ"˜"K–1.4 in tabStopsšœ!‘
˜+K–1.4 in tabStopsšœ!‘˜3K–1.4 in tabStopsš
œ ˜ K–1.4 in tabStopsšœ‘
˜)K–1.4 in tabStopsšœ'‘
˜4K–1.4 in tabStopsšœ%‘
˜2K–1.4 in tabStopsšœ‘
˜,K–1.4 in tabStopsšœ‘
˜,K–1.4 in tabStopsšœ!‘
˜.K–1.4 in tabStopsšœ‘
˜,K–1.4 in tabStopsšœ+‘
˜8K–1.4 in tabStopsšœ+‘
˜8K–1.4 in tabStopsšœ‘
˜,K–1.4 in tabStopsšœ%‘
˜2K–1.4 in tabStopsšœ)‘
˜6K–1.4 in tabStopsšœ-‘
˜:K–1.4 in tabStopsšœ)‘
˜6K–1.4 in tabStopsšœ1‘
˜>K–1.4 in tabStopsšœ‘
˜,K–1.4 in tabStopsšžœ˜ —Kš
œ˜—K˜š 	œžœ˜Kšœžœ˜šžœ‘'˜+šžœžœž˜,Kšœžœ
˜šœžœžœž˜3Kšœ#žœ
˜&Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜šžœ˜Kšœžœ˜Kš
žœ
žœžœ
žœ
žœ˜EKš
œ˜Kš
žœ
žœžœ
žœ
žœ˜EKš
œ˜Kšœžœ˜—Kšžœ˜—Kšžœ
˜—Kš
œ˜K˜
Kšžœ
˜—Kš
œ˜K˜Kš
œ˜Kš
œ˜K˜—š œžœ˜šžœ
ž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜š
œ˜K˜	Kšžœžœ˜0Kšžœ˜Kš
œ˜—Kš
œ˜Kš
œ ˜ Kšžœ˜"—K˜
Kš
œ˜K˜—Kš
œ™š
žœžœ
žœžœ
žœžœ
ž˜KK˜
Kšžœ
˜—Kšœžœ˜(K˜Kš
œ™šžœ
ž˜Kšžœ˜Kšžœžœ˜&K˜Kšžœ˜—Kš
œ˜K˜—š
œ
™
š œžœ
žœ˜K˜K˜*K˜&K˜K˜ K˜"K˜K˜K˜,K˜!K˜"K˜K˜&K˜.K˜!K˜6K˜/K˜#K˜K˜K˜K˜(K˜0K˜ K˜<K˜OK˜;K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜Kšœ	ž
œ˜K˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜K˜Kšœ	ž
œ˜K˜Kšœ	ž
œ˜K˜K˜"Kšœ	žœ	˜Kšœ	žœ	˜K˜K˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜K˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜K˜K˜K˜(K˜Kšœžœ	˜!K˜Kšœ	žœ
˜Kšœ	žœ
˜Kšœ	ž
œ˜K˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜K˜"K˜K˜"K˜K˜Kšœ	žœ
˜K˜#Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜Kšœ	ž
œ˜K˜Kšœ	ž
œ˜Kšœ	ž
œ˜K˜K˜K˜&K˜K˜$K˜K˜#K˜K˜—˜K˜——š
œ™š
œ
˜
Kš
žœžœžœžœžœ
˜AKšœžœ
˜#Kšœ žœ
˜&Kšœžœ
˜"Kšœžœ
˜$Kšœžœ
˜ Kšœ!žœ
˜'Kšœžœ
˜$Kšœ žœ
˜&Kšœ!žœ
˜'Kšœžœ
˜$Kšœžœ
˜#Kšœžœ
˜%K˜——K˜Kšžœ
˜K˜K˜—…—rΪ¬€