-- Pass1T.pgs
-- Copyright (C) 1985 by Xerox Corporation.  All rights reserved.
-- DO NOT CONVERT TO TIOGA FORMAT!  (PSG requires the mesa-style comments)
-- last modified by Satterthwaite, April 9, 1986 10:10:14 am PST
-- last modified by Donahue,  9-Dec-81 10:48:31
-- last modified by Maxwell, August 11, 1983 12:57 pm
-- Russ Atkinson (RRA) March 6, 1985 10:35:47 pm PST

-- pgs [grammar: Cedar] _ Pass1T.pgs

-- needs CBinary.bcd
-- output:
--      new version of Pass1T.mesa
--      tables in MesaTab.bcd, which is exported as a PROGRAM module to CBinary
--      table format description on ParseTable.mesa
--      log on PGS.log, grammar on Cedar.grammar
--      errors on Pass1T.errlog


DIRECTORY
  ComData: TYPE USING [idANY, idINT, idLOCK, cedar],
  ParseTable: TYPE USING [ActionEntry, ProdDataRef, TSymbol],
  P1: TYPE USING [
    ActionStack, Index, LinkStack, Value, ValueStack, nullValue,
    InputLoc, IdOfFirst, IdOfLock, IdOfRest],
  Symbols: TYPE USING [Name, nullName],
  SourceMap: TYPE USING [Cons],
  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, SourceMap, 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] = INLINE {
    negation: ARRAY Op[$relE .. $notin] OF Op = [
      relE: $relN,	relN: $relE,
      relL: $relGE,	relGE: $relL,
      relG: $relLE,	relLE: $relG,
      in: $notin,		notin: $in];
    RETURN[negation[v[k].s]]};


 -- 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[SourceMap.Cons[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
          dataPtr.cedar _ safety _ trusted _ checked _ TRUE;
        7  => -- cedar          ::=
          dataPtr.cedar _ safety _ trusted _ checked _ FALSE;
        8  => -- proghead       ::= resident safe class arguments locks interface bindop 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 bindop 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 bindop 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 entry block
          BEGIN
          IF ~BoolV[top+5] 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];
          IF OpV[top+4] # $none THEN PushNodeV[top+4,1];
          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 ::= bindop 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 
              -- bindop         ::= ~ 
              -- bindop         ::= = 
              -- 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};

  }.