-- file Pass1T.mesa rewritten by PGS, 12-May-83 14:22
-- file Pass1T.mesa rewritten by PGS, 2-May-83 9:07
-- last modified by Satterthwaite, May 2, 1983 9:06 am
-- last modified by Donahue, 9-Dec-81 10:48:31
DIRECTORY
ComData: TYPE USING [idANY, idINT, idLOCK],
ParseTable: TYPE USING [ActionEntry, ProdDataRef, TSymbol],
P1: TYPE USING [
ActionStack, LinkStack, Value, ValueStack, nullValue,
InputLoc, IdOfFirst, IdOfLock, IdOfRest],
Symbols: TYPE USING [Name, nullName],
Tree: TYPE USING [AttrId, Link, Map, NodeName, Null],
TreeOps: TYPE USING [
FreeTree, ListLength, MakeNode, ExtractTree, InsertTree, OpName,
PopTree, PushTree, PushHash, PushList, PushLit, PushProperList, PushSe,
PushNode, SetAttr, SetInfo, UpdateList];
Pass1T: PROGRAM
IMPORTS P1, TreeOps, dataPtr: ComData
EXPORTS P1 = {
-- parse tree building
OPEN TreeOps;
Op: TYPE = Tree.NodeName;
-- local data base (supplied by parser)
v: P1.ValueStack;
l: P1.LinkStack;
q: P1.ActionStack;
prodData: ParseTable.ProdDataRef;
-- initialization/termination
AssignDescriptors: PUBLIC PROC [
qd: P1.ActionStack, vd: P1.ValueStack, ld: P1.LinkStack,
pp: ParseTable.ProdDataRef] = {
q ← qd; v ← vd; l ← ld; prodData ← pp};
-- error recovery (only)
TokenValue: PUBLIC PROC [s: ParseTable.TSymbol] RETURNS [P1.Value] = {
RETURN [P1.nullValue]};
-- stack manipulation
-- note that r and s may be overlaid in some parameterizations
PushHashV: PROC [k: NAT] = {PushHash[v[k].r]};
PushLitV: PROC [k: NAT] = {PushLit[v[k].r]};
PushNodeV: PROC [k: NAT, count: INTEGER] = {PushNode[v[k].s, count]};
PushListV: PROC [k: NAT] = {PushList[v[k].s]};
PushProperListV: PROC [k: NAT] = {PushProperList[v[k].s]};
SetAttrV: PROC [attr: Tree.AttrId, k: NAT] = {SetAttr[attr, v[k].s]};
SetAttrs: PROC [attr1, attr2, attr3: BOOL ← FALSE] = {
SetAttr[1,attr1]; SetAttr[2,attr2]; SetAttr[3,attr3]};
-- value manipulation
BoolV: PROC [k: NAT] RETURNS [BOOL] = {RETURN [v[k].s]};
SetBoolV: PROC [k: NAT, b: BOOL] = {v[k].s ← b};
OpV: PROC [k: NAT] RETURNS [Op] = {RETURN [v[k].s]};
SetOpV: PROC [k: NAT, op: Op] = {v[k].s ← op};
NegatedV: PROC [k: NAT] RETURNS [Op] = {
op: Op = v[k].s;
RETURN [SELECT op FROM
relE => relN, relN => relE,
relL => relGE, relGE => relL,
relG => relLE, relLE => relG,
in => notin, notin => in,
ENDCASE => op]};
-- shared processing routines
DetachItem: Tree.Map = {PushTree[t]; RETURN [Tree.Null]};
AnonField: PROC [type, default: Tree.Link, top: CARDINAL] = {
PushField[Symbols.nullName, type, default, top]};
PushField: PROC [id: Symbols.Name, type, default: Tree.Link, top: CARDINAL] = {
PushHash[id]; PushTree[type]; PushTree[default];
PushNode[decl,3]; LinkToSource[top];
SetAttrs[FALSE,public,FALSE]};
-- the interpretation rules
LinkToSource: PROC [index: CARDINAL] = {SetInfo[l[index]]};
-- propagated attributes
public: BOOL;
machineDep: BOOL;
trusted, checked: BOOL;
safety: BOOL;
ProcessQueue: PUBLIC PROC [qI, top: CARDINAL] = {
t1, t2: Tree.Link;
FOR i: CARDINAL IN [0..qI) DO
top ← top-q[i].tag.pLength+1;
SELECT prodData[q[i].transition].rule FROM
-- basic tree building
0 => -- TABLE: MesaTab TYPE: ParseTable EXPORTS: CBinary
-- GOAL: goal
--TERMINALS:
-- id num lnum flnum string lstring char atom
-- , ; : .. => ←
-- = # < > <= >= ~
-- + - * / ↑ . @ ! '|
-- RECORD POINTER REF VAR
-- LIST ARRAY SEQUENCE DESCRIPTOR
-- PROCEDURE PROC PORT SIGNAL ERROR PROCESS
-- PROGRAM MONITOR DEFINITIONS ZONE RELATIVE LONG
-- TYPE FRAME TO ORDERED UNCOUNTED PAINTED
-- BASE OF PACKED RETURNS SAFE UNSAFE
-- MONITORED OVERLAID COMPUTED MACHINE DEPENDENT
-- DIRECTORY IMPORTS EXPORTS SHARES LOCKS USING
-- PUBLIC PRIVATE CEDAR CHECKED TRUSTED UNCHECKED
-- ENTRY INTERNAL INLINE READONLY CODE
-- ABS ALL AND APPLY CONS MAX MIN MOD
-- NOT OR ORD PRED LENGTH NEW START SUCC VAL
-- FORK JOIN LOOPHOLE NARROW ISTYPE SIZE
-- FIRST LAST NIL TRASH NULL IF THEN ELSE
-- WITH FROM FOR DECREASING IN
-- THROUGH UNTIL WHILE REPEAT FINISHED
-- RETURN EXIT LOOP GOTO GO
-- FREE WAIT RESTART NOTIFY BROADCAST STOP
-- RESUME REJECT CONTINUE RETRY TRANSFER STATE
-- OPEN ENABLE ANY EXITS
-- ) ] } END ENDLOOP ENDCASE
-- ( [ { BEGIN DO SELECT
--ALIASES:
-- id tokenID
-- num tokenNUM
-- lnum tokenLNUM
-- flnum tokenFLNUM
-- string tokenSTR
-- lstring tokenLSTR
-- char tokenCHAR
-- atom tokenATOM
-- - tokenMINUS
-- . tokenDOT
-- .. tokenDOTS
-- = tokenEQUAL
-- => tokenARROW
-- < tokenLESS
-- <= tokenLE
-- > tokenGREATER
-- >= tokenGE
-- # tokenNE
-- ~ tokenTILDE
-- . initialSymbol
--PRODUCTIONS:
-- goal ::= . module .
-- goal ::= . module ..
NULL;
1 => -- module ::= directory identlist cedar proghead trusted checked block
BEGIN
IF ~BoolV[top+6] THEN InsertTree[Tree.Null,2];
PushTree[Tree.Null];
t1 ← MakeNode[body,4];
t2 ← ExtractTree[2];
PushTree[ExtractTree[5]]; PushTree[t2];
PushTree[t1]; SetAttr[1,checked]; SetAttr[2,trusted];
trusted ← BoolV[top+4]; checked ← BoolV[top+5];
PushNode[decl,3]; LinkToSource[top+1];
SetAttrs[TRUE,TRUE,FALSE];
PushNode[module,6]; LinkToSource[top]; SetAttrV[1,top+3];
END;
2 => -- module ::= directory identlist cedar defhead defbody
BEGIN
IF ~BoolV[top+4] THEN InsertTree[Tree.Null,2];
PushTree[Tree.Null];
t1 ← MakeNode[body,4]; t2 ← ExtractTree[2];
PushTree[ExtractTree[5]]; PushTree[t2]; PushTree[t1];
PushNode[decl,3]; LinkToSource[top+1];
SetAttrs[TRUE,TRUE,FALSE];
PushNode[module,6]; LinkToSource[top]; SetAttrV[1,top+3];
END;
3 => -- includeitem ::= id : FROM string using
BEGIN
PushLitV[top+3]; PushHashV[top];
PushNode[diritem,-3]; LinkToSource[top];
END;
4 => -- includeitem ::= id : TYPE using
-- includeitem ::= id using
BEGIN
PushTree[Tree.Null]; PushHashV[top];
PushNode[diritem,-3]; LinkToSource[top];
END;
5 => -- includeitem ::= id : TYPE id using
BEGIN
PushHashV[top+3]; PushHashV[top];
PushNode[diritem,-3]; LinkToSource[top];
END;
6 => -- cedar ::= CEDAR
safety ← trusted ← checked ← TRUE;
7 => -- cedar ::=
safety ← trusted ← checked ← FALSE;
8 => -- proghead ::= resident safe class arguments locks interface tilde public
BEGIN
t1 ← ExtractTree[4];
PushTree[ExtractTree[5]]; PushTree[ExtractTree[5]];
PushNode[programTC,2]; SetAttrV[1,top+2]; SetAttrV[3,top+1];
IF ~BoolV[top+2] OR t1 # Tree.Null THEN PushTree[t1]
ELSE {
PushHash[P1.IdOfLock[]]; PushTree[Tree.Null];
PushNode[lambda,-2]; SetAttr[1,TRUE]; SetAttr[2,public]};
machineDep ← FALSE;
END;
9 => -- resident ::=
{public ← FALSE; SetBoolV[top,FALSE]; l[top] ← P1.InputLoc[]};
10 => -- defhead ::= definitions locks imports shares tilde public
BEGIN
t1 ← ExtractTree[3];
t2 ← PopTree[]; PushTree[Tree.Null]; PushTree[t2];
PushNode[definitionTC,0]; PushTree[t1];
SetBoolV[top,FALSE]; machineDep ← FALSE;
END;
11 => -- definitions ::= DEFINITIONS
public ← TRUE;
12 => -- defbody ::= BEGIN open declist END
-- defbody ::= BEGIN open declist ; END
-- defbody ::= { open declist }
-- defbody ::= { open declist ; }
{PushListV[top+2]; PushTree[Tree.Null]; SetBoolV[top,TRUE]};
13 => -- locks ::= LOCKS primary lambda
{PushNode[lambda,-2]; SetAttr[1,FALSE]; SetAttr[2,FALSE]};
14 => -- lambda ::= USING ident typeexp
BEGIN
PushTree[Tree.Null]; PushNode[decl,3]; LinkToSource[top+1];
SetAttrs[FALSE,FALSE,FALSE];
END;
15 => -- moduleitem ::= id
BEGIN
PushHashV[top]; PushHashV[top];
PushNode[item,2]; SetAttr[1,FALSE]; LinkToSource[top];
END;
16 => -- moduleitem ::= id : id
BEGIN
PushHashV[top]; PushHashV[top+2];
PushNode[item,2]; SetAttr[1,TRUE]; LinkToSource[top];
END;
17 => -- declaration ::= identlist public entry readonly typeexp initialization
BEGIN
IF BoolV[top+3] THEN {
t1 ← PopTree[];
PushNode[varTC,1]; SetAttrs[FALSE,FALSE,TRUE];
PushTree[t1]};
IF OpV[top+2] # none THEN PushNodeV[top+2,1];
PushNode[decl,3]; LinkToSource[top];
SetAttrV[1,top+5]; SetAttr[2,public]; public ← BoolV[top+1];
END;
18 => -- declaration ::= identlist public TYPE tilde public typeexp default
BEGIN
public ← BoolV[top+4];
PushNode[typedecl,3]; LinkToSource[top];
SetAttrs[TRUE,public,FALSE]; public ← BoolV[top+1];
END;
19 => -- declaration ::= identlist public TYPE optsize
BEGIN
PushNode[opaqueTC,1]; PushTree[Tree.Null];
PushNode[typedecl,3]; LinkToSource[top];
SetAttrs[TRUE,public,FALSE]; public ← BoolV[top+1];
END;
20 => -- public ::= PUBLIC
{SetBoolV[top,public]; public ← TRUE};
21 => -- public ::= PRIVATE
-- procaccess ::=
{SetBoolV[top, public]; public ← FALSE};
22 => -- public ::=
SetBoolV[top,public];
23 => -- entry ::= ENTRY
SetOpV[top,entry];
24 => -- entry ::= INTERNAL
SetOpV[top,internal];
25 => -- entry ::=
{SetOpV[top,none]; l[top] ← P1.InputLoc[]};
26 => -- idlist' ::= id
-- identlist' ::= id :
{PushHashV[top]; v[top].s ← -1};
27 => -- identlist' ::= id position :
{PushHashV[top]; PushNode[item,-2]; v[top].s ← -1};
28 => -- idlist' ::= id , idlist'
-- identlist' ::= id , identlist'
{PushHashV[top]; v[top].s ← v[top+2].s-1};
29 => -- identlist' ::= id position , identlist'
BEGIN
PushTree[ExtractTree[-(v[top+3].s-1)]];
PushHashV[top]; PushNode[item,-2]; v[top].s ← v[top+3].s-1;
END;
30 => -- position ::= ( exp optbits )
PushNode[item,2];
31 => -- optbits ::= : bounds
-- interval ::= [ bounds ]
PushNode[intCC,2];
32 => -- interval ::= [ bounds )
PushNode[intCO,2];
33 => -- interval ::= ( bounds ]
PushNode[intOC,2];
34 => -- interval ::= ( bounds )
PushNode[intOO,2];
35 => -- typeexp ::= id
-- range ::= id
PushHashV[top];
36 => -- typeid' ::= id . id
{PushHashV[top]; PushHashV[top+2]; PushNode[dot,2]};
37 => -- typeid' ::= typeid' . id
-- typeappl ::= typeappl . id
{PushHashV[top+2]; PushNode[dot,2]};
38 => -- typeid ::= id id
{PushHashV[top+1]; PushHashV[top]; PushNode[dot,2]};
39 => -- typeid ::= id typeid
{PushHashV[top]; PushNode[dot,2]};
40 => -- typeappl ::= id length
{PushHashV[top]; PushNode[apply,-2]};
41 => -- typeappl ::= typeid length
-- typeappl ::= typeappl length
PushNode[apply,2];
42 => -- typecons ::= interval
{PushSe[dataPtr.idINT]; PushNode[subrangeTC,-2]};
43 => -- typecons ::= id interval
-- range ::= id interval
{PushHashV[top]; PushNode[subrangeTC,-2]};
44 => -- typecons ::= typeid interval
-- range ::= typeid interval
PushNode[subrangeTC,2];
45 => -- typecons ::= dependent { elementlist }
BEGIN
PushListV[top+2];
PushNode[enumeratedTC,1]; SetAttr[1,public]; SetAttr[2,machineDep];
machineDep ← BoolV[top];
END;
46 => -- ident ::= id position :
-- element ::= id ( exp )
{PushHashV[top]; PushNode[item,-2]};
47 => -- element ::= ( exp )
{PushHash[Symbols.nullName]; PushNode[item,-2]};
48 => -- typecons ::= dependent monitored RECORD reclist
BEGIN
IF ~BoolV[top+1] THEN PushNode[recordTC,1]
ELSE {
t1 ← PopTree[]; v[top+2].s ← ListLength[t1];
t1 ← UpdateList[t1,DetachItem]; t1 ← FreeTree[t1];
PushList[v[top+2].s+1]; PushNode[monitoredTC,1]};
SetAttr[1,machineDep]; SetAttrV[2,top+3]; machineDep ← BoolV[top];
SetAttr[3,TRUE];
END;
49 => -- typecons ::= ordered base pointertype
BEGIN
t2 ← MakeNode[pointerTC,1];
t1 ← PopTree[];
PushTree[t2];
SetAttrV[1,top]; SetAttrV[2,top+1]; SetAttrV[3,top+2];
IF t1 # Tree.Null THEN {PushTree[t1]; PushNode[subrangeTC,2]};
END;
50 => -- typecons ::= VAR typeexp
{PushNode[varTC,1]; SetAttrs[FALSE,FALSE,FALSE]};
51 => -- typecons ::= REF readonly typeexp
BEGIN
PushNode[refTC,1];
SetAttr[1,FALSE]; SetAttr[2,FALSE]; SetAttrV[3,top+1];
PushNode[longTC,1];
END;
52 => -- typecons ::= REF readonly ANY
BEGIN
PushNode[anyTC, 0]; PushNode[refTC,1];
SetAttr[1,FALSE]; SetAttr[2,FALSE]; SetAttrV[3,top+1];
PushNode[longTC,1];
END;
53 => -- typecons ::= REF
BEGIN
PushNode[anyTC, 0]; PushNode[refTC,1];
SetAttrs[FALSE,FALSE,FALSE];
PushNode[longTC,1];
END;
54 => -- typecons ::= LIST OF readonly typeexp
BEGIN
PushField[P1.IdOfFirst[], PopTree[], Tree.Null, top];
PushField[P1.IdOfRest[], MakeNode[linkTC,0], Tree.Null, top];
PushList[2];
PushNode[recordTC,1]; SetAttrs[FALSE,FALSE,FALSE];
PushNode[listTC,1]; SetAttr[1,FALSE]; SetAttr[2,FALSE]; SetAttrV[3,top+2];
PushNode[longTC,1];
END;
55 => -- typecons ::= packed ARRAY indextype OF typeexp
{PushNode[arrayTC,2]; SetAttrV[3,top]};
56 => -- typecons ::= DESCRIPTOR FOR readonly typeexp
{PushNode[arraydescTC,1]; SetAttrV[3,top+2]};
57 => -- typecons ::= safe transfermode arguments
{PushNodeV[top+1,2]; SetAttrV[3,top]};
58 => -- safe ::=
{SetBoolV[top,safety]; l[top] ← P1.InputLoc[]};
59 => -- arglist ::= ANY
-- returnlist ::= RETURNS ANY
PushNode[anyTC, 0];
60 => -- typecons ::= id RELATIVE typeexp
{PushHashV[top]; PushNode[relativeTC,-2]};
61 => -- typecons ::= typeid RELATIVE typeexp
PushNode[relativeTC,2];
62 => -- typecons ::= heap ZONE
{PushNode[zoneTC,0]; SetAttrV[1,top]; SetAttr[2,FALSE]};
63 => -- typecons ::= LONG typeexp
PushNode[longTC,1];
64 => -- typecons ::= FRAME [ id ]
{PushHashV[top+2]; PushNode[frameTC,1]};
65 => -- typecons ::= id PAINTED typeexp
{PushHashV[top]; PushNode[paintTC,-2]};
66 => -- typecons ::= typeid PAINTED typeexp
PushNode[paintTC,2];
67 => -- monitored ::= MONITORED
BEGIN
PushSe[dataPtr.idLOCK];
PushField[P1.IdOfLock[], PopTree[], Tree.Null, top];
SetBoolV[top,TRUE];
END;
68 => -- dependent ::= MACHINE DEPENDENT
{SetBoolV[top,machineDep]; machineDep ← TRUE};
69 => -- dependent ::=
SetBoolV[top,machineDep];
70 => -- reclist ::= [ ]
-- reclist ::= NULL
{PushList[0]; SetBoolV[top,FALSE]};
71 => -- reclist ::= [ pairlist ]
-- reclist ::= [ typelist ]
{PushListV[top+1]; SetBoolV[top,FALSE]};
72 => -- reclist ::= [ pairlist , variantpair ]
{PushList[v[top+1].s+1]; SetBoolV[top,TRUE]};
73 => -- reclist ::= [ variantpart default ]
{t1 ← PopTree[]; AnonField[PopTree[], t1, top]; SetBoolV[top,TRUE]};
74 => -- pairitem ::= identlist public typeexp default
-- variantpair ::= identlist public variantpart default
BEGIN
PushNode[decl,3]; LinkToSource[top];
SetAttrs[FALSE,public,FALSE]; public ← BoolV[top+1];
END;
75 => -- variantpart ::= SELECT vcasehead FROM variantlist ENDCASE
-- variantpart ::= SELECT vcasehead FROM variantlist , ENDCASE
BEGIN
PushListV[top+3];
PushNode[unionTC,2]; SetAttr[1,machineDep]; SetAttrV[2,top+1];
END;
76 => -- variantpart ::= packed SEQUENCE vcasehead OF typeexp
BEGIN
PushNode[sequenceTC,2];
SetAttr[1,machineDep]; SetAttrV[2,top+2]; SetAttrV[3,top];
END;
77 => -- vcasehead ::= ident public tagtype
BEGIN
PushTree[Tree.Null]; PushNode[decl,3]; LinkToSource[top];
SetAttrs[FALSE,public,FALSE]; public ← BoolV[top+1];
SetBoolV[top,FALSE];
END;
78 => -- vcasehead ::= COMPUTED tagtype
{AnonField[PopTree[], Tree.Null, top]; SetBoolV[top,FALSE]};
79 => -- vcasehead ::= OVERLAID tagtype
{AnonField[PopTree[], Tree.Null, top]; SetBoolV[top,TRUE]};
80 => -- tagtype ::= *
PushNode[implicitTC,0];
81 => -- variantitem ::= idlist => reclist
BEGIN
PushNode[variantTC,1];
SetAttr[1,machineDep]; SetAttrV[2,top+2]; SetAttr[3,TRUE];
PushTree[Tree.Null]; PushNode[typedecl,3]; LinkToSource[top];
SetAttrs[TRUE,public,FALSE];
END;
82 => -- typelist ::= typecons default
-- typelist ::= typeid default
{t1 ← PopTree[]; AnonField[PopTree[], t1, top]; v[top].s ← -1};
83 => -- typelist ::= id
{PushHashV[top]; AnonField[PopTree[], Tree.Null, top]; v[top].s ← -1};
84 => -- typelist ::= id ← defaultopt
{t1 ← PopTree[]; PushHashV[top]; AnonField[PopTree[], t1, top]; v[top].s ← -1};
85 => -- typelist ::= typecons default , typelist
-- typelist ::= typeid default , typelist
BEGIN
t1 ← ExtractTree[-(v[top+3].s-1)]; AnonField[ExtractTree[-(v[top+3].s-1)], t1, top];
v[top].s ← v[top+3].s-1;
END;
86 => -- typelist ::= id , typelist
{PushHashV[top]; AnonField[PopTree[], Tree.Null, top]; v[top].s ← v[top+2].s-1};
87 => -- typelist ::= id ← defaultopt , typelist
BEGIN
t1 ← ExtractTree[-(v[top+4].s-1)]; PushHashV[top]; AnonField[PopTree[], t1, top];
v[top].s ← v[top+4].s-1;
END;
88 => -- pointertype ::= pointerprefix
{PushSe[dataPtr.idANY]; SetBoolV[top,FALSE]};
89 => -- pointertype ::= pointerprefix TO readonly typeexp
SetBoolV[top, BoolV[top+2]];
90 => -- transfermode ::= PROCEDURE
-- transfermode ::= PROC
SetOpV[top,procTC];
91 => -- transfermode ::= PORT
SetOpV[top,portTC];
92 => -- transfermode ::= SIGNAL
SetOpV[top,signalTC];
93 => -- transfermode ::= ERROR
SetOpV[top,errorTC];
94 => -- transfermode ::= PROCESS
SetOpV[top,processTC];
95 => -- transfermode ::= PROGRAM
SetOpV[top,programTC];
96 => -- initialization ::=
{PushTree[Tree.Null]; SetBoolV[top,FALSE]};
97 => -- initvalue ::= procaccess trusted checked inline block
BEGIN
IF ~BoolV[top+4] THEN InsertTree[Tree.Null,2];
PushTree[Tree.Null];
PushNode[body,4]; SetAttrV[3,top+3];
SetAttr[1,checked]; SetAttr[2,trusted];
trusted ← BoolV[top+1]; checked ← BoolV[top+2]; public ← BoolV[top];
END;
98 => -- initvalue ::= CODE
PushNode[signalinit,0];
99 => -- initvalue ::= procaccess trusted checked MACHINE CODE BEGIN codelist END
-- initvalue ::= procaccess trusted checked MACHINE CODE { codelist }
BEGIN
PushProperListV[top+6]; PushNode[inline,1];
SetAttr[1,checked]; SetAttr[2,trusted];
trusted ← BoolV[top+1]; checked ← BoolV[top+2]; public ← BoolV[top];
END;
100 => -- trusted ::=
SetBoolV[top,trusted];
101 => -- codelist ::= orderlist
{PushListV[top]; v[top].s ← 1};
102 => -- codelist ::= codelist ; orderlist
{PushListV[top+2]; v[top].s ← v[top].s+1};
103 => -- statement ::= IF exp THEN statement
{PushTree[Tree.Null]; PushNode[if,3]; LinkToSource[top]};
104 => -- statement ::= IF exp THEN balstmt ELSE statement
-- balstmt ::= IF exp THEN balstmt ELSE balstmt
{PushNode[if,3]; LinkToSource[top]};
105 => -- statement ::= casehead casestmtlist ENDCASE => statement
-- balstmt ::= casehead casestmtlist ENDCASE => balstmt
BEGIN
t1 ← PopTree[]; PushProperListV[top+1]; PushTree[t1];
IF BoolV[top] THEN PushNode[bind,4] ELSE PushNode[case,3];
LinkToSource[top];
END;
106 => -- basicstmt ::= lhs
BEGIN
t1 ← PopTree[]; PushTree[t1];
IF OpName[t1] # apply THEN {
PushTree[Tree.Null]; PushNode[apply,2]; SetAttr[1, FALSE]};
LinkToSource[top];
END;
107 => -- basicstmt ::= lhs ← exp
{PushNode[assign,2]; LinkToSource[top]};
108 => -- basicstmt ::= [ explist ] ← exp
{PushNode[extract,2]; LinkToSource[top]};
109 => -- basicstmt ::= trusted checked block
BEGIN
IF BoolV[top+2] THEN {
PushNode[block,2];
SetAttr[1,checked]; SetAttr[2,trusted]; LinkToSource[top+2]}
ELSE IF checked # BoolV[top+1] OR (~checked AND trusted) THEN {
PushNode[checked,1];
SetAttr[1,checked]; SetAttr[2,trusted]; LinkToSource[top+2]};
trusted ← BoolV[top]; checked ← BoolV[top+1];
t1 ← ExtractTree[2];
IF t1 # Tree.Null THEN {
PushTree[t1]; PushNode[open,-2]; LinkToSource[top+2]};
END;
110 => -- basicstmt ::= casehead casestmtlist ENDCASE
BEGIN
PushProperListV[top+1]; PushTree[Tree.Null];
IF BoolV[top] THEN PushNode[bind,4] ELSE PushNode[case,3];
LinkToSource[top];
END;
111 => -- basicstmt ::= forclause dotest DO scope doexit ENDLOOP
BEGIN
IF BoolV[top+3] THEN {
t1 ← PopTree[]; t2 ← PopTree[];
PushNode[block,2]; SetAttr[1,checked]; SetAttr[2,trusted]; LinkToSource[top+2];
PushTree[t2]; PushTree[t1]};
PushNode[do,6]; LinkToSource[top];
END;
112 => -- basicstmt ::= EXIT
{PushNode[exit,0]; LinkToSource[top]};
113 => -- basicstmt ::= LOOP
{PushNode[loop,0]; LinkToSource[top]};
114 => -- basicstmt ::= GOTO id
{PushHashV[top+1]; PushNode[goto,1]; LinkToSource[top]};
115 => -- basicstmt ::= GO TO id
{PushHashV[top+2]; PushNode[goto,1]; LinkToSource[top]};
116 => -- basicstmt ::= RETURN optargs
{PushNode[return,1]; SetAttrV[3,top+1]; LinkToSource[top]};
117 => -- basicstmt ::= transfer lhs
{PushNodeV[top,1]; LinkToSource[top]};
118 => -- basicstmt ::= free [ exp optcatch ]
BEGIN
IF BoolV[top+3] THEN {
t1 ← PopTree[]; PushTree[Tree.Null]; PushTree[t1]; PushNode[free,4]}
ELSE {PushTree[Tree.Null]; PushNode[free,3]};
LinkToSource[top];
END;
119 => -- basicstmt ::= WAIT lhs
{PushNode[wait,1]; LinkToSource[top]};
120 => -- basicstmt ::= ERROR
{PushNode[syserror,0]; LinkToSource[top]};
121 => -- basicstmt ::= STOP
{PushNode[stop,0]; LinkToSource[top]};
122 => -- basicstmt ::= NULL
{PushNode[null,0]; LinkToSource[top]};
123 => -- basicstmt ::= RESUME optargs
{PushNode[resume,1]; SetAttrV[3,top+1]; LinkToSource[top]};
124 => -- basicstmt ::= REJECT
{PushNode[reject,0]; LinkToSource[top]};
125 => -- basicstmt ::= CONTINUE
{PushNode[continue,0]; LinkToSource[top]};
126 => -- basicstmt ::= RETRY
{PushNode[retry,0]; LinkToSource[top]};
127 => -- basicstmt ::= lhs ← STATE
{PushNode[dst,1]; LinkToSource[top]};
128 => -- basicstmt ::= STATE ← exp
{PushNode[lst,1]; LinkToSource[top]};
129 => -- block ::= BEGIN scope exits END
-- block ::= { scope exits }
IF BoolV[top+2] THEN { -- an exits clause is present; build a label node
IF BoolV[top+1] THEN {
t1 ← PopTree[];
PushNode[block,2]; SetAttr[1,checked]; SetAttr[2,trusted]; LinkToSource[top+1];
PushTree[t1]};
SetBoolV[top,FALSE]; PushNode[label,2]; LinkToSource[top]}
ELSE -- things are unchanged; propogate the "block needs to be made" bit
SetBoolV[top,BoolV[top+1]];
130 => -- scope ::= open enables statementlist
BEGIN
PushListV[top+2];
SetBoolV[top,FALSE];
IF BoolV[top+1] THEN {PushNode[enable,2]; LinkToSource[top+1]};
END;
131 => -- scope ::= open enables declist ; statementlist
BEGIN
PushListV[top+4];
t1 ← PopTree[]; PushListV[top+2]; PushTree[t1];
IF BoolV[top+1] THEN {
PushNode[block,2]; SetAttr[1,checked]; SetAttr[2,checked]; LinkToSource[top+2];
PushNode[enable,2]; LinkToSource[top+1]; SetBoolV[top,FALSE]}
ELSE SetBoolV[top,TRUE];
END;
132 => -- binditem ::= exp
{PushHash[Symbols.nullName]; PushNode[item,-2]; LinkToSource[top]};
133 => -- binditem ::= id : exp
-- binditem ::= id ~ ~ exp
{PushHashV[top]; PushNode[item,-2]; LinkToSource[top]};
134 => -- exits ::= EXITS exitlist
{PushListV[top+1]; SetBoolV[top,TRUE]};
135 => -- casestmtitem ::= caselabel => statement
-- caseexpitem ::= caselabel => exp
-- exititem ::= idlist => statement
{PushNode[item,2]; LinkToSource[top]};
136 => -- casetest ::= optrelation
{PushTree[Tree.Null]; PushNodeV[top,-2]};
137 => -- casetest ::= exp
{PushTree[Tree.Null]; PushNode[relE,-2]};
138 => -- caselabel ::= ident typeexp
-- controlid ::= ident typeexp
BEGIN
PushTree[Tree.Null]; PushNode[cast,1]; PushNode[decl,3]; LinkToSource[top];
SetAttrs[FALSE,public,FALSE];
END;
139 => -- forclause ::= FOR controlid ← exp , exp
PushNode[forseq,3];
140 => -- forclause ::= FOR controlid direction IN range
{PushTree[Tree.Null]; PushNodeV[top+2,3]};
141 => -- forclause ::= THROUGH range
{InsertTree[Tree.Null,2]; PushTree[Tree.Null]; PushNode[upthru,-3]};
142 => -- direction ::= DECREASING
SetOpV[top,downthru];
143 => -- direction ::=
SetOpV[top,upthru];
144 => -- dotest ::= UNTIL exp
PushNode[not,1];
145 => -- doexit ::=
{PushTree[Tree.Null]; PushTree[Tree.Null]};
146 => -- doexit ::= REPEAT exitlist
{PushListV[top+1]; PushTree[Tree.Null]};
147 => -- doexit ::= REPEAT exitlist FINISHED => statement
-- doexit ::= REPEAT exitlist FINISHED => statement ;
{t1 ← PopTree[]; PushListV[top+1]; PushTree[t1]};
148 => -- enables ::= ENABLE catchcase ;
{PushTree[Tree.Null]; PushNode[catch,2]; SetBoolV[top,TRUE]};
149 => -- enables ::= ENABLE catchany ;
{PushTree[Tree.Null]; PushNode[catch,-2]; SetBoolV[top,TRUE]};
150 => -- enables ::= ENABLE BEGIN catchlist END ;
-- enables ::= ENABLE { catchlist } ;
BEGIN
t1 ← PopTree[];
PushListV[top+2]; PushTree[t1]; PushNode[catch,2];
SetBoolV[top,TRUE];
END;
151 => -- catchlist ::= catchhead catchcase
{v[top].s ← v[top].s + 1; PushTree[Tree.Null]};
152 => -- catchcase ::= lhslist => statement
BEGIN
t1 ← PopTree[]; PushListV[top]; PushTree[t1];
PushNode[item,2]; LinkToSource[top];
END;
153 => -- optargs ::= [ explist ]
BEGIN
t1 ← PopTree[];
IF t1 = Tree.Null THEN PushProperList[0] ELSE PushTree[t1];
SetBoolV[top,FALSE];
END;
154 => -- optargs ::=
{PushTree[Tree.Null]; l[top] ← P1.InputLoc[]; SetBoolV[top,FALSE]};
155 => -- transfer ::= SIGNAL
SetOpV[top,signal];
156 => -- transfer ::= ERROR
SetOpV[top,error];
157 => -- transfer ::= RETURN WITH ERROR
SetOpV[top,xerror];
158 => -- transfer ::= START
SetOpV[top,start];
159 => -- transfer ::= RESTART
SetOpV[top,restart];
160 => -- transfer ::= JOIN
SetOpV[top,join];
161 => -- transfer ::= NOTIFY
SetOpV[top,notify];
162 => -- transfer ::= BROADCAST
SetOpV[top,broadcast];
163 => -- transfer ::= TRANSFER WITH
SetOpV[top,lste];
164 => -- transfer ::= RETURN WITH
SetOpV[top,lstf];
-- expression processing
165 => -- keyitem ::= id ~ optexp
-- keyitem ::= id : optexp
{PushHashV[top]; PushNode[item,-2]};
166 => -- defaultopt ::= trash
-- optexp ::= trash
-- initvalue ::= trash
PushNode[void,0];
167 => -- defaultopt ::= exp '| trash
{PushNode[void,0]; PushList[2]};
168 => -- exp ::= IF exp THEN exp ELSE exp
PushNode[ifx,3];
169 => -- exp ::= casehead caseexplist ENDCASE => exp
BEGIN
t1 ← PopTree[];
PushProperListV[top+1]; PushTree[t1];
IF BoolV[top] THEN PushNode[bindx,4] ELSE PushNode[casex,3];
LinkToSource[top];
END;
170 => -- exp ::= lhs ← exp
PushNode[assignx,2];
171 => -- exp ::= [ explist ] ← exp
PushNode[extractx,2];
172 => -- exp ::= ERROR
PushNode[syserrorx,0];
173 => -- disjunct ::= disjunct OR conjunct
PushNode[or,2];
174 => -- conjunct ::= conjunct AND negation
PushNode[and,2];
175 => -- negation ::= ~ relation
-- negation ::= NOT relation
PushNode[not,1];
176 => -- relation ::= sum optrelation
-- sum ::= sum addop product
-- product ::= product multop factor
PushNodeV[top+1,2];
177 => -- optrelation ::= NOT relationtail
SetOpV[top, NegatedV[top+1]];
178 => -- relationtail ::= IN range
SetOpV[top,in];
179 => -- relop ::= =
SetOpV[top,relE];
180 => -- relop ::= #
SetOpV[top,relN];
181 => -- relop ::= <
SetOpV[top,relL];
182 => -- relop ::= <=
SetOpV[top,relLE];
183 => -- relop ::= >
SetOpV[top,relG];
184 => -- relop ::= >=
SetOpV[top,relGE];
185 => -- addop ::= +
SetOpV[top,plus];
186 => -- addop ::= -
SetOpV[top,minus];
187 => -- multop ::= *
SetOpV[top,times];
188 => -- multop ::= /
SetOpV[top,div];
189 => -- multop ::= MOD
SetOpV[top,mod];
190 => -- factor ::= addop primary
IF OpV[top] = minus THEN PushNode[uminus,1];
191 => -- primary ::= [ explist ]
{PushTree[Tree.Null]; PushNode[apply,-2]; SetAttr[1, FALSE]};
192 => -- primary ::= prefixop [ orderlist ]
{PushListV[top+2]; PushNodeV[top,1]};
193 => -- primary ::= VAL [ orderlist ]
{PushListV[top+2]; PushNode[val,1]};
194 => -- primary ::= ALL [ orderlist ]
{PushListV[top+2]; PushNode[all,1]};
195 => -- primary ::= new [ typeexp initialization optcatch ]
{PushNode[new, IF BoolV[top+4] THEN 4 ELSE 3]; SetAttrV[1,top+3]};
196 => -- primary ::= cons [ explist optcatch ]
PushNode[cons, IF BoolV[top+3] THEN 3 ELSE 2];
197 => -- primary ::= listcons [ explist ]
PushNode[listcons,2];
198 => -- primary ::= NIL
{PushTree[Tree.Null]; PushNode[nil,1]};
199 => -- primary ::= typeop [ typeexp ]
-- exp ::= transferop lhs
PushNodeV[top,1];
200 => -- qualifier ::= . prefixop
-- qualifier ::= . typeop
PushNodeV[top+1,1];
201 => -- primary ::= SIZE [ typeexp ]
-- qualifier ::= . SIZE
{PushTree[Tree.Null]; PushNode[size,2]};
202 => -- primary ::= SIZE [ typeexp , exp ]
PushNode[size,2];
203 => -- primary ::= ISTYPE [ exp , typeexp ]
PushNode[istype,2];
204 => -- primary ::= @ lhs
PushNode[addr,1];
205 => -- primary ::= DESCRIPTOR [ desclist ]
PushNode[arraydesc,1];
206 => -- lhs ::= id
-- element ::= id
-- ident ::= id :
-- controlid ::= id
PushHashV[top];
207 => -- lhs ::= num
-- lhs ::= string
PushLitV[top];
208 => -- lhs ::= lnum
{PushLitV[top]; PushNode[mwconst,1]; SetAttr[1,FALSE]};
209 => -- lhs ::= flnum
{PushLitV[top]; PushNode[mwconst,1]; SetAttr[1,TRUE]};
210 => -- lhs ::= char
{PushLitV[top]; PushNode[clit,1]};
211 => -- lhs ::= lstring
{PushLitV[top]; PushNode[llit,1]};
212 => -- lhs ::= atom
{PushHashV[top]; PushNode[atom,1]};
213 => -- lhs ::= NARROW [ exp opttype optcatch ]
PushNode[narrow, IF BoolV[top+4] THEN 3 ELSE 2];
214 => -- lhs ::= LOOPHOLE [ exp opttype ]
PushNode[loophole,2];
215 => -- lhs ::= APPLY [ exp , exp optcatch ]
{PushNode[apply, IF BoolV[top+5] THEN 3 ELSE 2]; SetAttr[1,TRUE]};
216 => -- qualifier ::= [ explist optcatch ]
{PushNode[apply, IF BoolV[top+2] THEN 3 ELSE 2]; SetAttr[1,FALSE]};
217 => -- qualifier ::= . id
{PushHashV[top+1]; PushNode[dot,2]};
218 => -- qualifier ::= ↑
PushNode[uparrow,1];
219 => -- optcatch ::= ! catchlist
BEGIN
t1 ← PopTree[];
PushListV[top+1]; PushTree[t1]; PushNode[catch,2];
SetBoolV[top,TRUE];
END;
220 => -- transferop ::= SIGNAL
SetOpV[top,signalx];
221 => -- transferop ::= ERROR
SetOpV[top,errorx];
222 => -- transferop ::= START
SetOpV[top,startx];
223 => -- transferop ::= JOIN
SetOpV[top,joinx];
224 => -- transferop ::= NEW
SetOpV[top,create];
225 => -- transferop ::= FORK
SetOpV[top,fork];
226 => -- prefixop ::= LONG
SetOpV[top,lengthen];
227 => -- prefixop ::= ABS
SetOpV[top,abs];
228 => -- prefixop ::= PRED
SetOpV[top,pred];
229 => -- prefixop ::= SUCC
SetOpV[top,succ];
230 => -- prefixop ::= ORD
SetOpV[top,ord];
231 => -- prefixop ::= MIN
SetOpV[top,min];
232 => -- prefixop ::= MAX
SetOpV[top,max];
233 => -- prefixop ::= BASE
SetOpV[top,base];
234 => -- prefixop ::= LENGTH
SetOpV[top,length];
235 => -- typeop ::= CODE
SetOpV[top,typecode];
236 => -- typeop ::= FIRST
SetOpV[top,first];
237 => -- typeop ::= LAST
SetOpV[top,last];
238 => -- typeop ::= NIL
SetOpV[top,nil];
239 => -- desclist ::= exp , exp opttype
PushList[3];
240 => -- directory ::= DIRECTORY ;
-- imports ::= IMPORTS
-- exports ::= EXPORTS
-- fieldlist ::= [ ]
-- new ::= NEW
-- free ::= FREE
-- cons ::= CONS
-- listcons ::= LIST
-- pointerprefix ::= POINTER
-- catchlist ::= catchhead
PushTree[Tree.Null];
241 => -- using ::= USING [ ]
-- defaultopt ::=
PushProperList[0];
242 => -- elementlist ::=
-- statementlist ::=
-- casestmtlist ::=
-- exitlist ::=
-- catchhead ::=
-- caseexplist ::=
v[top].s ← 0;
243 => -- includelist ::= includeitem
-- modulelist ::= moduleitem
-- declist ::= declaration
-- pairlist ::= pairitem
-- elementlist' ::= element
-- variantlist ::= variantitem
-- bindlist ::= binditem
-- statementlist' ::= statement
-- casestmtlist' ::= casestmtitem
-- caselabel' ::= casetest
-- exitlist' ::= exititem
-- lhslist ::= lhs
-- orderlist ::= optexp
-- keylist ::= keyitem
-- caseexplist' ::= caseexpitem
v[top].s ← 1;
244 => -- includelist ::= includelist , includeitem
-- modulelist ::= modulelist , moduleitem
-- declist ::= declist ; declaration
-- pairlist ::= pairlist , pairitem
-- elementlist' ::= elementlist' , element
-- variantlist ::= variantlist , variantitem
-- bindlist ::= bindlist , binditem
-- statementlist' ::= statementlist' ; statement
-- casestmtlist' ::= casestmtlist' ; casestmtitem
-- caselabel' ::= caselabel' , casetest
-- exitlist' ::= exitlist' ; exititem
-- catchhead ::= catchhead catchcase ;
-- lhslist ::= lhslist , lhs
-- orderlist ::= orderlist , optexp
-- keylist ::= keylist , keyitem
-- caseexplist' ::= caseexplist' , caseexpitem
v[top].s ← v[top].s+1;
245 => -- idlist ::= idlist'
-- identlist ::= identlist'
-- explist ::= orderlist
-- explist ::= keylist
-- caselabel ::= caselabel'
PushListV[top];
246 => -- directory ::= DIRECTORY includelist ;
-- imports ::= IMPORTS modulelist
-- exports ::= EXPORTS modulelist
-- open ::= OPEN bindlist ;
-- fieldlist ::= [ pairlist ]
-- fieldlist ::= [ typelist ]
PushListV[top+1];
247 => -- class ::= PROGRAM
-- safe ::= UNSAFE
-- initialization ::= ← initvalue
-- casehead ::= SELECT exp FROM
SetBoolV[top,FALSE];
248 => -- class ::= MONITOR
-- packed ::= PACKED
-- safe ::= SAFE
-- readonly ::= READONLY
-- reclist ::= [ variantpair ]
-- ordered ::= ORDERED
-- base ::= BASE
-- heap ::= UNCOUNTED
-- initialization ::= tilde initvalue
-- inline ::= INLINE
-- optargs ::= lhs
-- casehead ::= WITH binditem SELECT optexp FROM
SetBoolV[top,TRUE];
249 => -- packed ::=
-- readonly ::=
-- monitored ::=
-- ordered ::=
-- base ::=
-- heap ::=
-- inline ::=
-- enables ::=
-- exits ::=
-- optcatch ::=
{SetBoolV[top,FALSE]; l[top] ← P1.InputLoc[]};
250 => -- using ::= USING [ idlist ]
-- interface ::= imports exports shares
-- shares ::= SHARES idlist
-- tilde ::= ~
-- tilde ::= =
-- typeid ::= typeid'
-- typeexp ::= typeid
-- typeexp ::= typecons
-- typecons ::= typeappl
-- optsize ::= [ exp ]
-- elementlist ::= elementlist'
-- length ::= [ exp ]
-- default ::= ← defaultopt
-- defaultopt ::= exp
-- tagtype ::= typeexp
-- pointerprefix ::= POINTER interval
-- indextype ::= typeexp
-- arguments ::= arglist returnlist
-- arglist ::= fieldlist
-- returnlist ::= RETURNS fieldlist
-- initvalue ::= exp
-- statement ::= basicstmt
-- balstmt ::= basicstmt
-- dotest ::= WHILE exp
-- catchany ::= ANY => statement
-- catchlist ::= catchhead catchany
-- catchlist ::= catchhead catchany ;
-- statementlist ::= statementlist'
-- statementlist ::= statementlist' ;
-- casestmtlist ::= casestmtlist'
-- casestmtlist ::= casestmtlist' ;
-- exitlist ::= exitlist'
-- exitlist ::= exitlist' ;
-- caseexplist ::= caseexplist'
-- caseexplist ::= caseexplist' ,
-- trash ::= TRASH
-- trash ::= NULL
-- optexp ::= exp
-- exp ::= disjunct
-- disjunct ::=C conjunct
-- conjunct ::=C negation
-- negation ::=C relation
-- relation ::= sum
-- optrelation ::= relationtail
-- relationtail ::= relop sum
-- range ::= interval
-- range ::= typeid
-- bounds ::= exp .. exp
-- sum ::=C product
-- product ::=C factor
-- factor ::=C primary
-- primary ::= lhs
-- desclist ::= exp
-- lhs ::= ( exp )
-- lhs ::= lhs qualifier
-- new ::= lhs . NEW
-- free ::= lhs . FREE
-- cons ::= lhs . CONS
-- listcons ::= lhs . LIST
-- opttype ::= , typeexp
NULL;
251 => -- directory ::=
-- using ::=
-- locks ::=
-- lambda ::=
-- imports ::=
-- exports ::=
-- shares ::=
-- optsize ::=
-- optbits ::=
-- default ::=
-- open ::=
-- arglist ::=
-- returnlist ::=
-- indextype ::=
-- forclause ::=
-- dotest ::=
-- optexp ::=
-- opttype ::=
{PushTree[Tree.Null]; l[top] ← P1.InputLoc[]};
252 => -- checked ::=
{SetBoolV[top,checked]; trusted ← checked};
253 => -- checked ::= CHECKED
{SetBoolV[top,checked]; trusted ← checked ← TRUE};
254 => -- checked ::= TRUSTED
{SetBoolV[top,checked]; trusted ← TRUE; checked ← FALSE};
255 => -- checked ::= UNCHECKED
{SetBoolV[top,checked]; trusted ← checked ← FALSE};
-- error or unimplemented
ENDCASE => ERROR;
ENDLOOP};
}.