-- file sakurapass1t.mesa rewritten by PGS,  6-Aug-81 10:19
-- file sakurapass1t.mesa rewritten by PGS,  6-Aug-81 10:11
-- file sakurapass1t.mesa rewritten by PGS,  6-Aug-81  9:10
-- file SakuraPass1T.Mesa
-- syntax last modified by Satterthwaite, February 4, 1981  3:23 PM
-- rules  last modified by Satterthwaite, February 4, 1981  3:23 PM
-- last edit by Suzuki,    5-Aug-81 16:35:43

DIRECTORY
  Inline: TYPE USING [LowHalf],
  PPComData: TYPE USING [idANY, idINT, idLOCK],
  PPCommentTable: TYPE USING [Index],
  ParseTable: TYPE USING [ActionEntry, ProdData, TSymbol],
  PPP1: TYPE USING [Value, ValueStack, NullValue, InputLoc, IdOfFirst, IdOfLock, IdOfRest],
  PPLeaves: TYPE USING [HTIndex, HTNull],
  SakuraTree: TYPE USING [AttrId, Link, Map, NodeName, Null],
  SakuraTreeOps: TYPE USING [
    FreeTree, ListLength, MakeNode, ExtractTree, InsertTree, OpName,
    PopTree, PushTree, PushHash, PushList, PushLit, PushProperList, PushSe,
    PushNode, PushStringLit, SetAttr, SetInfo, UpdateList];

SakuraPass1T: PROGRAM
    IMPORTS Inline, P1: PPP1, TreeOps: SakuraTreeOps, PPComData
    EXPORTS PPP1 =
  BEGIN  -- parse tree building
  OPEN PPLeaves, Tree: SakuraTree, PPCommentTable, TreeOps;

  ProdDataHandle: TYPE = LONG POINTER TO ParseTable.ProdData;
  
  Op: TYPE = Tree.NodeName;

 -- local data base (supplied by parser)

  v: P1.ValueStack;
  l: LONG DESCRIPTOR FOR ARRAY OF Index;

  q: LONG DESCRIPTOR FOR ARRAY OF ParseTable.ActionEntry;

  prodData: ProdDataHandle;

 -- initialization/termination

  AssignDescriptors: PUBLIC PROC [
	qd: LONG DESCRIPTOR FOR ARRAY OF ParseTable.ActionEntry,
	vd: P1.ValueStack,
	ld: LONG DESCRIPTOR FOR ARRAY OF Index,
	pp: ProdDataHandle] =
    {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]};
  PushStringLitV: PROC [k: NAT] = {PushStringLit[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: BOOLEAN _ FALSE] =
    BEGIN
    SetAttr[1,attr1];  SetAttr[2,attr2];  SetAttr[3,attr3];
    END;

 -- value manipulation

  IntV: PROC [k: NAT] RETURNS [INTEGER] = {RETURN [v[k].s]};
  SetIntV: PROC [k: NAT, i: INTEGER] = {v[k].s _ i}; 

  BoolV: PROC [k: NAT] RETURNS [BOOLEAN] = {RETURN [v[k].s]};
  SetBoolV: PROC [k: NAT, b: BOOLEAN] = {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] =
    BEGIN
    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]
    END;


 -- shared processing routines

  DetachItem: Tree.Map = {PushTree[t]; RETURN [Tree.Null]};

  AnonField: PROC [type, default: Tree.Link, top: CARDINAL] =
    BEGIN
    PushField[HTNull, type, default, top];
    END;

  PushField: PROC [id: HTIndex, type, default: Tree.Link, top: CARDINAL] =
    BEGIN
    PushHash[id];  PushTree[type];  PushTree[default];
    PushNode[decl,3];  LinkToSource[top];
    SetAttrs[FALSE,public,FALSE];
    END;

 -- the interpretation rules

  LinkToSource: PROC [index: CARDINAL] = {SetInfo[Inline.LowHalf[l[index]]]};

 -- propagated attributes
  public: BOOLEAN;
  machineDep: BOOLEAN;

  ProcessQueue: PUBLIC PROC [qI, top: CARDINAL] =
    BEGIN
    t1, t2: Tree.Link;
    FOR i: CARDINAL IN [0..qI)
      DO
      top _ top-q[i].tag.pLength+1;
      IF prodData[q[i].transition].rule >= 150 THEN 
        ProcessQueue2[top, prodData[q[i].transition].rule]
      ELSE 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   LIST   ARRAY   SEQUENCE   DESCRIPTOR
	      --  PROC  PORT   SIGNAL   ERROR   PROCESS DEVICE
	      --  PROGRAM   MONITOR   RELATIVE   LONG
	      --  TYPE   FRAME   TO   ORDERED
	      --  BASE   OF   PACKED   RETURNS   MONITORED
	      --  OVERLAID   COMPUTED   MACHINE   DEPENDENT   DIRECTORY
	      --  DEFINITIONS   IMPORTS   EXPORTS   SHARES
	      --  LOCKS   USING   PUBLIC   PRIVATE   READONLY
	      --  ENTRY   INTERNAL   INLINE   CODE
	      --  ABS   ALL   AND   CONS   MAX   MIN   MOD
	      --  NOT   OR   PRED   LENGTH   NEW   START   SUCC
	      --  FORK   JOIN   LOOPHOLE   NARROW   ISTYPE   SIZE
	      --  FIRST   LAST   NIL   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  CONTINUE  RETRY  TRANSFER  STATE
	      --  OPEN  ENABLE  ANY  EXITS  )
	      --  )  ]  }  ENDLOOP  ENDCASE
	      --  (  [  {    DO  SELECT
	      --  GUARDIAN CONTROL OUT DATAFLOW PAR CHOICE WHEN ON WITHIN -> UP DOWN

	      --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
	      --  .        InitialSymbol

	      --PRODUCTIONS:

              -- goal           ::= . unit . 
	      -- goal           ::= . unit .. 
	  NULL;
        1  => -- unit           ::= directory module 
	  {PushNode[unit,2]; LinkToSource[top]};
        2  => -- directory      ::= DIRECTORY includelist ;
	  PushListV[top+1];
        3  => -- includeitem    ::= id : FROM string using
	  BEGIN
	  PushStringLitV[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  => -- using          ::= USING [ ]
	  PushProperList[0];
        7  => -- module         ::= identlist classhead block 
	      -- module         ::= identlist defhead defbody 
	  BEGIN
	  IF ~BoolV[top+2] THEN InsertTree[Tree.Null,2];
	  PushTree[Tree.Null];
	  t1 _ MakeNode[body,4];  t2 _ ExtractTree[2];
	  PushTree[ExtractTree[5]];  PushTree[t2];  PushTree[t1];
	  SetAttrs[FALSE,FALSE,FALSE];
	  PushNode[decl,3];  LinkToSource[top];
	  SetAttrs[TRUE,TRUE,FALSE];
	  PushNode[module,5];  LinkToSource[top];  SetAttrV[1,top+1];
	  END;
        8  => -- classhead      ::= class arguments locks interface = public 
	  BEGIN
	  t1 _ ExtractTree[4];
	  PushTree[ExtractTree[5]];  PushTree[ExtractTree[5]];
	  PushNode[programTC,2];  SetAttrV[1, top+1];
	  IF ~BoolV[top+1] OR t1 # Tree.Null
	    THEN PushTree[t1]
	    ELSE
	      BEGIN
	      PushHash[P1.IdOfLock[]];  PushTree[Tree.Null];
	      PushNode[lambda,-2];  SetAttr[1,TRUE];  SetAttr[2,public];
	      END;
	  machineDep _ FALSE;
	  END;
        9  => -- class          ::= PROGRAM 
	  SetBoolV[top,FALSE];
       10  => -- class          ::= MONITOR 
	  SetBoolV[top,TRUE];
       11  => -- defhead        ::= definitions locks imports shares = public 
	  BEGIN
	  t1 _ ExtractTree[3];
	  t2 _ PopTree[];  PushTree[Tree.Null];  PushTree[t2];
	  PushNode[definitionTC,0];  PushTree[t1];
	  SetBoolV[top,FALSE];  machineDep _ FALSE;
	  END;
       12  => -- definitions    ::= DEFINITIONS 
	  public _ TRUE;
       13  => -- defbody        ::= { open declist } 
	  {PushListV[top+2]; PushTree[Tree.Null]; SetBoolV[top,TRUE]};
       14  => -- locks          ::= LOCKS primary lambda
	  {PushNode[lambda,-2]; SetAttr[1,FALSE]; SetAttr[2,FALSE]};
       15  => -- lambda         ::= USING ident typeexp
	  BEGIN
	  PushTree[Tree.Null];  PushNode[decl,3];  LinkToSource[top+1];
	  SetAttrs[FALSE,FALSE,FALSE];
	  END;
       16  => -- moduleitem     ::= id 
	  BEGIN
	  PushHashV[top];  PushHashV[top];
	  PushNode[item,2];  SetAttr[1,FALSE];  LinkToSource[top];
	  END;
       17  => -- moduleitem     ::= id : id 
	  BEGIN
	  PushHashV[top];  PushHashV[top+2];
	  PushNode[item,2];  SetAttr[1,TRUE];  LinkToSource[top];
	  END;
       18  => -- declaration    ::= identlist public readonly entry typeexp initialization 
	  BEGIN
	  IF OpV[top+3] # none THEN PushNodeV[top+3,1];
	  PushNode[decl,3];  LinkToSource[top];
	  SetAttrV[1,top+5]; SetAttr[2,public]; public _ BoolV[top+1];
	  SetAttrV[3,top+2];
	  END;
       19  => -- declaration    ::= identlist public TYPE = public typeexp default 
          BEGIN
	  public _ BoolV[top+4];
	  PushNode[typedecl,3];  LinkToSource[top];
	  SetAttrs[TRUE,public,FALSE];  public _ BoolV[top+1];
	  END;
       20  => -- declaration    ::= identlist public TYPE optargs 
          BEGIN
	  PushNode[opaqueTC,1];  PushTree[Tree.Null];
	  PushNode[typedecl,3];  LinkToSource[top];
	  SetAttrs[TRUE,public,FALSE];  public _ BoolV[top+1];
	  END;
       21  => -- public         ::= PUBLIC
	  {SetBoolV[top,public]; public _ TRUE};
       22  => -- public         ::= PRIVATE
              -- procaccess     ::=
	  {SetBoolV[top,public]; public _ FALSE};
       23  => -- public         ::=
	  SetBoolV[top,public];
       24  => -- entry          ::= ENTRY
	  SetOpV[top,entry];
       25  => -- entry          ::= INTERNAL
	  SetOpV[top,internal];
       26  => -- entry          ::=
	  {SetOpV[top,none]; l[top] _ P1.InputLoc[]};
       27  => -- idlist'        ::= id 
	      -- identlist'     ::= id : 
	  {PushHashV[top]; v[top].s _ -1};
       28  => -- identlist'     ::= id position : 
	  {PushHashV[top]; PushNode[item,-2]; v[top].s _ -1};
       29  => -- idlist'        ::= id , idlist' 
	      -- identlist'     ::= id , identlist' 
	  {PushHashV[top]; v[top].s _ v[top+2].s-1};
       30  => -- 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;
       31  => -- position       ::= ( exp optbits ) 
	  PushNode[item,2];
       32  => -- optbits        ::= : bounds 
	      -- interval       ::= [ bounds ] 
          PushNode[intCC,2];
       33  => -- interval       ::= [ bounds ) 
          PushNode[intCO,2];
       34  => -- interval       ::= ( bounds ] 
          PushNode[intOC,2];
       35  => -- interval       ::= ( bounds ) 
          PushNode[intOO,2];
       36  => -- typeexp        ::= id 
	      -- range          ::= id
	  PushHashV[top];
       37  => -- typeid         ::= id . id 
	  {PushHashV[top]; PushHashV[top+2]; PushNode[dot,2]};
       38  => -- typeid         ::= id id 
	  {PushHashV[top+1]; PushHashV[top]; PushNode[discrimTC,2]};
       39  => -- typeid         ::= id typeid 
	  {PushHashV[top]; PushNode[discrimTC,2]};
       40  => -- typecons       ::= interval 
	  {PushSe[PPComData.idINT]; PushNode[subrangeTC,-2]};
       41  => -- typecons       ::= id interval 
	      -- range          ::= id interval
	  {PushHashV[top]; PushNode[subrangeTC,-2]};
       42  => -- typecons       ::= typeid interval 
	      -- range          ::= typeid interval
	  PushNode[subrangeTC,2];
       43  => -- typecons       ::= id length 
	  {PushHashV[top]; PushNode[apply,-2]};
       44  => -- typecons       ::= typeid length 
	  PushNode[apply,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[HTNull]; PushNode[item,-2]};
       48  => -- typecons       ::= dependent monitored RECORD reclist
	  BEGIN
	  IF ~BoolV[top+1]
	    THEN PushNode[recordTC,1]
	    ELSE
	      BEGIN
	      t1 _ PopTree[];  v[top+2].s _ ListLength[t1];
	      t1 _ UpdateList[t1,DetachItem];  t1 _ FreeTree[t1];
	      PushList[IntV[top+2]+1];  PushNode[monitoredTC,1];
	      END;
	  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       ::= REF readonly typeexp
	  BEGIN
	  PushNode[refTC,1];
	  SetAttr[1,FALSE];  SetAttr[2,FALSE];  SetAttrV[3,top+1];
	  PushNode[longTC,1];
	  END;
       51  => -- 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;
       52  => -- typecons       ::= REF
	  BEGIN
	  PushNode[anyTC, 0];  PushNode[refTC,1];
	  SetAttrs[FALSE,FALSE,FALSE];
	  PushNode[longTC,1];
	  END;
       53  => -- 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;
       54  => -- typecons       ::= packed ARRAY indextype OF typeexp
	  {PushNode[arrayTC,2]; SetAttrV[3,top]};
       55  => -- typecons       ::= DESCRIPTOR FOR readonly typeexp
	  {PushNode[arraydescTC,1]; SetAttrV[3,top+2]};
       56  => -- typecons       ::= transfermode arguments
	  PushNodeV[top,2];
       57  => -- typecons       ::= id RELATIVE typeexp
	  {PushHashV[top]; PushNode[relativeTC,-2]};
       58  => -- typecons       ::= typeid RELATIVE typeexp
	  PushNode[relativeTC,2];
       59  => -- typecons       ::= LONG typeexp
	  PushNode[longTC,1];
       60  => -- typecons       ::= FRAME [ id ]
	  {PushHashV[top+2]; PushNode[frameTC,1]};
       61  => -- monitored      ::= MONITORED
	  BEGIN
	  PushSe[PPComData.idLOCK];
	  PushField[P1.IdOfLock[], PopTree[], Tree.Null, top];
	  SetBoolV[top,TRUE];
	  END;
       62  => -- dependent      ::= MACHINE DEPENDENT
	  {SetBoolV[top,machineDep]; machineDep _ TRUE};
       63  => -- dependent      ::=
	  SetBoolV[top,machineDep];
       64  => -- reclist        ::= [ ]
              -- reclist        ::= NULL
	  {PushList[0]; SetBoolV[top,FALSE]};
       65  => -- reclist        ::= [ pairlist ]
	      -- reclist        ::= [ typelist ]
	  {PushListV[top+1]; SetBoolV[top,FALSE]};
       66  => -- reclist        ::= [ pairlist , variantpair ]
	  {PushList[IntV[top+1]+1]; SetBoolV[top,TRUE]};
       67  => -- reclist        ::= [ variantpart default ]
	  {t1 _ PopTree[]; AnonField[PopTree[], t1, top]; SetBoolV[top,TRUE]};
       68  => -- 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;
       69  => -- defaultopt     ::=
	  PushProperList[0];
       70  => -- defaultopt     ::= NULL
	  PushNode[void,0];
       71  => -- defaultopt     ::= exp '| NULL
	  {PushNode[void,0]; PushList[2]};
       72  => -- 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;
       73  => -- variantpart    ::= packed SEQUENCE vcasehead OF typeexp
	  BEGIN
	  PushNode[sequenceTC,2];
	  SetAttr[1,machineDep]; SetAttrV[2,top+2]; SetAttrV[3,top];
	  END;
       74  => -- 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;
       75  => -- vcasehead      ::= COMPUTED tagtype
	  {AnonField[PopTree[], Tree.Null, top]; SetBoolV[top,FALSE]};
       76  => -- vcasehead      ::= OVERLAID tagtype
	  {AnonField[PopTree[], Tree.Null, top]; SetBoolV[top,TRUE]};
       77  => -- tagtype        ::= *
	  PushNode[implicitTC,0];
       78  => -- 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;
       79  => -- typelist       ::= typecons default
	      -- typelist       ::= typeid default
	  {t1 _ PopTree[]; AnonField[PopTree[], t1, top]; v[top].s _ -1};
       80  => -- typelist       ::= id
	  {PushHashV[top]; AnonField[PopTree[], Tree.Null, top]; v[top].s _ -1};
       81  => -- typelist       ::= id _ defaultopt
	  {t1 _ PopTree[]; PushHashV[top]; AnonField[PopTree[], t1, top]; v[top].s _ -1};
       82  => -- 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;
       83  => -- typelist       ::= id , typelist
	  {PushHashV[top]; AnonField[PopTree[], Tree.Null, top]; v[top].s _ v[top+2].s-1};
       84  => -- 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;
       85  => -- pointertype    ::= pointerprefix
	  {PushSe[PPComData.idANY]; SetBoolV[top,FALSE]};
       86  => -- pointertype    ::= pointerprefix TO readonly typeexp
	  SetBoolV[top, BoolV[top+2]];
       87  => -- transfermode   ::= PROC
	  SetOpV[top,procTC];
       88  => -- transfermode   ::= PORT
	  SetOpV[top,portTC];
       89  => -- transfermode   ::= SIGNAL
	  SetOpV[top,signalTC];
       90  => -- transfermode   ::= ERROR
	  SetOpV[top,errorTC];
       91  => -- transfermode   ::= PROCESS
	  SetOpV[top,processTC];
       92  => -- transfermode   ::= PROGRAM
	  SetOpV[top,programTC];
       93  => -- initialization ::=
	  {PushTree[Tree.Null]; SetBoolV[top,FALSE]};
       94  => -- initvalue      ::= procaccess inline block
	  BEGIN
	  IF ~BoolV[top+2] THEN  InsertTree[Tree.Null,2];
	  PushTree[Tree.Null];
	  PushNode[body,4];  SetAttr[1,FALSE];  SetAttr[2,FALSE];  SetAttrV[3,top+1];
	  public _ BoolV[top];
	  END;
       95  => -- initvalue      ::= CODE
	  PushNode[signalinit,0];
       96  => -- initvalue      ::= MACHINE CODE { codelist }
	  {PushProperListV[top+3]; PushNode[inline,1]};
       97  => -- codelist       ::= orderlist
	  {PushListV[top]; v[top].s _ 1};
       98  => -- codelist       ::= codelist ; orderlist
	  {PushListV[top+2]; v[top].s _ v[top].s+1};

       99  => -- statement      ::= lhs
	  BEGIN
	  t1 _ PopTree[];  PushTree[t1];
	  IF OpName[t1] # apply THEN {PushTree[Tree.Null]; PushNode[apply,2]};
	  LinkToSource[top];
	  END;
      100  => -- statement      ::= lhs _ exp 
	  {PushNode[assign,2]; LinkToSource[top]};
      101  => -- statement      ::= [ explist ] _ exp 
	  {PushNode[extract,2]; LinkToSource[top]};
      102  => -- statement      ::= block 
	  BEGIN
	  IF BoolV[top] THEN {PushNode[block,2]; LinkToSource[top]};
	  t1 _ ExtractTree[2];
	  IF t1 # Tree.Null THEN {PushTree[t1]; PushNode[open,-2]; LinkToSource[top]};
	  END;
      103  => -- statement      ::= IF exp THEN statement elsepart 
	  {PushNode[if,3]; LinkToSource[top]};
      104  => -- statement      ::= casehead casestmtlist ENDCASE otherpart
	  BEGIN
	  t1 _ PopTree[];  PushProperListV[top+1];  PushTree[t1];
	  IF BoolV[top] THEN PushNode[bind,4] ELSE PushNode[case,3];
	  LinkToSource[top];
	  END;
      105  => -- statement      ::= forclause dotest DO scope doexit ENDLOOP 
	  BEGIN
	  IF BoolV[top+3]
	    THEN
	      BEGIN
	      t1 _ PopTree[];  t2 _ PopTree[];
	      PushNode[block,2];  LinkToSource[top+2];
	      PushTree[t2];  PushTree[t1];
	      END;
	  PushNode[do,6];  LinkToSource[top];
	  END;
      106  => -- statement      ::= EXIT 
	  {PushNode[exit,0]; LinkToSource[top]};
      107  => -- statement      ::= LOOP 
	  {PushNode[loop,0]; LinkToSource[top]};
      108  => -- statement      ::= GOTO id 
	  {PushHashV[top+1]; PushNode[goto,1]; LinkToSource[top]};
      109  => -- statement      ::= GO TO id 
	  {PushHashV[top+2]; PushNode[goto,1]; LinkToSource[top]};
      110  => -- statement      ::= RETURN optargs
	  {PushNode[return,1]; LinkToSource[top]};
      111  => -- statement      ::= transfer lhs
	  {PushNodeV[top,1]; LinkToSource[top]};
      112  => -- statement      ::= 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;
      113  => -- statement      ::= WAIT lhs
	  {PushNode[wait,1]; LinkToSource[top]};
      114  => -- statement      ::= ERROR
	  {PushNode[syserror,0]; LinkToSource[top]};
      115  => -- statement      ::= STOP
	  {PushNode[stop,0]; LinkToSource[top]};
      116  => -- statement      ::= NULL
	  {PushNode[null,0]; LinkToSource[top]};
      117  => -- statement      ::= RESUME optargs
	  {PushNode[resume,1]; LinkToSource[top]};
      118  => -- statement      ::= CONTINUE
	  {PushNode[continue,0]; LinkToSource[top]};
      119  => -- statement      ::= RETRY
	  {PushNode[retry,0]; LinkToSource[top]};
      120  => -- statement      ::= lhs _ STATE
	  {PushNode[dst,1]; LinkToSource[top]};
      121  => -- block          ::= { scope exits }
	  IF BoolV[top+2]
	    THEN
	      BEGIN
	      IF BoolV[top+1]
		THEN {t1 _ PopTree[]; PushNode[block,2]; LinkToSource[top]; PushTree[t1]};
	      SetBoolV[top,FALSE];  PushNode[label,2];  LinkToSource[top];
	      END
	    ELSE  SetBoolV[top, BoolV[top+1]];
      122  => -- scope          ::= open enables declist statementlist
	  BEGIN
	  PushListV[top+3];
	  IF IntV[top+2] = 0
	    THEN SetBoolV[top,FALSE]
	    ELSE {t1 _ PopTree[]; PushListV[top+2]; PushTree[t1]; SetBoolV[top,TRUE]};
	  IF BoolV[top+1]
	    THEN
	      BEGIN
	      IF BoolV[top] THEN {PushNode[block,2]; LinkToSource[top+2]};
	      PushNode[enable,2];  LinkToSource[top+1];  SetBoolV[top,FALSE];
	      END;
	  END;
      123  => -- binditem       ::= exp
	  {PushHash[HTNull]; PushNode[item,-2]; LinkToSource[top]};
      124  => -- binditem       ::= id : exp
	  {PushHashV[top]; PushNode[item,-2]; LinkToSource[top]};
      125  => -- exits          ::= EXITS exitlist
	  {PushListV[top+1]; SetBoolV[top,TRUE]};
      126  => -- casestmtitem   ::= caselabel => statement
	      -- caseexpitem    ::= caselabel => exp
	      -- exititem       ::= idlist => statement
	  {PushNode[item,2]; LinkToSource[top]};
      127  => -- casetest       ::= optrelation 
	  {PushTree[Tree.Null]; PushNodeV[top,-2]};
      128  => -- casetest       ::= exp 
	  {PushTree[Tree.Null]; PushNode[relE,-2]};
      129  => -- caselabel      ::= ident typeexp
	      -- controlid      ::= ident typeexp 
	  BEGIN
	  PushTree[Tree.Null];  PushNode[decl,3];  LinkToSource[top];
	  SetAttrs[FALSE,public,FALSE];
	  END;
      130  => -- forclause      ::= FOR controlid _ exp , exp 
	  PushNode[forseq,3];
      131  => -- forclause      ::= FOR controlid direction IN range 
	  {PushTree[Tree.Null]; PushNodeV[top+2,3]};
      132  => -- forclause      ::= THROUGH range
	  {InsertTree[Tree.Null,2]; PushTree[Tree.Null]; PushNode[upthru,-3]};
      133  => -- direction      ::= DECREASING 
	  SetOpV[top,downthru];
      134  => -- direction      ::=  
	  SetOpV[top,upthru];
      135  => -- dotest         ::= UNTIL exp 
	  PushNode[not,1];
      136  => -- doexit         ::=
	  {PushTree[Tree.Null]; PushTree[Tree.Null]};
      137  => -- doexit         ::= REPEAT exitlist
	  {PushListV[top+1]; PushTree[Tree.Null]};
      138  => -- doexit         ::= REPEAT exitlist FINISHED => statement
	      -- doexit         ::= REPEAT exitlist FINISHED => statement ;
	  {t1 _ PopTree[]; PushListV[top+1]; PushTree[t1]};
      139  => -- enables        ::= ENABLE catchcase ;
	  {PushTree[Tree.Null]; PushNode[catch,2]; SetBoolV[top,TRUE]};
      140  => -- enables        ::= ENABLE catchany ;
	  {PushTree[Tree.Null]; PushNode[catch,-2]; SetBoolV[top,TRUE]};
      141  => -- enables        ::= ENABLE { catchlist } ;
	  BEGIN
	  t1 _ PopTree[];
	  PushListV[top+2];  PushTree[t1];  PushNode[catch,2];
	  SetBoolV[top,TRUE];
	  END;
      142  => -- catchlist      ::= catchhead
	  PushTree[Tree.Null];
      143  => -- catchlist      ::= catchhead catchcase
	  {v[top].s _ v[top].s + 1; PushTree[Tree.Null]};
      144  => -- catchcase      ::= lhslist => statement
	  BEGIN
	  t1 _ PopTree[];  PushListV[top];  PushTree[t1];
	  PushNode[item,2];  LinkToSource[top];
	  END;
      145  => -- optargs        ::= [ explist ]
	  BEGIN
	  t1 _ PopTree[];
	  IF t1 = Tree.Null THEN PushProperList[0] ELSE PushTree[t1];
	  END;
     ENDCASE => ERROR;
	
   ENDLOOP;
END;  
	  
ProcessQueue2: PROC[top: CARDINAL, rule: [0..377B]] = BEGIN	  
   t1: Tree.Link;
   SELECT rule FROM
      146  => -- transfer       ::= SIGNAL
	  SetOpV[top,signal];
      147  => -- transfer       ::= ERROR
	  SetOpV[top,error];
      148  => -- transfer       ::= RETURN WITH ERROR
	  SetOpV[top,xerror];
      149  => -- transfer       ::= START
	  SetOpV[top,start];
      150  => -- transfer       ::= RESTART
	  SetOpV[top,restart];
      151  => -- transfer       ::= JOIN
	  SetOpV[top,join];
      152  => -- transfer       ::= NOTIFY
	  SetOpV[top,notify];
      153  => -- transfer       ::= BROADCAST
	  SetOpV[top,broadcast];
      154  => -- transfer       ::= TRANSFER WITH
	  SetOpV[top,lst];
      155  => -- transfer       ::= RETURN WITH
	  SetOpV[top,lstf];

       -- expression processing
      156  => -- keyitem        ::= id : optexp
	  {PushHashV[top]; PushNode[item,-2]}; 
      157  => -- optexp         ::= NULL
              -- initvalue      ::= NULL
	  PushNode[void,0];
      158  => -- exp            ::= transferop lhs 
          PushNodeV[top,1];
      159  => -- exp            ::= IF exp THEN exp ELSE exp 
          PushNode[ifx,3];
      160  => -- 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;
      161  => -- exp            ::= lhs _ exp 
          PushNode[assignx,2];
      162  => -- exp            ::= [ explist ] _ exp 
	  PushNode[extractx,2];
      163  => -- exp            ::= ERROR 
          PushNode[syserrorx,0];
      164  => -- disjunct       ::= disjunct OR conjunct 
          PushNode[or,2];
      165  => -- conjunct       ::= conjunct AND negation 
          PushNode[and,2];
      166  => -- negation       ::= not relation 
          PushNode[not,1];
      167  => -- relation       ::= sum optrelation 
              -- sum            ::= sum addop product 
              -- product        ::= product multop factor 
          PushNodeV[top+1,2];
      168  => -- optrelation    ::= not relationtail 
          SetOpV[top, NegatedV[top+1]];
      169  => -- relationtail   ::= IN range 
          SetOpV[top,in];
      170  => -- relop          ::= = 
          SetOpV[top,relE];
      171  => -- relop          ::= # 
          SetOpV[top,relN];
      172  => -- relop          ::= < 
          SetOpV[top,relL];
      173  => -- relop          ::= <= 
          SetOpV[top,relLE];
      174  => -- relop          ::= > 
          SetOpV[top,relG];
      175  => -- relop          ::= >= 
          SetOpV[top,relGE];
      176  => -- addop          ::= + 
          SetOpV[top,plus];
      177  => -- addop          ::= - 
          SetOpV[top,minus];
      178  => -- multop         ::= * 
          SetOpV[top,times];
      179  => -- multop         ::= / 
          SetOpV[top,div];
      180  => -- multop         ::= MOD 
          SetOpV[top,mod];
      181  => -- factor         ::= - primary 
          PushNode[uminus,1];
      182  => -- primary        ::= num 
	  PushLitV[top];
      183  => -- primary        ::= lnum 
	  {PushLitV[top]; PushNode[mwconst,1]; SetAttr[1,FALSE]};
      184  => -- primary        ::= flnum 
	  {PushLitV[top]; PushNode[mwconst,1]; SetAttr[1,TRUE]};
      185  => -- primary        ::= char 
	  {PushLitV[top]; PushNode[clit,1]};
      186  => -- primary        ::= string 
	  PushStringLitV[top];
      187  => -- primary        ::= lstring 
	  {PushStringLitV[top]; PushNode[llit,1]};
      188  => -- primary        ::= atom 
	  {PushHashV[top]; PushNode[atom,1]};
      189  => -- primary        ::= NIL 
	  {PushTree[Tree.Null]; PushNode[nil,1]};
      190  => -- primary 	::= [ explist ]
	  {PushTree[Tree.Null]; PushNode[apply,-2]};
      191  => -- primary        ::= prefixop [ orderlist ]
	  {PushListV[top+2]; PushNodeV[top,1]};
      192  => -- primary        ::= new [ typeexp initialization optcatch ]
          {PushNode[new, IF BoolV[top+4] THEN 4 ELSE 3]; SetAttrV[1,top+3]};
      193  => -- primary        ::= cons [ explist optcatch ]
          PushNode[cons, IF BoolV[top+3] THEN 3 ELSE 2];
      194  => -- primary        ::= listcons [ explist ]
          PushNode[listcons,2];
      195  => -- primary        ::= typeop [ typeexp ]
          PushNodeV[top,1];
      196  => -- primary        ::= SIZE [ typeexp ]
          {PushTree[Tree.Null];  PushNode[size, 2]};
      197  => -- primary        ::= SIZE [ typeexp , exp ]
          PushNode[size,2];
      198  => -- primary        ::= ISTYPE [ exp , typeexp optcatch ] 
          PushNode[istype, IF BoolV[top+5] THEN 3 ELSE 2];
      199  => -- primary        ::= @ lhs
	  PushNode[addr,1];
      200  => -- primary        ::= DESCRIPTOR [ desclist ]
	  PushNode[arraydesc,1];
      201  => -- lhs            ::= id 
              -- element        ::= id
	      -- ident          ::= id : 
              -- controlid      ::= id 
	  PushHashV[top];
      202  => -- lhs            ::= NARROW [ exp opttype optcatch ]
	  PushNode[narrow, IF BoolV[top+4] THEN 3 ELSE 2];
      203  => -- lhs            ::= LOOPHOLE [ exp opttype ]
	  PushNode[loophole,2];
      204  => -- qualifier      ::= [ explist optcatch ]
	  PushNode[apply, IF BoolV[top+2] THEN 3 ELSE 2];
      205  => -- qualifier      ::= . id
	  {PushHashV[top+1]; PushNode[dot,2]};
      206  => -- qualifier      ::= ^
	  PushNode[uparrow,1];
      207  => -- optcatch       ::= ! catchlist
	  BEGIN
	  t1 _ PopTree[];
	  PushListV[top+1];  PushTree[t1];  PushNode[catch,2];
	  SetBoolV[top,TRUE];
	  END;
      208  => -- transferop     ::= SIGNAL
	  SetOpV[top,signalx];
      209  => -- transferop     ::= ERROR
	  SetOpV[top,errorx];
      210  => -- transferop     ::= START
	  SetOpV[top,startx];
      211  => -- transferop     ::= JOIN
	  SetOpV[top,joinx];
      212  => -- transferop     ::= NEW 
          SetOpV[top,create];
      213  => -- transferop     ::= FORK
	  SetOpV[top,fork];
      214  => -- prefixop       ::= LONG 
          SetOpV[top,lengthen];
      215  => -- prefixop       ::= ABS 
          SetOpV[top,abs];
      216  => -- prefixop       ::= PRED 
          SetOpV[top,pred];
      217  => -- prefixop       ::= SUCC 
          SetOpV[top,succ];
      218  => -- prefixop       ::= MIN 
          SetOpV[top,min];
      219  => -- prefixop       ::= MAX 
          SetOpV[top,max];
      220  => -- prefixop       ::= BASE
	  SetOpV[top,base];
      221  => -- prefixop       ::= LENGTH
	  SetOpV[top,length];
      222  => -- prefixop       ::= ALL
	  SetOpV[top,all];
      223  => -- typeop         ::= CODE
	  SetOpV[top,typecode];
      224  => -- typeop         ::= FIRST
	  SetOpV[top,first];
      225  => -- typeop         ::= LAST
	  SetOpV[top,last];
      226  => -- typeop         ::= NIL
	  SetOpV[top,nil];
      227  => -- desclist       ::= exp , exp opttype
	  PushList[3];
      228  => -- directory      ::= DIRECTORY ;
	      -- fieldlist      ::= [ ]
	      -- new            ::= NEW
              -- free           ::= FREE
              -- cons           ::= CONS
              -- listcons       ::= LIST
              -- pointerprefix  ::= POINTER
	  PushTree[Tree.Null];
      229  => -- declist        ::= 
              -- statementlist  ::= 
	      -- casestmtlist   ::=
              -- exitlist       ::= 
	      -- catchhead      ::=
	      -- caseexplist    ::=
	  v[top].s _ 0;
      230  => -- includelist    ::= includeitem
	      -- modulelist     ::= moduleitem
	      -- pairlist       ::= pairitem
	      -- elementlist    ::= element
	      -- variantlist    ::= variantitem
	      -- bindlist       ::= binditem
	      -- statementlist' ::= statement 
	      -- casestmtlist'  ::= casestmtitem
	      -- caselabel'     ::= casetest 
	      -- exitlist'      ::= exititem
	      -- lhslist        ::= lhs
	      -- orderlist      ::= optexp 
	      -- keylist        ::= keyitem 
	      -- caseexplist'   ::= caseexpitem
      -- transferseries ::= transferexp
      -- parlist ::= statement
      -- guardcomlist ::= guardcom 
	  v[top].s _ 1;

      231  => -- 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
      -- transferseries ::= transferseries ; transferexp
      -- parlist ::= parlist // statement
      -- guardcomlist ::= guardcomlist "||" guardcom
	  v[top].s _ v[top].s + 1;
      232  => -- idlist         ::= idlist'
	      -- identlist      ::= identlist'
	      -- explist        ::= orderlist
	      -- explist        ::= keylist
	      -- caselabel     ::= caselabel' 
	  PushListV[top];
      233  => -- imports        ::= IMPORTS modulelist
	      -- exports        ::= EXPORTS modulelist 
              -- open           ::= OPEN bindlist ;
	      -- fieldlist      ::= [ pairlist ]
	      -- fieldlist      ::= [ typelist ]
	  PushListV[top+1];
      234  => -- initialization ::= _ initvalue
	      -- casehead       ::= SELECT exp FROM
	  SetBoolV[top,FALSE];
      235  => -- readonly       ::= READONLY
	      -- reclist        ::= [ variantpair ]
	      -- ordered        ::= ORDERED
	      -- base           ::= BASE
	      -- packed		::= PACKED
	      -- initialization ::= = initvalue
	      -- inline		::= INLINE
	      -- casehead       ::= WITH binditem SELECT optexp FROM
	  SetBoolV[top,TRUE];
      236  => -- packed		::=
	      -- readonly       ::=
	      -- monitored      ::=
	      -- ordered        ::=
	      -- base           ::=
	      -- inline		::=
	      -- enables        ::=
	      -- exits          ::=
	      -- optcatch       ::=
	  {SetBoolV[top,FALSE]; l[top] _ P1.InputLoc[]};
      237  => -- using          ::= USING [ idlist ]
	      -- interface      ::= imports exports shares
	      -- shares         ::= SHARES idlist 
	      -- typeexp        ::= typeid 
	      -- typeexp        ::= typecons 
	      -- length         ::= [ exp ] 
	      -- default        ::= _ defaultopt 
	      -- defaultopt     ::= exp 
	      -- tagtype        ::= typeexp 
	      -- pointerprefix  ::= POINTER interval 
	      -- indextype      ::= typeexp 
	      -- arguments      ::= arglist returnlist 
	      -- arglist        ::= fieldlist 
	      -- returnlist     ::= RETURNS fieldlist 
	      -- initvalue      ::= exp 
	      -- elsepart       ::= ELSE statement 
	      -- otherpart      ::= => statement 
	      -- 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' , 
	      -- optexp         ::= exp 
	      -- exp            ::= disjunct 
	      -- disjunct       ::=C conjunct 
	      -- conjunct       ::=C negation 
	      -- negation       ::=C relation 
	      -- not            ::= ~ 
	      -- not            ::= NOT 
	      -- 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;
      238  => -- directory      ::= 
	      -- using          ::= 
	      -- locks          ::= 
	      -- lambda         ::= 
	      -- imports        ::= 
	      -- exports        ::= 
	      -- shares         ::= 
	      -- optbits        ::= 
	      -- default        ::= 
	      -- open           ::=
	      -- arglist        ::= 
	      -- returnlist     ::= 
	      -- indextype      ::=
	      -- elsepart       ::=
	      -- otherpart      ::=
	      -- forclause      ::= 
	      -- dotest         ::= 
	      -- optargs        ::= 
	      -- optexp         ::=
	      -- opttype        ::=
	  {PushTree[Tree.Null]; l[top] _ P1.InputLoc[]};

-- SakuraProductions.pgs
-- The following productions will be added to Mesa productions

      239  => -- transfermode ::= DEVICE
	  SetOpV[top,deviceTC];
 
      240  => -- block ::= { IN pairlist OUT pairlist GUARDIAN block OUT pairlist DATAFLOW transferseries CONTROL block }
	  {PushListV[top+2]; PushListV[top+4]; PushListV[top+8]; PushListV[top+10]; PushNode[deviceblock, 6]};
      241  => -- statement ::= WHEN event : statement
      	  PushNode[when, 2];
      242  => -- transferexp ::= lhs _ exp
	  PushNode[transfer, 2];

      243  => -- statement ::= PAR { parlist }
	  {PushListV[top+2]; PushNode[parallel, 1]};

      244  => -- guardcom ::= WHEN event -> statement
	  PushNode[guardedcommand, 2];

      245  => -- statement ::= ON event -> statement WITHIN statement
	  PushNode[on, 3];
      246  => -- event ::= updownsignal
	  {PushTree[Tree.Null]; PushNode[event, 2]};
      247  => -- event ::= updownsignal AND exp
	  PushNode[event, 2];
      248  => -- updownsignal ::= lhs UP
	  PushNode[upsignal, 1];
      249  => -- updownsignal ::= lhs DOWN
	  PushNode[downsignal, 1];
      250  => -- statement ::= CHOICE { guardcomlist }
      	  {PushListV[top+2]; PushNode[choice, 1]};
	  
    ENDCASE => ERROR;
  END;
END.