-- file Pass1T.Mesa rewritten by PGS,  8-Jan-80  9:40
-- file Pass1T.Mesa
-- syntax last modified by Satterthwaite, 10-Dec-79 12:30
-- rules  last modified by Satterthwaite, January 8, 1980  10:49 AM

DIRECTORY
  ComData: FROM "comdata"
    USING [
      definitionsOnly, nTypeCodes,
      idANY, idBOOLEAN, idCARDINAL, idCHARACTER, idINTEGER, idLOCK, idREAL],
  ParseTable: FROM "parsetable"
    USING [ActionEntry, Production, ProductionInfo, TSymbol, tokenID],
  P1: FROM "p1" USING [InputLoc, LockId],
  Symbols: FROM "symbols" USING [HTNull],
  Tree: FROM "tree" USING [Link, Map, NodeName, Null, NullId],
  TreeOps: FROM "treeops" USING [
      FreeTree, ListLength, MakeNode, ExtractTree, InsertTree,
      PopTree, PushTree, PushHash, PushList, PushLit, PushProperList, PushSe,
      PushNode, PushStringLit, SetAttr, SetInfo, TestTree, UpdateList];

Pass1T: PROGRAM
    IMPORTS
	P1, TreeOps,
	dataPtr: ComData
    EXPORTS P1 =
  BEGIN  -- parse tree building
  OPEN TreeOps;

 -- local data base (supplied by parser)

  v: DESCRIPTOR FOR ARRAY OF UNSPECIFIED;
  l: DESCRIPTOR FOR ARRAY OF CARDINAL;

  q: DESCRIPTOR FOR ARRAY OF ParseTable.ActionEntry;

  ProdData: TYPE = ARRAY ParseTable.Production OF ParseTable.ProductionInfo;
  prodData: POINTER TO ProdData;

 -- initialization/termination

  AssignDescriptors: PUBLIC PROCEDURE [
	qd: DESCRIPTOR FOR ARRAY OF ParseTable.ActionEntry,
	vd: DESCRIPTOR FOR ARRAY OF UNSPECIFIED,
	ld: DESCRIPTOR FOR ARRAY OF CARDINAL,
	pp: POINTER TO ProdData] =
    BEGIN
    q _ qd;  v _ vd;  l _ ld;  prodData _ pp;
    END;


 -- the interpretation rules

  LinkToSource: PROCEDURE [index: CARDINAL] = BEGIN SetInfo[l[index]] END;

  public: BOOLEAN;
  -- initialization
    init: BOOLEAN = FALSE;
    equate: BOOLEAN = TRUE;
  -- machine dependent segments
    machineDep: BOOLEAN;

  ProcessQueue: PUBLIC PROCEDURE [qI, top: CARDINAL] =
    BEGIN
    i: CARDINAL;
    vTop: UNSPECIFIED;
    sv1, sv2: Tree.Link;
    FOR i IN [0..qI)
      DO
      top _ top-q[i].tag.pLength+1;  vTop _ v[top];
      SELECT prodData[q[i].transition].rule FROM

       -- basic tree building
        0  => -- MODULE: ParseTable
              -- BINARY: MesaTab      INTERFACE: CBinary
	      -- GOAL:  goal

	      --TERMINALS:
	      --  id    num    lnum    string    lstring
	      --  char    ,    ;    :   ..
	      --  =>   _   =   #   <
	      --  >   <=   >=   ~   +
	      --  -   *   /   ^   .
	      --  @   !   '|   INTEGER   CARDINAL
	      --  CHARACTER   BOOLEAN   REAL   RECORD   POINTER REF
	      --  ARRAY   DESCRIPTOR   PROCEDURE   PROC  PORT   SIGNAL
	      --  ERROR   PROCESS   PROGRAM   MONITOR   RELATIVE
	      --  LONG   TYPE   FRAME   TO   ORDERED
	      --  BASE   OF   PACKED   RETURNS   MONITORED
	      --  OVERLAID   COMPUTED   MACHINE   DEPENDENT   DIRECTORY
	      --  DEFINITIONS   IMPORTS   EXPORTS   SHARES   RESIDENT
	      --  LOCKS   USING   PUBLIC   PRIVATE   READONLY
	      --  ENTRY   INTERNAL   INLINE   CODE   ABS
	      --  ALL   AND   MAX   MIN   MOD
	      --  NOT   OR   LENGTH   NEW   START
	      --  FORK   JOIN   LOOPHOLE   SIZE   FIRST
	      --  LAST   NULL   IF   THEN   ELSE
	      --  WITH   FROM   FOR   DECREASING  IN
	      --  THROUGH  UNTIL  WHILE  REPEAT  FINISHED
	      --  RETURN  EXIT  LOOP  GOTO  GO
	      --  WAIT  RESTART  NOTIFY  BROADCAST  STOP
	      --  RESUME  CONTINUE  RETRY  TRANSFER  STATE
	      --  OPEN  ENABLE  ANY  EXITS  )
	      --  ]  }  END  ENDLOOP  ENDCASE
	      --  (  [  {  BEGIN  DO
	      --  SELECT

	      --ALIASES:
	      --  id       tokenID
	      --  num      tokenNUM
	      --  lnum     tokenLNUM
	      --  string   tokenSTR
	      --  lstring  tokenLSTR
	      --  char     tokenCHAR
	      --  -        tokenMINUS
	      --  .        tokenDOT
	      --  ..       tokenDOTS
	      --  =        tokenEQUAL
	      --  =>       tokenARROW
	      --  <        tokenLESS
	      --  <=       tokenLE
	      --  >        tokenGREATER
	      --  >=       tokenGE
	      --  .        InitialSymbol

	      --PRODUCTIONS:

              -- goal           ::= . unit . 
	      -- goal           ::= . unit .. 
	  NULL;
        1  => -- unit           ::= directory module 
	  BEGIN
	  PushNode[unit,2];  LinkToSource[top];
	  END;
        2  => -- directory      ::= DIRECTORY includelist ;
	  PushList[v[top+1]];
        3  => -- includeitem    ::= id : FROM string using
	  BEGIN
	  PushStringLit[v[top+3]];  PushHash[v[top]];
	  PushNode[diritem,-3];  LinkToSource[top];
	  END;
        4  => -- using          ::= USING [ ]
	  PushProperList[0];
        5  => -- module         ::= id : classhead block 
	      -- module         ::= id : defhead defbody 
	  BEGIN
	  IF ~v[top+3] THEN InsertTree[Tree.Null, 2];
	  PushTree[Tree.Null];
	  PushNode[body,4];
	  SetAttr[1,FALSE];  SetAttr[2,FALSE];  SetAttr[3,FALSE];
	  PushTree[ExtractTree[3]];  PushHash[v[top]];
	  PushNode[decl,-3];  LinkToSource[top];
	  SetAttr[1,equate];  SetAttr[2,TRUE];  SetAttr[3,FALSE];
	  PushNode[module,5];  LinkToSource[top];  SetAttr[1, v[top+2]];
	  END;
        6  => -- classhead       ::= resident PROGRAM arguments interface = public 
	  BEGIN
	  dataPtr.definitionsOnly _ FALSE;
	  PushTree[ExtractTree[5]];  PushTree[ExtractTree[5]];
	  PushNode[programTC,2];
	  PushTree[Tree.Null];  vTop _ v[top];  machineDep _ FALSE;
	  END;
        7  => -- classhead      ::= resident MONITOR arguments locks interface = public 
	  BEGIN
	  dataPtr.definitionsOnly _ FALSE;
	  sv1 _ ExtractTree[4];
	  PushTree[ExtractTree[5]];  PushTree[ExtractTree[5]];
	  PushNode[programTC,2];
	  IF sv1 # Tree.Null
	    THEN PushTree[sv1]
	    ELSE
	      BEGIN
	      PushHash[P1.LockId[]];  PushTree[Tree.Null];
	      PushNode[lambda,-2];  SetAttr[1,TRUE];  SetAttr[2,public];
	      END;
	  vTop _ v[top];  machineDep _ FALSE;
	  END;
        8  => -- resident       ::= RESIDENT 
	  BEGIN
	  public _ FALSE;  vTop _ TRUE;
	  END;
        9  => -- resident       ::= 
	  BEGIN
	  public _ FALSE;  vTop _ FALSE;  l[top] _ P1.InputLoc[];
	  END;
       10  => -- defhead        ::= definitions locks imports shares = public 
	  BEGIN
	  dataPtr.definitionsOnly _ TRUE;
	  sv1 _ ExtractTree[3];
	  sv2 _ PopTree[];  PushTree[Tree.Null];  PushTree[sv2];
	  PushNode[definitionTC,0];  PushTree[sv1];
	  vTop _ FALSE;  machineDep _ FALSE;
	  END;
       11  => -- definitions     ::= DEFINITIONS 
	  public _ TRUE;
       12  =>  -- defbody        ::= BEGIN open declist END 
               -- defbody        ::= { open declist } 
	  BEGIN
	  PushList[v[top+2]];  PushTree[Tree.Null];  vTop _ TRUE;
	  END;
       13  => -- locks          ::= LOCKS primary
	  BEGIN
	  PushTree[Tree.Null];   PushNode[lambda,-2];
	  SetAttr[1,FALSE];  SetAttr[2,FALSE];
	  END;
       14  => -- locks          ::= LOCKS primary USING id : typeexp
	  BEGIN
	  PushHash[v[top+3]];  InsertTree[Tree.Null,3];
	  PushNode[decl,-3];  LinkToSource[top+3];
	  SetAttr[1,FALSE];  SetAttr[2,FALSE];  SetAttr[3,FALSE];
	  PushNode[lambda,-2];  SetAttr[1,FALSE];  SetAttr[2,FALSE];
	  END;
       15  => -- moduleitem     ::= id 
	  BEGIN
	  PushHash[v[top]];  PushHash[v[top]];
	  PushNode[item,2];  SetAttr[1,FALSE];  LinkToSource[top];
	  END;
       16  => -- moduleitem     ::= id : id 
	  BEGIN
	  PushHash[v[top]];  PushHash[v[top+2]];
	  PushNode[item,2];  SetAttr[1,TRUE];  LinkToSource[top];
	  END;
       17  => -- declaration    ::= identlist public readonly entry typeexp initialization 
	  BEGIN
	  IF v[top+3] # Tree.NodeName[none] THEN PushNode[v[top+3],1];
	  PushNode[decl,3];  LinkToSource[top];
	  SetAttr[1,v[top+5]]; SetAttr[2,public]; public _ v[top+1];
	  SetAttr[3,v[top+2]];
	  END;
       18  => -- declaration    ::= identlist public TYPE = public typeexp default 
          BEGIN
	  public _ v[top+4];
	  PushNode[typedecl,3];  LinkToSource[top];
	  SetAttr[1,equate]; SetAttr[2,public]; public _ v[top+1];
	  SetAttr[3,FALSE];
	  END;
       19  => -- public         ::= PUBLIC
	  BEGIN
	  vTop _ public;  public _ TRUE;
	  END;
       20  => -- public         ::= PRIVATE
	  BEGIN
	  vTop _ public;  public _ FALSE;
	  END;
       21  => -- public         ::=
	  vTop _ public;
       22  => -- entry          ::= ENTRY
	  vTop _ Tree.NodeName[entry];
       23  => -- entry          ::= INTERNAL
	  vTop _ Tree.NodeName[internal];
       24  => -- entry          ::=
	  BEGIN
	  vTop _ Tree.NodeName[none];  l[top] _ P1.InputLoc[];
	  END;
       25  => -- idlist'        ::= id 
	      -- identlist'     ::= id : 
	  BEGIN
	  PushHash[v[top]];  vTop _ -1;
	  END;
       26  => -- idlist'        ::= id , idlist' 
	      -- identlist'     ::= id , identlist' 
	  BEGIN
	  PushHash[v[top]];  vTop _ v[top+2]-1;
	  END;
       27  => -- typeexp        ::= id 
	      -- range          ::= id
	  PushHash[v[top]];
       28  => -- typeid         ::= INTEGER 
	  PushSe[dataPtr.idINTEGER];
       29  => -- typeid         ::= CARDINAL 
	  PushSe[dataPtr.idCARDINAL];
       30  => -- typeid         ::= CHARACTER 
	  PushSe[dataPtr.idCHARACTER];
       31  => -- typeid         ::= BOOLEAN 
	  PushSe[dataPtr.idBOOLEAN];
       32  => -- typeid         ::= REAL 
	  PushSe[dataPtr.idREAL];
       33  => -- typeid         ::= id . id 
	  BEGIN
	  PushHash[v[top]];  PushHash[v[top+2]];
	  PushNode[dot,2];
	  END;
       34  => -- typeid         ::= id id 
	  BEGIN
	  PushHash[v[top+1]];  PushHash[v[top]];
	  PushNode[discrimTC,2];
	  END;
       35  => -- typeid         ::= id typeid 
	  BEGIN
	  PushHash[v[top]];  PushNode[discrimTC,2];
	  END;
       36  => -- typecons       ::= interval 
	  BEGIN
	  PushSe[dataPtr.idINTEGER];  PushNode[subrangeTC,-2];
	  END;
       37  => -- typecons       ::= id interval 
	      -- range          ::= id interval
	  BEGIN
	  PushHash[v[top]];  PushNode[subrangeTC,-2];
	  END;
       38  => -- typecons       ::= typeid interval 
	      -- range          ::= typeid interval
	  PushNode[subrangeTC,2];
       39  => -- typecons       ::= { idlist }
	  BEGIN
	  PushNode[enumeratedTC,1];  SetAttr[1,public];
	  END;
       40  => -- typecons       ::= monitored dependent RECORD reclist
	  BEGIN
	  IF ~v[top]
	    THEN PushNode[recordTC,1]
	    ELSE
	      BEGIN
	      sv1 _ PopTree[];  v[top+2] _ ListLength[sv1];
	      sv1 _ UpdateList[sv1, DetachItem];  sv1 _ FreeTree[sv1];
	      PushList[v[top+2]+1];  PushNode[monitoredTC,1];
	      END;
	  SetAttr[1,machineDep]; SetAttr[2,v[top+3]];
	  machineDep _ v[top+1];
	  END;
       41  => -- typecons       ::= ordered base pointertype
	  BEGIN
	  sv2 _ MakeNode[pointerTC,1];
	  sv1 _ PopTree[];
	  PushTree[sv2];
	  SetAttr[1,v[top]];  SetAttr[2,v[top+1]];  SetAttr[3,v[top+2]];
	  IF sv1 # Tree.Null
	    THEN  BEGIN  PushTree[sv1];  PushNode[subrangeTC,2]  END;
	  END;
       42  => -- typecons       ::= REF
	  BEGIN
	  PushSe[dataPtr.idANY];  PushNode[pointerTC,1];
	  SetAttr[1,FALSE];  SetAttr[2,FALSE];  SetAttr[3,FALSE];
	  PushNode[longTC,1];
	  END;
       43  => -- typecons       ::= REF readonly typeexp
	  BEGIN
	  PushNode[pointerTC,1];
	  SetAttr[1,FALSE];  SetAttr[2,FALSE];  SetAttr[3,v[top+1]];
	  PushNode[longTC,1];
	  END;
       44  => -- typecons       ::= array indextype OF typeexp
	  BEGIN
	  PushNode[arrayTC,2];  SetAttr[1,v[top]];
	  END;
       45  => -- typecons       ::= DESCRIPTOR FOR readonly typeexp
	  BEGIN
	  PushNode[arraydescTC,1];  SetAttr[3,v[top+2]];
	  END;
       46  => -- typecons       ::= transfermode arguments
	  PushNode[v[top],2];
       47  => -- typecons       ::= id RELATIVE typeexp
	  BEGIN
	  PushHash[v[top]];  PushNode[relativeTC,-2];
	  END;
       48  => -- typecons       ::= typeid RELATIVE typeexp
	  PushNode[relativeTC,2];
       49  => -- typecons       ::= LONG typeexp
	  PushNode[longTC,1];
       50  => -- typecons       ::= FRAME [ id ]
	  BEGIN
	  PushHash[v[top+2]];  PushNode[frameTC,1];
	  END;
       51  => -- interval       ::= [ bounds ] 
          PushNode[intCC,2];
       52  => -- interval       ::= [ bounds ) 
          PushNode[intCO,2];
       53  => -- interval       ::= ( bounds ] 
          PushNode[intOC,2];
       54  => -- interval       ::= ( bounds ) 
          PushNode[intOO,2];
       55  => -- monitored      ::= MONITORED
	  BEGIN
	  PushHash[P1.LockId[]];  PushSe[dataPtr.idLOCK];
	  PushTree[Tree.Null];
	  PushNode[decl,3];  LinkToSource[top];
	  SetAttr[1,FALSE];  SetAttr[2,public];  SetAttr[3,FALSE];
	  vTop _ TRUE;
	  END;
       56  => -- dependent      ::= MACHINE DEPENDENT
	  BEGIN
	  vTop _ machineDep;  machineDep _ TRUE;
	  END;
       57  => -- dependent      ::=
	  vTop _ machineDep;
       58  => -- reclist        ::= [ pairlist ]
	      -- reclist        ::= [ typelist ]
	  BEGIN
	  PushList[v[top+1]];  vTop _ FALSE;
	  END;
       59  => -- reclist        ::= [ pairlist , variantpair ]
	  BEGIN
	  PushList[v[top+1]+1];  vTop _ TRUE;
	  END;
       60  => -- reclist        ::= [ variantpair ]
	  vTop _ TRUE;
       61  => -- reclist        ::= [ variantpart ]
	  BEGIN
	  AnonField[PopTree[],top];  vTop _ TRUE;
	  END;
       62  => -- pairitem       ::= identlist public typeexp default
	  BEGIN
	  PushNode[decl,3];  LinkToSource[top];
	  SetAttr[1,FALSE]; SetAttr[2,public]; public _ v[top+1];
	  SetAttr[3,FALSE];
	  END;
       63  => -- defaultopt     ::=
	  PushProperList[0];
       64  => -- defaultopt     ::= NULL
	  PushNode[void,0];
       65  => -- defaultopt     ::= exp '| NULL
	  BEGIN
	  PushNode[void,0];  PushList[2];
	  END;
       66  => -- variantpair    ::= identlist public variantpart
	  BEGIN
	  PushTree[Tree.Null];
	  PushNode[decl,3];  LinkToSource[top];
	  SetAttr[1,FALSE]; SetAttr[2,public]; public _ v[top+1];
	  SetAttr[3,FALSE];
	  END;
       67  => -- variantpart    ::= SELECT vcasehead FROM variantlist ENDCASE
              -- variantpart    ::= SELECT vcasehead FROM variantlist , ENDCASE
	  BEGIN
	  PushList[v[top+3]];  PushNode[unionTC,2];  SetAttr[1,v[top+1]];
	  END;
       68  => -- vcasehead      ::= id : public tagtype
	  BEGIN
	  PushHash[v[top]];  InsertTree[Tree.Null,3];
	  PushNode[decl,-3];  LinkToSource[top];
	  SetAttr[1,FALSE]; SetAttr[2,public]; public _ v[top+2];
	  SetAttr[3,FALSE];  vTop _ FALSE;
	  END;
       69  => -- vcasehead      ::= COMPUTED tagtype
	  BEGIN
	  AnonField[PopTree[],top];  vTop _ FALSE;
	  END;
       70  => -- vcasehead      ::= OVERLAID tagtype
	  BEGIN
	  AnonField[PopTree[],top];  vTop _ TRUE;
	  END;
       71  => -- tagtype        ::= *
	  PushNode[implicitTC,0];
       72  => -- variantitem    ::= idlist => subreclist
	  BEGIN
	  PushNode[variantTC,1];  SetAttr[1,machineDep];  SetAttr[2,v[top+2]];
	  PushTree[Tree.Null];  PushNode[typedecl,3];  LinkToSource[top];
	  SetAttr[1,TRUE]; SetAttr[2,public]; SetAttr[3,FALSE];
	  END;
       73  => -- subreclist     ::= NULL
              -- subreclist     ::= [ ]
	  BEGIN
	  PushTree[Tree.Null];  vTop _ FALSE;
	  END;
       74  => -- typelist       ::= typecons
	      -- typelist       ::= typeid
	  BEGIN
	  AnonField[PopTree[],top];
	  vTop _ -1;
	  END;
       75  => -- typelist       ::= id
	  BEGIN
	  PushHash[v[top]];  AnonField[PopTree[],top];
	  vTop _ -1;
	  END;
       76  => -- typelist       ::= typecons , typelist
	      -- typelist       ::= typeid , typelist
	  BEGIN
	  AnonField[ExtractTree[-(v[top+2]-1)],top];
	  vTop _ v[top+2]-1;
	  END;
       77  => -- typelist       ::= id , typelist
	  BEGIN
	  PushHash[v[top]];  AnonField[PopTree[],top];
	  vTop _ v[top+2]-1;
	  END;
       78  => -- pointertype    ::= pointerprefix
	  BEGIN
	  PushSe[dataPtr.idANY];  vTop _ FALSE;
	  END;
       79  => -- pointertype    ::= pointerprefix TO readonly typeexp
	  vTop _ v[top+2];
       80  => -- transfermode   ::= PROCEDURE
              -- transfermode   ::= PROC
	  vTop _ Tree.NodeName[procTC];
       81  => -- transfermode   ::= PORT
	  vTop _ Tree.NodeName[portTC];
       82  => -- transfermode   ::= SIGNAL
	  vTop _ Tree.NodeName[signalTC];
       83  => -- transfermode   ::= ERROR
	  vTop _ Tree.NodeName[errorTC];
       84  => -- transfermode   ::= PROCESS
	  vTop _ Tree.NodeName[processTC];
       85  => -- transfermode   ::= PROGRAM
	  vTop _ Tree.NodeName[programTC];
       86  => -- initialization ::=
	  BEGIN
	  PushTree[Tree.Null];  vTop _ FALSE;
	  END;
       87  => -- initvalue      ::= procaccess inline block
	  BEGIN
	  IF ~v[top+2] THEN  InsertTree[Tree.Null,2];
	  PushTree[Tree.Null];
	  PushNode[body,4];  SetAttr[1,FALSE];  SetAttr[2,FALSE];
	  SetAttr[3,v[top+1]];
	  public _ v[top];
	  END;
       88  => -- initvalue      ::= CODE
	  PushNode[signalinit,0];
       89  => -- initvalue      ::= MACHINE CODE BEGIN codelist END
	  BEGIN
	  PushProperList[v[top+3]];  PushNode[inline,1];
	  END;
       90  => -- codelist       ::= orderlist
	  BEGIN
	  PushList[v[top]];  vTop _ 1;
	  END;
       91  => -- codelist       ::= codelist ; orderlist
	  BEGIN
	  PushList[v[top+2]];  vTop _ v[top]+1;
	  END;
       92  => -- procaccess     ::=
	  BEGIN
	  vTop _ public;  public _ FALSE;
	  END;

       93  => -- statement      ::= lhs
	  BEGIN
	  sv1 _ PopTree[];  PushTree[sv1];
	  IF ~TestTree[sv1,apply]
	    THEN  BEGIN  PushTree[Tree.Null];  PushNode[apply,2]  END;
	  LinkToSource[top];
	  END;
       94  => -- statement      ::= lhs _ exp 
	  BEGIN
	  PushNode[assign,2];  LinkToSource[top];
	  END;
       95  => -- statement      ::= [ explist ] _ exp 
	  BEGIN
	  PushNode[extract,2];  LinkToSource[top];
	  END;
       96  => -- statement      ::= block 
	  BEGIN
	  IF v[top] THEN BEGIN  PushNode[block,2];  LinkToSource[top]  END;
	  sv1 _ ExtractTree[2];
	  IF sv1 # Tree.Null
	    THEN
	      BEGIN
	      PushTree[sv1];  PushNode[open,-2];  LinkToSource[top];
	      END;
	  END;
       97  => -- statement      ::= IF exp THEN statement elsepart 
	  BEGIN
	  PushNode[if,3];  LinkToSource[top];
	  END;
       98  => -- statement      ::= casehead casestmtlist ENDCASE otherpart
              -- statement      ::= casehead casestmtlist ; ENDCASE otherpart
	  BEGIN
	  sv1 _ PopTree[];  PushProperList[v[top+1]];  PushTree[sv1];
	  IF v[top] THEN PushNode[bind,4] ELSE PushNode[case,3];
	  LinkToSource[top];
	  END;
       99  => -- statement      ::= forclause dotest dohead doexit ENDLOOP 
	  BEGIN
	  PushNode[do,6];  LinkToSource[top];
	  END;
      100  => -- statement      ::= EXIT 
	  BEGIN
	  PushNode[exit,0];  LinkToSource[top];
	  END;
      101  => -- statement      ::= LOOP 
	  BEGIN
	  PushNode[loop,0];  LinkToSource[top];
	  END;
      102  => -- statement      ::= GOTO id 
	  BEGIN
	  PushHash[v[top+1]];  PushNode[goto,1];
	  LinkToSource[top];
	  END;
      103  => -- statement      ::= GO TO id 
	  BEGIN
	  PushHash[v[top+2]];  PushNode[goto,1];
	  LinkToSource[top];
	  END;
      104  => -- statement      ::= RETURN optargs
	  BEGIN
	  PushNode[return,1];  LinkToSource[top];
	  END;
      105  => -- statement      ::= transfer lhs
	  BEGIN
	  PushNode[v[top],1];  LinkToSource[top];
	  END;
      106  => -- statement      ::= WAIT lhs
	  BEGIN
	  PushNode[wait,1];  LinkToSource[top];
	  END;
      107  => -- statement      ::= ERROR
	  BEGIN
	  PushNode[syserror,0];  LinkToSource[top];
	  END;
      108  => -- statement      ::= STOP
	  BEGIN
	  PushTree[Tree.Null];  PushNode[stop,1];  LinkToSource[top];
	  END;
      109  => -- statement      ::= NULL
	  BEGIN
	  PushNode[null,0];  LinkToSource[top];
	  END;
      110  => -- statement      ::= RESUME optargs
	  BEGIN
	  PushNode[resume,1];  LinkToSource[top];
	  END;
      111  => -- statement      ::= CONTINUE
	  BEGIN
	  PushNode[continue,0];  LinkToSource[top];
	  END;
      112  => -- statement      ::= RETRY
	  BEGIN
	  PushNode[retry,0];  LinkToSource[top];
	  END;
      113  => -- statement      ::= lhs _ STATE
	  BEGIN
	  PushNode[dst,1];  LinkToSource[top];
	  END;
      114  => -- block          ::= BEGIN blockhead END 
	      -- block          ::= { blockhead }
	  vTop _ v[top+1]; 
      115  => -- block          ::= BEGIN blockhead exits END
              -- block          ::= { blockhead exits }
	  BEGIN
	  IF v[top+1]
	    THEN
	      BEGIN
	      sv1 _ PopTree[];  PushNode[block,2];  LinkToSource[top];
	      PushTree[sv1];
	      END;
	  vTop _ FALSE;  PushNode[label,2];  LinkToSource[top];
	  END;
      116  => -- blockhead       ::= open enables declist statementlist
	  BEGIN
	  IF v[top+2] = 0
	    THEN  vTop _ FALSE
	    ELSE
	      BEGIN
	      sv1 _ PopTree[]; PushList[v[top+2]]; PushTree[sv1]; vTop _ TRUE;
	      END;
	  IF v[top+1]
	    THEN
	      BEGIN
	      IF vTop
		THEN  BEGIN  PushNode[block,2];  LinkToSource[top+2]  END;
	      PushNode[enable,2];  LinkToSource[top+1];  vTop _ FALSE;
	      END;
	  END;
      117  => -- open           ::= OPEN bindlist ;
	  PushList[v[top+1]];
      118  => -- binditem       ::= exp
	  BEGIN
	  PushTree[Tree.NullId];  PushNode[item,-2];  LinkToSource[top];
	  END;
      119  => -- binditem       ::= id : exp
	  BEGIN
	  PushHash[v[top]];  PushNode[item,-2];
	  LinkToSource[top];
	  END;
      120  => -- casestmtitem   ::= caselabel => statement
	      -- caseexpitem    ::= caselabel => exp
	      -- catchcase      ::= lhslist => statement
	  BEGIN
	  sv1 _ PopTree[];
	  PushList[v[top]];  PushTree[sv1];
	  PushNode[item,2];  LinkToSource[top];
	  END;
      121  => -- casetest       ::= optrelation 
	  BEGIN
	  PushTree[Tree.Null];  PushNode[v[top],-2];
	  END;
      122  => -- casetest       ::= exp 
	  BEGIN
	  PushTree[Tree.Null];  PushNode[relE,-2];
	  END;
      123  => -- forclause      ::= FOR id _ exp , exp 
	  BEGIN
	  sv1 _ PopTree[];  sv2 _ PopTree[];
	  PushHash[v[top+1]];  PushTree[sv2];  PushTree[sv1];
	  PushNode[forseq,3];
	  END;
      124  => -- forclause      ::= FOR id direction IN range 
	  BEGIN
	  InsertTree[Tree.Null,2]; PushHash[v[top+1]]; PushNode[v[top+2],-3];
	  END;
      125  => -- forclause      ::= THROUGH range
	  BEGIN
	  InsertTree[Tree.Null,2]; PushTree[Tree.Null]; PushNode[upthru,-3];
	  END;
      126  => -- direction      ::= DECREASING 
	  vTop _ Tree.NodeName[downthru];
      127  => -- direction      ::=  
	  vTop _ Tree.NodeName[upthru];
      128  => -- dotest         ::= UNTIL exp 
	  PushNode[not,1];
      129  => -- dohead         ::= DO open enables declist statementlist
	  BEGIN
	  IF v[top+3] # 0
	    THEN
	      BEGIN
	      sv1 _ PopTree[]; PushList[v[top+3]]; PushTree[sv1];
	      PushNode[block,2];  LinkToSource[top];
	      END;
	  IF v[top+2]
	    THEN
	      BEGIN
	      PushNode[enable,2];  LinkToSource[top+2];
	      END;
	  END;
      130  => -- doexit         ::=
	  BEGIN
	  PushTree[Tree.Null];  PushTree[Tree.Null];
	  END;
      131  => -- doexit         ::= REPEAT exitlist
	      -- doexit         ::= REPEAT exitlist ;
	  BEGIN
	  PushList[v[top+1]];  PushTree[Tree.Null];
	  END;
      132  => -- doexit         ::= REPEAT exitlist ; FINISHED => statement
	      -- doexit         ::= REPEAT exitlist ; FINISHED => statement ;
	  BEGIN
	  sv1 _ PopTree[];  PushList[v[top+1]];  PushTree[sv1];
	  END;
      133  => -- doexit         ::= REPEAT FINISHED => statement
	      -- doexit         ::= REPEAT FINISHED => statement ;
	  InsertTree[Tree.Null,2];
      134  => -- exititem       ::= idlist => statement
	  BEGIN
	  PushNode[item,2];  LinkToSource[top];
	  END;
      135  => -- enables        ::= ENABLE catchitem ;
	  BEGIN
	  sv1 _ PopTree[];
	  PushList[v[top+1]];  PushTree[sv1];  PushNode[catch,2];
	  vTop _ TRUE;
	  END;
      136  => -- enables        ::= ENABLE BEGIN catchlist END ;
	  BEGIN
	  sv1 _ PopTree[];
	  PushList[v[top+2]];  PushTree[sv1];  PushNode[catch,2];
	  vTop _ TRUE;
	  END;
      137  => -- enables        ::= ENABLE BEGIN catchhead END ;
	  BEGIN
	  PushList[v[top+2]];  PushTree[Tree.Null];  PushNode[catch,2];
	  vTop _ TRUE;
	  END;
      138  => -- catchlist      ::= catchhead catchitem
	  vTop _ v[top] + v[top+1];
      139  => -- catchitem      ::= catchcase
	  BEGIN
	  PushTree[Tree.Null];  vTop _ 1;
	  END;
      140  => -- statementlist  ::= statementlist' statement
	  PushList[v[top]+1];
      141  => -- transfer       ::= SIGNAL
	  vTop _ Tree.NodeName[signal];
      142  => -- transfer       ::= ERROR
	  vTop _ Tree.NodeName[error];
      143  => -- transfer       ::= RETURN WITH ERROR
	  vTop _ Tree.NodeName[xerror];
      144  => -- transfer       ::= START
	  vTop _ Tree.NodeName[start];
      145  => -- transfer       ::= RESTART
	  vTop _ Tree.NodeName[restart];
      146  => -- transfer       ::= JOIN
	  vTop _ Tree.NodeName[join];
      147  => -- transfer       ::= NOTIFY
	  vTop _ Tree.NodeName[notify];
      148  => -- transfer       ::= BROADCAST
	  vTop _ Tree.NodeName[broadcast];
      149  => -- transfer       ::= TRANSFER WITH
	  vTop _ Tree.NodeName[lst];
      150  => -- transfer       ::= RETURN WITH
	  vTop _ Tree.NodeName[lstf];

       -- expression processing
      151  => -- keyitem        ::= id : optexp
	  BEGIN
	  PushHash[v[top]];  PushNode[item,-2];
	  END; 
      152  => -- optexp         ::= NULL
              -- initvalue      ::= NULL
	  PushNode[void,0];
      153  => -- exp            ::= transferop lhs 
          PushNode[v[top],1];
      154  => -- exp            ::= IF exp THEN exp ELSE exp 
          PushNode[ifx,3];
      155  => -- exp            ::= casehead caseexplist ENDCASE => exp 
              -- exp            ::= casehead caseexplist , ENDCASE => exp 
	  BEGIN
	  sv1 _ PopTree[];
	  PushProperList[v[top+1]];  PushTree[sv1];
	  IF v[top] THEN PushNode[bindx,4] ELSE PushNode[casex,3];
	  LinkToSource[top];
	  END;
      156  => -- exp            ::= lhs _ exp 
          PushNode[assignx,2];
      157  => -- exp            ::= ERROR 
          PushNode[syserrorx,0];
      158  => -- disjunct       ::= disjunct OR conjunct 
          PushNode[or,2];
      159  => -- conjunct       ::= conjunct AND negation 
          PushNode[and,2];
      160  => -- negation       ::= not relation 
          PushNode[not,1];
      161  => -- relation       ::= sum optrelation 
          PushNode[v[top+1],2];
      162  => -- optrelation    ::= not relationtail 
          vTop _ Tree.NodeName[SELECT Tree.NodeName[v[top+1]] FROM
	    relE => relN,
	    relN => relE,
	    relL => relGE,
	    relLE => relG,
	    relG => relLE,
	    relGE => relL,
	    in => notin,
	    notin => in,
	    ENDCASE => v[top+1]];
      163  => -- relationtail   ::= IN range 
          vTop _ Tree.NodeName[in];
      164  => -- relop          ::= = 
          vTop _ Tree.NodeName[relE];
      165  => -- relop          ::= # 
          vTop _ Tree.NodeName[relN];
      166  => -- relop          ::= < 
          vTop _ Tree.NodeName[relL];
      167  => -- relop          ::= <= 
          vTop _ Tree.NodeName[relLE];
      168  => -- relop          ::= > 
          vTop _ Tree.NodeName[relG];
      169  => -- relop          ::= >= 
          vTop _ Tree.NodeName[relGE];
      170  => -- sum            ::= sum addop product 
          PushNode[v[top+1],2];
      171  => -- addop          ::= + 
          vTop _ Tree.NodeName[plus];
      172  => -- addop          ::= - 
          vTop _ Tree.NodeName[minus];
      173  => -- product        ::= product multop factor 
          PushNode[v[top+1],2];
      174  => -- multop         ::= * 
          vTop _ Tree.NodeName[times];
      175  => -- multop         ::= / 
          vTop _ Tree.NodeName[div];
      176  => -- multop         ::= MOD 
          vTop _ Tree.NodeName[mod];
      177  => -- factor         ::= - primary 
          PushNode[uminus,1];
      178  => -- primary        ::= num 
	  PushLit[v[top]];
      179  => -- primary        ::= lnum 
	  BEGIN
	  PushLit[v[top]];  PushNode[mwconst,1];
	  END;
      180  => -- primary        ::= char 
	  BEGIN
	  PushLit[v[top]];  PushNode[clit,1];
	  END;
      181  => -- primary        ::= string 
	  PushStringLit[v[top]];
      182  => -- primary        ::= lstring 
	  BEGIN
	  PushStringLit[v[top]];  PushNode[llit,1];
	  END;
      183  => -- primary 	::= [ explist ]
	  BEGIN
	  PushTree[Tree.Null];  PushNode[apply,-2];
	  END;
      184  => -- primary        ::= prefixop [ orderlist ]
	  BEGIN
	  PushList[v[top+2]];  PushNode[v[top],1];
	  END;
      185  => -- primary        ::= typeop [ typeexp ]
          PushNode[v[top],1];
      186  => -- primary        ::= INTEGER [ explist ] 
	  BEGIN
	  PushSe[dataPtr.idINTEGER];  PushNode[apply,-2];
	  END;
      187  => -- primary        ::= CARDINAL [ explist ] 
	  BEGIN
	  PushSe[dataPtr.idCARDINAL];  PushNode[apply,-2];
	  END;
      188  => -- primary        ::= @ lhs
	  PushNode[addr,1];
      189  => -- primary        ::= DESCRIPTOR [ desclist ]
	  PushNode[arraydesc,1];
      190  => -- lhs            ::= id 
	  PushHash[v[top]];
      191  => -- lhs            ::= LOOPHOLE [ exp ]
	  BEGIN
	  PushTree[Tree.Null]; PushNode[loophole,2];
	  END;
      192  => -- lhs            ::= LOOPHOLE [ exp , typeexp ]
	  PushNode[loophole,2];
      193  => -- qualifier      ::= [ explist ]
	  PushNode[apply,2];
      194  => -- qualifier      ::= [ explist ! catchlist ]
	  BEGIN
	  sv1 _ PopTree[];
	  PushList[v[top+3]];  PushTree[sv1];  PushNode[catch,2];
	  PushNode[apply,3];
	  END;
      195  => -- qualifier      ::= . id
	  BEGIN
	  PushHash[v[top+1]];  PushNode[dot,2];
	  END;
      196  => -- qualifier      ::= ^
	  PushNode[uparrow,1];
      197  => -- transferop     ::= SIGNAL
	  vTop _ Tree.NodeName[signalx];
      198  => -- transferop     ::= ERROR
	  vTop _ Tree.NodeName[errorx];
      199  => -- transferop     ::= START
	  vTop _ Tree.NodeName[startx];
      200  => -- transferop     ::= JOIN
	  vTop _ Tree.NodeName[joinx];
      201  => -- transferop     ::= NEW 
          vTop _ Tree.NodeName[new];
      202  => -- transferop     ::= FORK
	  vTop _ Tree.NodeName[fork];
      203  => -- prefixop       ::= LONG 
          vTop _ Tree.NodeName[lengthen];
      204  => -- prefixop       ::= ABS 
          vTop _ Tree.NodeName[abs];
      205  => -- prefixop       ::= MIN 
          vTop _ Tree.NodeName[min];
      206  => -- prefixop       ::= MAX 
          vTop _ Tree.NodeName[max];
      207  => -- prefixop       ::= BASE
	  vTop _ Tree.NodeName[base];
      208  => -- prefixop       ::= LENGTH
	  vTop _ Tree.NodeName[length];
      209  => -- prefixop       ::= ALL
	  vTop _ Tree.NodeName[all];
      210  => -- typeop         ::= CODE
	  BEGIN
	  vTop _ Tree.NodeName[typecode];
	  dataPtr.nTypeCodes _ dataPtr.nTypeCodes + 1;
	  END;
      211  => -- typeop         ::= SIZE
	  vTop _ Tree.NodeName[size];
      212  => -- typeop         ::= FIRST
	  vTop _ Tree.NodeName[first];
      213  => -- typeop         ::= LAST
	  vTop _ Tree.NodeName[last];
      214  => -- desclist       ::= exp , exp
	  BEGIN
	  PushTree[Tree.Null];  PushList[3];
	  END;
      215  => -- desclist       ::= exp , exp , typeexp
	  PushList[3];
      216  => -- pointerprefix  ::= POINTER
	  BEGIN
	  PushTree[Tree.Null];  vTop _ 1;
	  END;
      217  => -- declist        ::= 
	      -- catchitem      ::= ANY => statement
	  vTop _ 0;
      218  => -- includelist    ::= includeitem
	      -- modulelist     ::= moduleitem
	      -- pairlist       ::= pairitem
	      -- variantlist    ::= variantitem
	      -- bindlist       ::= binditem
	      -- statementlist' ::= statement ; 
	      -- casestmtlist   ::= casestmtitem
	      -- caselabel      ::= casetest 
	      -- exitlist       ::= exititem
	      -- catchhead      ::= catchcase ;
	      -- lhslist        ::= lhs
	      -- orderlist      ::= optexp 
	      -- keylist        ::= keyitem 
	      -- caseexplist    ::= caseexpitem
	  vTop _ 1;
      219  => -- includelist    ::= includelist , includeitem
	      -- modulelist     ::= modulelist , moduleitem
	      -- declist        ::= declist declaration ; 
	      -- pairlist       ::= pairlist , pairitem
	      -- 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
	  vTop _ v[top]+1;
      220  => -- idlist         ::= idlist'
	      -- identlist      ::= identlist'
	      -- statementlist  ::= statementlist'
	      -- explist        ::= orderlist
	      -- explist        ::= keylist
	  PushList[v[top]];
      221  => -- imports        ::= IMPORTS modulelist
	      -- fieldlist      ::= [ pairlist ]
	      -- fieldlist      ::= [ typelist ]
	      -- exits          ::= EXITS exitlist
	      -- exits          ::= EXITS exitlist ;
	  PushList[v[top+1]];
      222  => -- array		::= ARRAY
	      -- initialization ::= _ initvalue
	      -- casehead       ::= SELECT exp FROM
	  vTop _ FALSE;
      223  => -- readonly       ::= READONLY
	      -- ordered        ::= ORDERED
	      -- base           ::= BASE
	      -- array		::= PACKED ARRAY
	      -- initialization ::= = initvalue
	      -- inline		::= INLINE
	      -- casehead       ::= WITH binditem SELECT optexp FROM
	  vTop _ TRUE;
      224  => -- readonly       ::=
	      -- monitored      ::=
	      -- ordered        ::=
	      -- base           ::=
	      -- inline		::=
	      -- enables        ::=
	  BEGIN
	  vTop _ FALSE;  l[top] _ P1.InputLoc[];
	  END;
      225  => -- using          ::= USING [ idlist ]
	      -- interface      ::= imports exports shares
	      -- exports        ::= EXPORTS idlist 
	      -- shares	        ::= SHARES idlist 
	      -- typeexp        ::= typeid 
	      -- typeexp        ::= typecons 
	      -- default        ::= _ defaultopt 
	      -- defaultopt     ::= exp 
	      -- tagtype        ::= typeexp 
	      -- subreclist     ::= reclist 
	      -- pointerprefix  ::= POINTER interval 
	      -- indextype      ::= typeexp 
	      -- arguments      ::= arglist returnlist 
	      -- arglist        ::= fieldlist 
	      -- returnlist     ::= RETURNS fieldlist 
	      -- initvalue      ::= exp 
	      -- elsepart       ::= ELSE statement 
	      -- otherpart      ::= => statement 
	      -- dotest         ::= WHILE exp 
	      -- catchlist      ::= catchitem 
	      -- statementlist  ::= statement 
	      -- optargs        ::= [ explist ] 
	      -- optexp         ::= exp 
	      -- exp            ::= disjunct 
	      -- disjunct       ::=C conjunct 
	      -- conjunct       ::=C negation 
	      -- negation       ::=C relation 
	      -- not            ::= ~ 
	      -- not            ::= NOT 
	      -- relation       ::=C sum 
	      -- optrelation    ::= relationtail 
	      -- relationtail   ::= relop sum 
	      -- range          ::= interval 
	      -- range          ::= typeid 
	      -- bounds         ::= exp .. exp 
	      -- sum            ::=C product 
	      -- product        ::=C factor 
	      -- factor         ::=C primary 
	      -- primary        ::=C lhs 
	      -- desclist       ::= exp 
	      -- lhs            ::= ( exp ) 
	      -- lhs            ::= lhs qualifier 
	  NULL;
      226  => -- directory      ::= 
	      -- using          ::= 
	      -- locks          ::= 
	      -- imports        ::= 
	      -- exports        ::= 
	      -- shares         ::= 
	      -- default        ::= 
	      -- open           ::=
	      -- arglist        ::= 
	      -- returnlist     ::= 
	      -- indextype      ::=
	      -- elsepart       ::=
	      -- otherpart      ::=
	      -- statementlist  ::= 
	      -- forclause      ::= 
	      -- dotest         ::= 
	      -- optargs        ::= 
	      -- optexp         ::=
	  BEGIN
	  PushTree[Tree.Null];  vTop _ 1;  l[top] _ P1.InputLoc[];
	  END;

       -- error or unimplemented
	ENDCASE =>  ERROR;

      v[top] _ vTop;
      ENDLOOP;
    END;

    DetachItem: Tree.Map =
      BEGIN
      PushTree[t];  RETURN [Tree.Null]
      END;


 -- shared processing routines

  AnonField: PROCEDURE [type: Tree.Link, top: CARDINAL] =
    BEGIN
    PushTree[Tree.NullId];  PushTree[type];  PushTree[Tree.Null];
    PushNode[decl,3];  LinkToSource[top];
    SetAttr[1,FALSE];  SetAttr[2,public];  SetAttr[3,FALSE];
    END;


 -- error recovery

  TokenValue: PUBLIC PROCEDURE [s: ParseTable.TSymbol] RETURNS [UNSPECIFIED] =
    BEGIN
    OPEN ParseTable;
    RETURN [SELECT s FROM
      tokenID => Symbols.HTNull,
      ENDCASE => 0]
    END;

  END.