DIRECTORY
Ascii: TYPE USING [CR, DEL, ESC, NUL, SP],
CommanderOps: TYPE USING [
CommandBlock, CommandBlockHandle, CommandParam, ParamType],
Exec: TYPE,
Frame: TYPE USING [MyLocalFrame],
Inline: TYPE USING [BITAND, BITOR],
PrincOps: TYPE USING [StateVector],
Runtime: TYPE USING [CallDebugger],
Storage: TYPE USING [Node, String, CopyString, Free],
String: TYPE USING [
AppendChar, AppendString, EquivalentString, InvalidNumber,StringBoundsFault],
Time: TYPE USING [AppendCurrent],
TTY: TYPE,
UserTerminal: TYPE;

CommanderImpl: PROGRAM
IMPORTS Exec, Frame, Inline, Runtime, Storage, String, Time, TTY, UserTerminal
EXPORTS CommanderOps = {
OPEN String, CommanderOps, Ascii;

CommandItem: TYPE = RECORD [
cb: CommandBlockHandle, link: POINTER TO CommandItem];

StringItem: TYPE = RECORD [link: POINTER TO StringItem, string: STRING];

commandHead: POINTER TO CommandItem _ NIL;
stringHead: POINTER TO StringItem _ NIL;

SyntaxError: ERROR = CODE;
Help: SIGNAL = CODE;
BadName: ERROR = CODE;
BadParam: ERROR [type: ParamType] = CODE;

GetDebugger: PROC = {Runtime.CallDebugger[NIL]};

ExtensionIs: PROC [name, ext: STRING] RETURNS [BOOL] = {
t: STRING _ [40];
i: CARDINAL;
IF name.length <= ext.length THEN RETURN[FALSE];
FOR i IN [name.length - ext.length..name.length) DO
String.AppendChar[t, name[i]] ENDLOOP;
RETURN [String.EquivalentString[t, ext]]};

CheckForExtension: PROC [name, ext: STRING] = {
i: CARDINAL;
FOR i IN [0..name.length) DO IF name[i] = '. THEN RETURN ENDLOOP;
String.AppendString[name, ext]};

AddCommand: PUBLIC PROC [name: STRING, proc: PROC, numargs: CARDINAL]
RETURNS [CommandBlockHandle] = {
OPEN Storage;
c: POINTER TO CommandItem _ Node[SIZE[CommandItem]];
cb: CommandBlockHandle _ Node[
SIZE[CommandBlock] + numargs*SIZE[CommandParam]];
c^ _ CommandItem[cb: cb, link: commandHead];
commandHead _ c;
cb.name _ name;
cb.proc _ proc;
cb.nparams _ numargs;
RETURN [cb]};

NewString: PROC [s: STRING] RETURNS [ns: STRING] = {
OPEN Storage;
si: POINTER TO StringItem _ Node[SIZE[StringItem]];
si^ _ StringItem[link: stringHead, string: ns _ CopyString[s]];
stringHead _ si;
RETURN};

FreeStrings: PROC = {
OPEN Storage;
next: POINTER TO StringItem;
WHILE stringHead # NIL DO
next _ stringHead.link;
Free[stringHead.string];
Free[stringHead];
stringHead _ next;
ENDLOOP};

WriteEOL: PROC = {IF ~TTY.NewLine[Exec.w] THEN TTY.PutCR[Exec.w]};

firstCommand: BOOL _ TRUE;
interactive: BOOL _ FALSE;

SetupCom: PROC [c: POINTER TO Exec.CommandLine _ @Exec.commandLine] RETURNS [BOOL] =
{RETURN[~(c.s = NIL OR c.i >= c.s.length)]};

SkipToken: PROC [c: POINTER TO Exec.CommandLine _ @Exec.commandLine] = {
foundToken: BOOL _ FALSE;
ch: CHAR;
DO
IF c.i >= c.s.length THEN EXIT;
ch _ c.s[c.i]; c.i _ c.i + 1;
SELECT ch FROM
Ascii.SP, Ascii.CR => IF foundToken THEN EXIT;
ENDCASE => foundToken _ TRUE;
ENDLOOP};


line: STRING _ NIL;
lineTerminator: CHAR;
Lindex: CARDINAL;

AppendStringToLine: PROC [s: STRING] = {
UNTIL (s.length + line.length) <= line.maxlength DO AddToLine[]; ENDLOOP;
AppendString[line, s]};

AppendCharToLine: PROC [c: CHAR] = {
IF line.length = line.maxlength THEN AddToLine[];
AppendChar[line, c]};

ReadUserLine: PROC [newstring: BOOL] = {
IF line = NIL THEN line _ Storage.String[80];
[] _ TTY.GetEditedString[Exec.w, line, LineMonitor, newstring !
resume => {newstring _ FALSE; RETRY}];
Lindex _ 0};

resume: SIGNAL = CODE;

LineMonitor: PROC [c: CHAR] RETURNS [BOOL] = {
SELECT c FROM
CR => RETURN[TRUE];
'? => {
WriteChar['?];
IF line.length = 0 THEN SIGNAL Help;
PromptCompletions[];
SIGNAL resume;
ERROR};
ESC => {ExtendLine[]; SIGNAL resume; ERROR};
ENDCASE => RETURN [FALSE]};

PromptCompletions: PROC = {
id: STRING = [40];
atLeastOne: BOOL _ FALSE;
p: POINTER TO CommandItem;
IF GetLastID[id] THEN
FOR p _ commandHead, p.link UNTIL p = NIL DO
IF PrefixString[prefix: id, of: p.cb.name] THEN {
IF ~atLeastOne THEN WriteEOL[];
WriteChar[SP];
WriteChar[SP];
WriteString[p.cb.name];
atLeastOne _ TRUE};
ENDLOOP;
IF atLeastOne THEN ReTypeLine[] ELSE UserTerminal.BlinkDisplay[]};

ExtendLine: PROC = {
i: CARDINAL;
id: STRING = [40];
match: STRING = [40];
moreThanOne, atLeastOne: BOOL _ FALSE;
p: POINTER TO CommandItem;
IF GetLastID[id] THEN {
FOR p _ commandHead, p.link UNTIL p = NIL DO
IF PrefixString[prefix: id, of: p.cb.name] THEN
IF ~atLeastOne THEN {
AppendString[match, p.cb.name]; atLeastOne _ TRUE}
ELSE {AndString[match, p.cb.name]; moreThanOne _ TRUE};
ENDLOOP};
IF atLeastOne AND id.length # match.length THEN {
FOR i IN [id.length..match.length) DO
AppendCharToLine[match[i]]; WriteChar[match[i]]; ENDLOOP;
IF moreThanOne THEN UserTerminal.BlinkDisplay[]}
ELSE UserTerminal.BlinkDisplay[]};

PrefixString: PROC [prefix, of: STRING] RETURNS [BOOL] = {
IF prefix.length > of.length THEN RETURN[FALSE];
FOR i: CARDINAL IN [0..prefix.length) DO
IF ~EquivalentChar[prefix[i], of[i]] THEN RETURN[FALSE] ENDLOOP;
RETURN [TRUE]};

AndString: PROC [accum, s: STRING] = {
FOR i: CARDINAL IN [0..s.length) DO
IF ~EquivalentChar[accum[i], s[i]] THEN BEGIN accum.length _ i; RETURN END;
ENDLOOP;
accum.length _ s.length};

GetLastID: PROC [id: STRING] RETURNS [BOOL] = {
i, start: CARDINAL;
c: CHAR;
IF line.length = 0 THEN RETURN[FALSE];
start _ line.length;
FOR i DECREASING IN [0..line.length) DO
IF AlphaNumeric[c _ line[i]] THEN start _ i
ELSE IF c = '] OR c = SP THEN EXIT ELSE RETURN[FALSE];
ENDLOOP;
FOR i IN [start..line.length) DO id[i - start] _ line[i] ENDLOOP;
id.length _ line.length - start;
RETURN [id.length # 0]};

AlphaNumeric: PROC [c: CHAR] RETURNS [BOOL] = {
RETURN [Alphabetic[c] OR Digit[c]]};

Alphabetic: PROC [c: CHAR] RETURNS [BOOL] = {
RETURN [Inline.BITAND[c, 337b] IN [100b..132b]]};

Digit: PROC [c: CHAR] RETURNS [BOOL] = {
RETURN [c IN ['0..'9]]};

EquivalentChar: PROC [c, d: CHAR] RETURNS [BOOL] = {
RETURN [Inline.BITOR[c, 40b] = Inline.BITOR[d, 40b]]};

AddToLine: PROC = INLINE {line _ Storage.CopyString[line, 80]};

ReTypeLine: PROC = {WriteEOL[]; WriteString[line]};


command: STRING = [100];
executing: BOOL _ FALSE;
Cindex: CARDINAL;
currentChar: CHAR;

EndOfString: SIGNAL = CODE;

GetChar: PROC RETURNS [CHAR] _ GetCommandChar;

PutBackChar: PROC _ PutBackCommandChar;

GetCommandChar: PROC RETURNS [CHAR] = {
IF Cindex >= command.length THEN currentChar _ NUL
ELSE BEGIN currentChar _ command[Cindex]; Cindex _ Cindex + 1; END;
RETURN [currentChar]};

PutBackCommandChar: PROC = {
IF currentChar = NUL THEN RETURN;
IF Cindex = 0 THEN ERROR;
Cindex _ Cindex - 1};

CommandOverFlow: SIGNAL = CODE;

SetUpCommand: PROC RETURNS [BOOL] = {
BEGIN
ENABLE StringBoundsFault => SIGNAL CommandOverFlow;
RETURN [IF interactive THEN CopyFromLine[] ELSE CopyFromExecCommand[]];
END};

CopyFromLine: PROC RETURNS [BOOL] = {
c: CHAR _ NUL;
DO
IF Lindex >= line.length THEN RETURN [FALSE];
c _ line[Lindex];
Lindex _ Lindex + 1;
IF c # SP AND c # CR THEN EXIT;
ENDLOOP;
command.length _ 0;
DO
AppendChar[command, c];
IF c = '] OR Lindex >= line.length THEN EXIT;
c _ line[Lindex];
Lindex _ Lindex + 1;
ENDLOOP;
Cindex _ 0;
RETURN [TRUE]};

SkipExecBlanks: PROC [c: POINTER TO Exec.CommandLine _ @Exec.commandLine]
RETURNS [ch: CHAR] = {
UNTIL c.i >= c.s.length DO
ch _ c.s[c.i]; c.i _ c.i + 1; IF ch # SP AND ch # CR THEN EXIT;
ENDLOOP};

WriteChar: PROC [ch: CHAR] = {TTY.PutChar[Exec.w, ch]};

WriteString: PROC [s: STRING] = {TTY.PutString[Exec.w, s]};

WriteLine: PROC [s: STRING] = {TTY.PutLine[Exec.w, s]};

EndOf: PROC [c: POINTER TO Exec.CommandLine _ @Exec.commandLine] RETURNS [BOOL] = {
RETURN [c.s = NIL OR c.i >= c.s.length]};

CopyFromExecCommand: PROC [c: POINTER TO Exec.CommandLine _ @Exec.commandLine]
RETURNS [BOOL] = {
ch: CHAR;
IF ~SetupCom[c] THEN {interactive _ TRUE; RETURN [FALSE]};
ch _ SkipExecBlanks[c];
IF EndOf[c] THEN
IF firstCommand THEN {interactive _ TRUE; RETURN [FALSE]}
ELSE SIGNAL CommandExit;
command.length _ 0;
WriteEOL[];
WriteChar['<];
WriteChar['>];
DO
AppendChar[command, ch];
WriteChar[ch];
IF ch = '] OR EndOf[c] THEN EXIT;
ch _ c.s[c.i]; c.i _ c.i + 1;
ENDLOOP;
WriteEOL[];
Cindex _ 0;
RETURN [TRUE]};

GetName: PROC [n: STRING] = {
n.length _ 0;
DO
IF AlphaNumeric[GetChar[]] THEN AppendChar[n, currentChar] ELSE EXIT;
ENDLOOP;
PutBackChar[];
SkipBlanks[];
IF GetChar[] # '[ THEN SE[]};

SkipBlanks: PROC = {
DO IF GetChar[] # SP THEN {PutBackChar[]; RETURN} ENDLOOP};



ParseCommand: PROC [state: POINTER TO PrincOps.StateVector] = {
proc: STRING = [40];
cb: CommandBlockHandle;
i: CARDINAL;
GetName[proc];
cb _ FindProc[proc].cb;
FOR i IN [0..cb.nparams) DO
state.stk[i] _ GetArg[cb, cb.params[i].type];
IF GetChar[] # (IF i = cb.nparams - 1 THEN '] ELSE ',) THEN SE[];
ENDLOOP;
state.dest _ LOOPHOLE[cb.proc];
state.stkptr _ cb.nparams};

FindProc: PROC [name: STRING] RETURNS [p: POINTER TO CommandItem] = {
FOR p _ commandHead, p.link UNTIL p = NIL DO
IF EquivalentString[name, p.cb.name] THEN RETURN; ENDLOOP;
ERROR BadName};

GetArg: PROC [cb: CommandBlockHandle, t: ParamType] RETURNS [a: UNSPECIFIED] = {
s: STRING = [100];
SkipBlanks[];
SELECT GetChar[] FROM
'" => {
IF t # string THEN ERROR BadParam[t];
DO
IF GetChar[] = '" AND GetChar[] # '" THEN {PutBackChar[]; EXIT};
IF executing THEN AppendChar[s, currentChar];
ENDLOOP;
IF executing THEN a _ NewString[s]};
'' => {IF t # character THEN ERROR BadParam[t]; a _ GetChar[]};
IN ['0..'9], '(, '- => {
IF t # numeric THEN ERROR BadParam[t];
PutBackChar[];
a _ ExpressionToNumber[]};
IN ['a..'z], IN ['A..'Z] => {
SELECT t FROM
boolean =>
IF currentChar = 'T THEN a _ GetTRUE[t]
ELSE IF currentChar = 'F THEN a _ GetFALSE[t];
string => {
DO
SELECT currentChar FROM
',, '], CR, NUL => {PutBackChar[]; EXIT};
ENDCASE => IF executing THEN AppendChar[s, currentChar];
[] _ GetChar[];
ENDLOOP;
IF executing THEN a _ NewString[s]};
ENDCASE => ERROR BadParam[t]};
ENDCASE => ERROR BadParam[t];
SkipBlanks[];
RETURN};

GetTRUE: PROC [t: ParamType] RETURNS [BOOL_TRUE] = {
IF GetChar[] # 'R THEN ERROR BadParam[t];
IF GetChar[] # 'U THEN ERROR BadParam[t];
IF GetChar[] # 'E THEN ERROR BadParam[t]};

GetFALSE: PROC [t: ParamType] RETURNS [BOOL_FALSE] = {
IF GetChar[] # 'A THEN ERROR BadParam[t];
IF GetChar[] # 'L THEN ERROR BadParam[t];
IF GetChar[] # 'S THEN ERROR BadParam[t];
IF GetChar[] # 'E THEN ERROR BadParam[t]};



ParsePromptedCommand: PROC = {
proc: STRING = [40];
cb: CommandBlockHandle;
IF GetLastID[proc] THEN {
cb _ FindProc[proc].cb; GetPromptedArgs[cb]; Confirm[]; RETURN};
lineTerminator _ CR};

CRFound: PROC [c: CHAR] RETURNS [BOOL] = {RETURN [c = CR]};

GetPromptedArgs: PROC [cb: CommandBlockHandle] = {
i: CARDINAL;
cindex: CARDINAL;
cstring: STRING = [100];

GetArgChar: PROC RETURNS [c: CHAR] = {
IF cindex >= cstring.length THEN currentChar _ NUL
ELSE BEGIN currentChar _ cstring[cindex]; cindex _ cindex + 1; END;
RETURN [currentChar]};

PutBackArgChar: PROC = {
IF currentChar = NUL THEN RETURN;
IF cindex = 0 THEN ERROR;
cindex _ cindex - 1};

GetChar _ GetArgChar;
PutBackChar _ PutBackArgChar;
AppendCharToLine['[];
FOR i IN [0..cb.nparams) DO
WriteString["\n  "L];
WriteString[cb.params[i].prompt];
WriteChar[':];
WriteChar[' ];
[] _ TTY.GetEditedString[Exec.w, cstring, CRFound, TRUE];
cindex _ 0;
[] _ GetArg[cb, cb.params[i].type];
AppendStringToLine[cstring];
AppendCharToLine[',];
ENDLOOP;
IF cb.nparams # 0 THEN line[line.length - 1] _ '] ELSE AppendCharToLine[']];
GetChar _ GetCommandChar;
PutBackChar _ PutBackCommandChar};

Confirm: PROC = {
char: CHAR;
WriteString[" [confirm]"L];
DO
char _ TTY.GetChar[Exec.w];
SELECT char FROM
DEL => SIGNAL TTY.Rubout;
CR => {WriteEOL[]; EXIT};
SP => {WriteString["\n  <>"L]; EXIT};
ENDCASE => WriteChar['?];
ENDLOOP;
lineTerminator _ char};


symbol: Symbol;
Symbol: TYPE = RECORD [
body: SELECT tag: * FROM
num => [val: INTEGER], delim => [char: CHAR], ENDCASE];
Num: TYPE = num Symbol;

SE: PROC = {ERROR SyntaxError};

Scan: PROC = {
v8, v10, radix, number: CARDINAL;
digits: ARRAY CHAR ['0..'9] OF CARDINAL = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
firstchar: BOOL _ TRUE;
v8 _ v10 _ 0;
SkipBlanks[];
DO
SELECT GetChar[] FROM
IN ['0..'9] => {
v8 _ v8*8 + digits[currentChar];
v10 _ v10*10 + digits[currentChar]};
'M => {
IF ~firstchar THEN SE[];
IF ~(GetChar[] = 'O AND GetChar[] = 'D) THEN SE[];
IF ~Alphabetic[GetChar[]] THEN PutBackChar[] ELSE SE[];
symbol _ [delim['!]];
RETURN};
'b, 'B => {number _ v8; radix _ 8; GOTO exponent};
'd, 'D => {number _ v10; radix _ 10; GOTO exponent};
SP => GOTO done;
NUL => IF ~firstchar THEN GOTO done ELSE {symbol _ nul; RETURN};
'(, '/, '*, '+, '-, '), '], ', =>
IF firstchar THEN {symbol _ [delim[currentChar]]; RETURN}
ELSE {PutBackChar[]; GOTO done};
ENDCASE => SIGNAL InvalidNumber;
firstchar _ FALSE;
REPEAT
done => {symbol _ [num[v10]]; RETURN};
exponent => {
IF firstchar THEN SE[];
v10 _ 0;
WHILE Digit[GetChar[]] DO
v10 _ v10*10 + digits[currentChar];
REPEAT FINISHED => PutBackChar[]; -- took one too many
ENDLOOP;
THROUGH [1..v10] DO number _ number*radix ENDLOOP;
symbol _ [num[number]];
RETURN};
ENDLOOP};

nul: Symbol = [delim[NUL]];

Primary: PROC RETURNS [n: Num] = {
WITH s: symbol SELECT FROM
delim => {
IF s.char # '( THEN SE[];
Scan[];
n _ Exp[];
WITH symbol SELECT FROM
delim => IF char = ') THEN {Scan[]; RETURN};
ENDCASE;
SE[]};
num => {n _ s; Scan[]; RETURN};
ENDCASE};

Factor: PROC RETURNS [n: Num] = {
WITH symbol SELECT FROM
delim =>
IF char = '- THEN {Scan[]; n _ Primary[]; n.val _ -n.val; RETURN};
ENDCASE;
RETURN [Primary[]]};

Product: PROC RETURNS [n: Num] = {
x: Num;
n _ Factor[];
DO
WITH symbol SELECT FROM
delim =>
SELECT char FROM
'* => {Scan[]; n.val _ Factor[].val*n.val};
'/ => {Scan[]; x _ Factor[]; n.val _ n.val/x.val};
'! => {Scan[]; x _ Factor[]; n.val _ n.val MOD x.val};
ENDCASE => EXIT;
ENDCASE => EXIT;
ENDLOOP;
RETURN};

Exp: PROC RETURNS [n: Num] = {
n _ Product[];
DO
WITH symbol SELECT FROM
delim =>
SELECT char FROM
'+ => {Scan[]; n.val _ Product[].val + n.val};
'- => {Scan[]; n.val _ n.val - Product[].val};
'], ', => {PutBackChar[]; EXIT};
NUL, ') => EXIT;
ENDCASE => SE[];
ENDCASE => EXIT;
ENDLOOP;
RETURN};

ExpressionToNumber: PROC RETURNS [INTEGER] = {
Scan[]; RETURN[Exp[].val]};

ShowSE: PROC = {
IF ~executing THEN {WriteChar['?]; RETURN};
WriteEOL[];
IF interactive THEN WriteString[command];
WriteEOL[];
THROUGH [1..(Cindex + (IF interactive THEN 0 ELSE 2))) DO
WriteChar['.]; ENDLOOP;
WriteChar['^]};

Driver: PROC = {
state: --lst-- PrincOps.StateVector;
newline: BOOL;
ci: POINTER TO CommandItem;
i: CARDINAL;
BEGIN
ENABLE {
SyntaxError, InvalidNumber, StringBoundsFault => {
ShowSE[]; GO TO abort};
CommandOverFlow => {
WriteEOL[]; WriteString["Command too long!"L]; GO TO abort};
BadName => {ShowSE[]; WriteString[" not found!"L]; GO TO abort};
BadParam => {
ShowSE[];
WriteString[" expected "L];
SELECT type FROM
string => WriteString["string"L];
character => WriteString["character"L];
numeric => WriteString["numerical"L];
ENDCASE;
WriteString[" parameter"L];
GO TO abort};
TTY.Rubout => {WriteString[" XXX"L]; GO TO abort};
Help => {
WriteEOL[];
FOR ci _ commandHead, ci.link UNTIL ci = NIL DO
WriteString[ci.cb.name];
WriteChar['[];
FOR i IN [0..ci.cb.nparams) DO
IF i # 0 THEN WriteChar[',];
SELECT ci.cb.params[i].type FROM
string => WriteChar['"];
character => WriteChar[''];
ENDCASE;
WriteString[ci.cb.params[i].prompt];
SELECT ci.cb.params[i].type FROM string => WriteChar['"]; ENDCASE;
ENDLOOP;
WriteChar[']];
IF ci.link # NIL THEN BEGIN WriteChar[',]; WriteChar[' ]; END;
ENDLOOP;
GO TO abort};
UNWIND => FreeStrings[]};
newline _ TRUE;
executing _ FALSE;
IF interactive THEN {
WriteEOL[];
WriteChar['<];
WriteChar['>];
DO
ENABLE StringBoundsFault => {AddToLine[]; RESUME [line]};
ReadUserLine[newline];
newline _ FALSE;
ParsePromptedCommand[];
IF lineTerminator = CR THEN EXIT;
ENDLOOP};
GetChar _ GetCommandChar;
PutBackChar _ PutBackCommandChar;
executing _ TRUE;
WHILE SetUpCommand[] DO
ParseCommand[@state];
state.instbyte _ 0;
state.source _ LOOPHOLE[Frame.MyLocalFrame[]];
firstCommand _ FALSE;
TRANSFER WITH state;
state _ STATE;
ENDLOOP;
executing _ FALSE;
EXITS abort => NULL;
END;
FreeStrings[]};

Quit: PROC = {SIGNAL CommandExit};

WriteHerald: PROC = {
time: STRING _ [22];
WriteEOL[];
IF h # NIL THEN WriteLine[h];
Time.AppendCurrent[time];
time.length _ time.length - 3;
WriteLine[time]};

h: STRING _ NIL;

InitCommander: PUBLIC PROC [herald: STRING] = {
h _ herald;
[] _ AddCommand["Quit", Quit, 0];
[] _ AddCommand["Debug", GetDebugger, 0]};

CommandExit: SIGNAL = CODE;

WaitCommands: PUBLIC PROC = {
IF h = NIL THEN InitCommander[NIL];
executing _ interactive _ FALSE;
firstCommand _ TRUE;
WriteHerald[];
DO Driver[ ! CommandExit => EXIT]; ENDLOOP};


}.



CommandLine ::= PromptedCommandList <CR> | NonPromptedCommandList ;
NonPromptedCommandList <EOF>
PromptedCommandList ::= PromptedCommand | Command | CommandList <SP> Command
| CommandList <SP> PromptedCommand
NonPromptedCommandList ::= Command | CommandList <SP> Command
Command ::= ID [ ParamList ]
PromptedCommand ::= ID <CR> PromptedParamList
ParamList ::= Param | ParamList , Param
PromptedParamList ::= Param | PromptedParamList <CR> Param
Param ::= " STRING " | ' CHAR | Expression | <empty>
Expression ::= Product | Expression + Product | Expression - Product
Product ::= Factor | Product * Factor | Product / Factor | Product MOD Factor
Factor ::= - Primary | Primary
Primary ::= NUM | ( Expression )


úfile CommanderImpl.mesa
edited by Johnsson,  9-Sep-80 20:35:49
edited by Sweet, 20-Apr-81 14:44:22
edited by Bruce, 10-Jan-81 15:32:29
edited by Satterthwaite, September 20, 1982 1:33 pm
code to get a line from the user, handling ESC and ?; stuffs it in line
read line from user; also handles <ESC> and '? for input from user
code to handle characters
code to parse user command
code to parse user commands in interactive mode
parsing arithmetic expressions
Here is the grammar for the command line
�Ê©˜Jš
œ™Jš
œ&™&Jš
œ#™#Jš
œ#™#Jš
œ3™3J˜š
Ïk	˜	Jšœ�œ
�œ�œ�œ�œ�œ�œ˜*šœ�œ
�œ˜J˜;—Jšœ�œ
˜Jšœ�œ
�œ˜!Jš	œ�œ
�œ�œ�œ˜#Jšœ
�œ
�œ˜#Jšœ	�œ
�œ˜#Jšœ	�œ
�œ"˜5šœ�œ
�œ˜J˜M—Jšœ�œ
�œ˜!Jš�œ�œ
˜
Jšœ�œ
˜J˜—šœ�˜Jš�œ6�œ˜NJš�œ˜Jš�œ˜!J˜šœ
�œ�œ˜Jšœ�œ
�œ˜6J˜—Jšœ�œ�œ�œ
�œ�œ˜HJ˜Jšœ
�œ
�œ�œ
˜*Jšœ�œ
�œ�œ
˜(J˜Jšœ
�œ�œ
˜Jšœ�œ�œ
˜Jšœ	�œ�œ
˜Jšœ
�œ�œ
˜)J˜JšÏnœ�œ�œ˜0J˜š
žœ�œ
�œ�œ�œ˜8Jšœ�œ˜Jšœ�œ
˜Jš�œ�œ
�œ
�œ˜0š�œ�œ)�˜3Jšœ�œ
˜&—Jš�œ$˜*J˜—šžœ�œ
�œ˜/Jšœ�œ
˜Jš�œ�œ�œ
�œ�œ
�œ
�œ
˜AJ˜ J˜—šž
œ�œ
�œ�œ�œ�œ
˜EJš�œ˜ Jš�œ	˜
Jšœ�œ
�œ�œ˜4˜Jš�œ�œ˜1—J˜,J˜J˜J˜J˜Jš�œ˜
J˜—š
ž	œ�œ�œ�œ�œ˜4Jš�œ	˜
Jšœ�œ
�œ�œ˜3J˜?J˜Jš�œ˜J˜—šžœ�œ˜Jš�œ	˜
Jšœ�œ
�œ˜š�œ�œ
�˜J˜J˜J˜J˜Jš�œ˜	J˜——Jšžœ�œ�œ�œ�œ
�œ˜BJ˜Jšœ�œ�œ
˜Jšœ
�œ�œ
˜J˜šžœ�œ�œ
�œ'�œ�œ˜TJšœ
�œ	�œ
�œ˜,J˜—šž	œ�œ�œ
�œ*˜HJšœ�œ�œ
˜Jšœ�œ
˜	š
�˜Jš�œ�œ
�œ
˜J˜š�œ�˜Jšœ�œ�œ�œ�œ
�œ
˜.Jš�œ�œ
˜—Jš�œ˜	J˜——Jš
œG™GJ˜Jšœ�œ�œ
˜Jšœ�œ
˜Jšœ�œ
˜J˜šžœ�œ�œ˜(Jš�œ,�œ�œ
˜IJ˜J˜—šžœ�œ�œ˜$Jš�œ�œ
˜1J˜J˜—šžœ�œ
�œ˜(Jš
œB™BJš�œ�œ
�œ˜-šœ�œ7˜?Jšœ�œ�œ˜&—J˜J˜—Jšœ�œ�œ
˜J˜š
žœ�œ�œ�œ�œ˜.š�œ�˜
Jš�œ�œ
�œ˜˜J˜Jš�œ�œ
�œ˜$J˜Jš�œ˜Jš�œ˜—Jš�œ�œ	�œ˜,Jš�œ�œ�œ˜J˜——šžœ�œ˜Jšœ�œ˜Jšœ�œ�œ
˜Jšœ�œ
�œ
˜š�œ�˜š�œ�œ�œ
�˜,š�œ)�œ˜1Jš�œ
�œ˜Jšœ
�œ˜Jšœ
�œ˜J˜Jšœ
�œ˜—Jš�œ
˜——Jš�œ�œ�œ˜BJ˜—šž
œ�œ˜Jšœ�œ
˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ�œ
˜&Jšœ�œ
�œ
˜š�œ�œ˜š�œ�œ�œ
�˜,š�œ)�˜/š�œ
�œ˜Jšœ-�œ
˜2—Jš�œ-�œ˜7—Jš�œ˜	——š�œ�œ�œ˜1š�œ�œ�˜%Jšœ1�œ
˜9—Jš�œ
�œ˜0—Jš�œ˜"J˜—š
žœ�œ�œ�œ�œ˜:Jš�œ�œ
�œ
�œ˜0š�œ�œ
�œ�˜(Jš
�œ#�œ
�œ
�œ�œ
˜@—Jš�œ�œ˜J˜—šž	œ�œ�œ˜&š�œ�œ
�œ�˜#Jš
�œ!�œ
�œ�œ
�œ
˜KJš�œ
˜—J˜J˜—š
ž	œ�œ�œ�œ�œ˜/Jšœ
�œ
˜Jšœ�œ
˜Jš�œ�œ
�œ
�œ˜&J˜š�œ�
œ
�œ�˜'Jš�œ�œ
˜+Jš�œ
�œ�œ�œ
�œ
�œ
�œ
�œ
�œ˜6Jš�œ
˜—Jš�œ�œ�œ�œ
˜AJ˜ Jš�œ˜J˜—š
žœ�œ�œ�œ�œ˜/Jš�œ�œ˜$J˜—š
ž
œ�œ�œ�œ�œ˜-Jš�œ	�œ
�œ˜1J˜—š
žœ�œ�œ�œ�œ˜(Jš�œ�œ˜J˜—š
žœ�œ�œ�œ�œ˜4Jš�œ	�œ�œ˜6J˜—Jšž	œ�œ�œ'˜?J˜Jšž
œ�œ#˜3J˜Jš
œ™J˜Jšœ	�œ	˜Jšœ�œ�œ
˜Jšœ�œ
˜Jšœ
�œ
˜J˜Jšœ
�œ�œ
˜J˜Jšžœ�œ
�œ�œ˜.J˜Jšžœ�œ˜'J˜šžœ�œ
�œ�œ˜'Jš�œ�œ�˜2Jš�œ
�œ5�œ
˜CJš�œ˜J˜—šžœ�œ˜Jš�œ�œ
�œ
�œ
˜!Jš�œ�œ
�œ
˜J˜J˜—Jšœ�œ�œ
˜J˜šžœ�œ
�œ�œ˜%Jš
�˜Jš�œ�œ˜3Jš�œ�œ
�œ�œ˜GJš�œ˜J˜—šžœ�œ
�œ�œ˜%Jšœ�œ�œ
˜š
�˜Jš�œ�œ
�œ�œ˜-J˜J˜Jš�œ�œ
�œ�œ
�œ
�œ
˜Jš�œ
˜—J˜š
�˜J˜Jš�œ�œ�œ
�œ
˜-J˜J˜Jš�œ
˜—J˜Jš�œ�œ˜J˜—šžœ�œ�œ
�œ&˜IJš�œ�œ˜š�œ�˜Jš
œ�œ�œ
�œ�œ
�œ
�œ
˜?Jš�œ˜	J˜——Jšž	œ�œ�œ�œ˜7J˜Jšžœ�œ�œ�œ˜;J˜Jšž	œ�œ�œ�œ˜7J˜šžœ�œ�œ
�œ'�œ�œ˜SJš�œ�œ
�œ˜)J˜—šžœ�œ�œ
�œ&˜NJš�œ�œ˜Jšœ�œ
˜	Jš
�œ�œ�œ�œ�œ˜:J˜š�œ
�˜Jš
�œ�œ�œ�œ�œ˜9Jš�œ
�œ
˜—J˜J˜J˜J˜š
�˜J˜J˜Jš�œ	�œ
�œ
�œ
˜!J˜Jš�œ
˜—J˜J˜Jš�œ�œ˜J˜—šžœ�œ�œ˜J˜
š
�˜Jš�œ�œ�œ
�œ
˜EJš�œ
˜—J˜J˜
Jš�œ�œ
�œ˜J˜—šž
œ�œ˜Jš�œ
�œ
�œ
�œ�œ�œ˜;J˜—Jš
œ™J˜J˜šžœ�œ	�œ
�œ˜?Jšœ�œ˜J˜Jšœ�œ
˜J˜J˜š�œ�œ�˜J˜-Jš�œ�œ�œ�œ�œ
�œ˜AJš�œ
˜—Jšœ
�œ
˜J˜J˜—šžœ�œ�œ�œ�œ
�œ˜Eš�œ�œ�œ
�˜,Jš�œ#�œ
�œ�œ
˜:—Jš�œ
˜J˜—šžœ�œ(�œ�œ˜PJšœ�œ	˜J˜
š�œ�˜˜Jš�œ�œ
�œ
˜%š
�˜Jš�œ�œ�œ�œ˜@Jš�œ�œ˜-Jš�œ
˜—Jš�œ�œ˜$—Jšœ�œ�œ
�œ˜?š�œ˜Jš�œ
�œ
�œ
˜&J˜J˜—š�œ�œ˜š�œ�˜
˜
Jš�œ�œ˜'Jš�œ
�œ�œ˜.—˜š
�˜š�œ
�˜Jšœ�œ�œ�œ˜)Jš�œ�œ�œ˜8—J˜Jš�œ
˜—Jš�œ�œ˜$—Jš�œ�œ˜——Jš�œ�œ
˜—J˜
Jš�œ˜J˜—š
žœ�œ�œ�œ
�œ˜4Jš�œ�œ
�œ
˜)Jš�œ�œ
�œ
˜)Jš�œ�œ
�œ˜*J˜—š
žœ�œ�œ�œ
�œ˜6Jš�œ�œ
�œ
˜)Jš�œ�œ
�œ
˜)Jš�œ�œ
�œ
˜)Jš�œ�œ
�œ˜*J˜—Jš
œ/™/J˜J˜šžœ�œ˜Jšœ�œ˜J˜š�œ�œ˜Jšœ8�œ˜@—Jšœ�œ˜J˜—Jšžœ�œ�œ�œ�œ�œ�œ˜;J˜šžœ�œ˜2Jšœ�œ
˜Jšœ�œ
˜Jšœ	�œ	˜J˜šž
œ�œ
�œ�œ˜&Jš�œ�œ�˜2Jš�œ
�œ5�œ
˜CJš�œ˜J˜—šžœ�œ˜Jš�œ�œ
�œ
�œ
˜!Jš�œ�œ
�œ
˜J˜J˜—J˜J˜J˜š�œ�œ�˜J˜J˜!J˜J˜Jšœ�œ+�œ˜9J˜J˜#J˜J˜Jš�œ
˜—Jš�œ�œ�œ˜LJ˜J˜"J˜—šžœ�œ˜Jšœ�œ
˜J˜š
�˜Jšœ�œ˜š�œ�˜Jš�œ�œ
�œ˜Jš�œ�œ˜Jš�œ�œ˜%Jš�œ˜—Jš�œ
˜—J˜J˜—Jš
œ™J˜J˜šœ�œ�œ˜šœ�œ�˜Jšœ
�œ�œ�œ˜7——Jšœ�œ˜J˜Jš�œ�œ�œ˜J˜šžœ�œ˜Jšœ�œ
˜!Jš	œ�œ
�œ
�œ
�œ"˜IJšœ�œ�œ
˜J˜
J˜
š
�˜š�œ�˜š�œ˜J˜ J˜$—˜Jš�œ�œ
�œ˜Jš�œ�œ�œ
�œ˜2Jš�œ�œ�œ
�œ˜7J˜Jš�œ˜—Jšœ#�œ˜2Jšœ%�œ˜4Jš�œ�œ˜Jš�œ�œ�œ
�œ�œ�œ˜@˜!Jš�œ�œ!�œ
˜9Jš�œ�œ˜ —Jš�œ�œ˜ —Jšœ�œ
˜š
�˜Jšœ�œ˜&˜
Jš�œ�œ
�œ˜J˜š�œ�˜J˜#Jš�œ
�œÏc˜6Jš�œ
˜—Jš�œ
�œ�œ
˜2J˜Jš�œ˜——Jš�œ˜	J˜——Jšœ�œ˜J˜šžœ�œ
�œ
˜"š�œ�œ
�˜˜
Jš�œ
�œ
�œ˜J˜J˜
š�œ�œ
�˜Jšœ	�œ�œ
�œ˜,Jš�œ
˜—Jš�œ˜—Jšœ�œ˜Jš�œ˜	J˜——šžœ�œ
�œ
˜!š�œ�œ
�˜˜Jš�œ�œ)�œ˜B—Jš�œ
˜—Jš�œ˜J˜—šžœ�œ
�œ
˜"J˜J˜
š
�˜š�œ�œ
�˜˜š�œ�˜J˜+J˜2Jšœ+�œ˜6Jš�œ�œ
˜——Jš�œ�œ
˜—Jš�œ
˜—Jš�œ˜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š
�˜š�œ˜˜2Jšœ
�œ
�œ˜—˜Jšœ/�œ
�œ˜<—Jšœ3�œ
�œ˜@˜
J˜	J˜š�œ�˜J˜!J˜'J˜%Jš�œ
˜—J˜Jš�œ
�œ˜
—Jš�œ"�œ
�œ˜2˜	J˜š�œ�œ�œ
�˜/J˜J˜š�œ�œ�˜Jš�œ�œ˜š�œ�˜ J˜J˜Jš�œ
˜—J˜$Jš�œ�œ�œ
˜BJš�œ
˜—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š�œ
˜J˜J˜—Jšžœ�œ�œ˜"J˜šžœ�œ˜Jšœ�œ˜J˜Jš�œ�œ
�œ˜J˜J˜J˜J˜—Jšœ�œ�œ
˜J˜šž
œ�œ
�œ
�œ˜/J˜J˜!J˜*J˜—Jšœ
�œ�œ
˜J˜šžœ�œ
�œ˜Jš�œ�œ
�œ�œ˜#Jšœ�œ
˜ Jšœ�œ
˜J˜Jš�œ�œ�œ˜,J˜J˜—J˜J˜J˜—Jš
œ(™(J˜šœ%�œ˜CJšœ�œ
˜—šœA�œ	˜LJšœ�œ˜"—Jšœ2�œ	˜=Jšœ�œ˜Jšœ�œ�œ˜-J˜'Jšœ1�œ˜:Jšœ�œ˜4J˜DJšœC�œ˜MJ˜Jšœ�œ˜ J˜—…—C€a#