-- file DIPack.Mesa rewritten by PGS, 25-Oct-80 21:06
-- file DIPack.Mesa modified by
--                  Sandman, January 16, 1979  3:59 PM
--                  Barbara, September 26, 1978  10:34 AM
--                  Bruce, October 25, 1980  7:50 PM

DIRECTORY
  ComData USING [idANY, idBOOL, idCARDINAL, idCHAR, idINT, idREAL, idSTRING],
  DebugOps USING [ParseError],
  DIActions USING [
    exp, memoryInt, arrayInt, conditionalBreak, eol, frameDollar, fileDollar, typeDollar,
    card, lcard, int, lint, bang, memory, reps],
  P1 USING [],
  ParseTable USING [ActionEntry, ProductionInfo],
  Tree USING [NodeName, Null],
  TreeOps USING [PushHash, PushList, PushLit, PushNode, PushSe, PushStringLit, PushTree];
  
Pass1T: PROGRAM
  IMPORTS dataPtr: ComData, DebugOps, TreeOps
  EXPORTS P1 =
  BEGIN OPEN DIActions, P1, TreeOps;
  
  
  q: DESCRIPTOR FOR ARRAY OF ParseTable.ActionEntry;
  v: DESCRIPTOR FOR ARRAY OF UNSPECIFIED;
  l: DESCRIPTOR FOR ARRAY OF CARDINAL;
  proddata: DESCRIPTOR FOR ARRAY OF ParseTable.ProductionInfo;
  
  AssignDescriptors: PUBLIC PROCEDURE [
      lq: DESCRIPTOR FOR ARRAY OF ParseTable.ActionEntry,
      lv: DESCRIPTOR FOR ARRAY OF UNSPECIFIED,
      ll: DESCRIPTOR FOR ARRAY OF CARDINAL,
      lproddata: DESCRIPTOR FOR ARRAY OF ParseTable.ProductionInfo] =
    BEGIN q _ lq; v _ lv; l _ ll; proddata _ lproddata END;
    
  ProcessQueue: PUBLIC PROCEDURE [qI, top: CARDINAL] =
    BEGIN
    rule: [0..256);
    i: CARDINAL;
    vTop: UNSPECIFIED;
    FOR i IN [0..qI) DO
      top _ top-q[i].tag.pLength+1;  vTop _ v[top];
      rule _ proddata[q[i].transition].rule;
      SELECT rule FROM
      
      0  => --BINARY: DIGrammar.bcd  INTERFACE: Init  MODULE: ParseTable.mesa
	--GOAL:  goal
	
	--TERMINALS:
	--    id  num  lnum  card lcard string  char
	--    ,   ;   _   +   -   *   /   ^   .   @    $   %
	--    =   #   <  >   <=   >=      
	--    INTEGER  CARDINAL  CHARACTER  BOOLEAN  REAL
	--    POINTER  DESCRIPTOR  LONG  TO  BASE
	--    ABS  MAX  MIN  MOD  LENGTH
	--    LOOPHOLE  SIZE  FIRST  LAST
	--    )   ]   (   [
	--    STRING  UNSPECIFIED  MEMORY  !   \   ..   '?
	--    WORD  PROCEDURE  PROC  ERROR  SIGNAL
	--    NIL
	
	--ALIASES:
	--  id       tokenID
	--  num      tokenNUM
	--  lnum     tokenLNUM
	--  card     tokenCARD
	--  lcard    tokenLCARD
	--  string   tokenSTR
	--  char     tokenCHAR
	--  -        tokenMINUS
	--  .        tokenDOT
	--  ..       tokenDOTS
	--  =        tokenEQUAL
	--  <        tokenLESS
	--  <=       tokenLE
	--  >        tokenGREATER
	--  >=       tokenGE
	--  eof      endmarker
	
	--  PRODUCTIONS:
	
	--  goal					::= stmtlist \
	PushNode[eol,1];  -- all finished
	
      1  => -- stmtlist				::= statementlist 
	    -- stmtlist					::= statementlist ;
	  BEGIN
	  PushList[v[top]];  PushNode[block,1];
	  END;
	  
      2  => -- statementlist				::= statementlist ; statement
	BEGIN
	-- clear the way for the next statement 
	vTop _ v[top]+1; PushNode[eol,1];
	END;
	
      3  => -- statement				::= lhs _ exp
	  PushNode[assign,2];
	  
      4  => -- statement				::= exp
	  PushNode[exp,1];
	  
      5  => -- statement				::= exp '?
	  PushNode[reps,1];
	  
      6  => -- statement				::= MEMORY interval
	  PushNode[memoryInt,1];
	  
      7  => -- statement				::= lhs interval
	  PushNode[arrayInt,2];
	  
      8  => -- statement				::= relation
	  PushNode[conditionalBreak,1];
	  
      9  => -- typeexp					::= id
	  PushHash[v[top]];
	  
      10  => -- typeid					::= INTEGER
	  PushSe[dataPtr.idINT];
      11  => -- typeid					::= CARDINAL
	  PushSe[dataPtr.idCARDINAL];
      12  => -- typeid					::= CHARACTER
	  PushSe[dataPtr.idCHAR];
      13  => -- typeid					::= BOOLEAN
	  PushSe[dataPtr.idBOOL];
      14  => -- typeid					::= REAL
	  PushSe[dataPtr.idREAL];
      15  => -- typeid					::= STRING
	  PushSe[dataPtr.idSTRING];
      16  => -- typeid					::= UNSPECIFIED
	  PushSe[dataPtr.idANY];
      17  => -- typeid					::= WORD
	  PushSe[dataPtr.idANY];
	  
      18  => -- typeid					::= PROCEDURE
	    -- typeid					::= PROC
	  BEGIN
	  PushTree[Tree.Null]; PushNode[procTC,1];
	  END;
      19  => -- typeid					::= ERROR
	  BEGIN
	  PushTree[Tree.Null]; PushNode[errorTC,1];
	  END;
      20  => -- typeid					::= SIGNAL
	  BEGIN
	  PushTree[Tree.Null]; PushNode[signalTC,1];
	  END;
	  
      21  => -- typeid					::= id . id
	  BEGIN
	  PushHash[v[top]];  PushHash[v[top+2]];
	  PushNode[typeDollar,2];
	  END;
	  
      22  => -- typeid					::= id id
	  BEGIN
	  PushHash[v[top+1]];  PushHash[v[top]];
	  PushNode[discrimTC,2];
	  END;
	  
      23  => -- typeid					::= id typeid
	  BEGIN
	  PushHash[v[top]];  PushNode[discrimTC,2];
	  END;
	  
      24  => -- typeid					::= id $ id
	  BEGIN
	  PushHash[v[top]];  PushHash[v[top+2]];
	  PushNode[typeDollar,2];
	  END;
	  
      25  => -- typecons				::= POINTER TO typeexp
	    -- typecons					::= @ typeexp
	  PushNode[pointerTC,1];
	  
      26  => -- typecons				::= LONG typeexp
	  PushNode[longTC,1];
	  
      27  => -- sum					::= sum addop product
	    -- relation					::= sum relationtail 
	  PushNode[v[top+1],2];
	  
      28  => -- addop					::= +
	  vTop _ Tree.NodeName[plus];
      29  => -- addop					::= - 
	  vTop _ Tree.NodeName[minus];
	  
      30  => -- relop					::= = 
	  vTop _ Tree.NodeName[relE];
      31  => -- relop					::= # 
	  vTop _ Tree.NodeName[relN];
      32  => -- relop					::= < 
	  vTop _ Tree.NodeName[relL];
      33  => -- relop					::= <= 
	  vTop _ Tree.NodeName[relLE];
      34  => -- relop					::= > 
	  vTop _ Tree.NodeName[relG];
      35  => -- relop					::= >= 
	  vTop _ Tree.NodeName[relGE];
	  
      36  => -- product					::= product multop factor 
	  PushNode[v[top+1],2];
	  
      37  => -- multop					::= * 
	  vTop _ Tree.NodeName[times];
      38  => -- multop					::= / 
	  vTop _ Tree.NodeName[div];
      39  => -- multop					::= MOD 
	  vTop _ Tree.NodeName[mod];
	  
      40  => -- factor					::= - primary 
	  PushNode[uminus,1];
	  
      41  => -- primary					::= num
	  BEGIN
	  PushLit[v[top]];  PushNode[int,1]
	  END;
	  
      42  => -- primary					::= lnum 
	  BEGIN
	  PushLit[v[top]];  PushNode[mwconst,1];
	  PushNode[lint,1];
	  END;
	  
      43  => -- primary					::= card
	  BEGIN
	  PushLit[v[top]];  PushNode[card,1];
	  END;
	  
      44  => -- primary					::= lcard 
	  BEGIN
	  PushLit[v[top]];  PushNode[mwconst,1];
	  PushNode[lcard,1];
	  END;
	  
      45  => -- primary					::= char
	  BEGIN
	  PushLit[v[top]];  PushNode[clit,1];
	  END;
	  
      46  => -- primary					::= string 
	  PushStringLit[v[top]];
	  
      47  => -- primary					::= NIL
	  BEGIN
	  PushTree[Tree.Null]; PushNode[nil,1];
	  END;
	  
      48  => -- primary					::= NIL [ typeexp ]
	  PushNode[nil,1];
	  
      49  => -- primary					::= prefixop [ explist ] 
	  BEGIN
	  PushList[v[top+2]];  PushNode[v[top],1];
	  END;
	  
      50  => -- primary					::= typeop [ typeexp ] 
	  PushNode[v[top],1];
	  
      51  => -- primary 					::= @ lhs
	  PushNode[addr,1];
	  
      52  => -- primary					::= DESCRIPTOR [ desclist ] 
	  PushNode[arraydesc,1];
	  
      53  => -- primary					::= primary %
	  BEGIN
	  PushTree[Tree.Null]; PushNode[loophole,2];
	  END;
	  
      54  => -- primary					::= primary % ( typeexp )
	  PushNode[loophole,2];
	  
      55  => -- lhs					::= id 
	  PushHash[v[top]];
	  
      56  => -- lhs					::= LOOPHOLE [ exp ]  
	  BEGIN
	  PushTree[Tree.Null]; PushNode[loophole,2];
	  END;
	  
      57  => -- lhs					::= LOOPHOLE [ exp , typeexp ]  
	  PushNode[loophole,2];
	  
      58  => -- lhs					::= MEMORY [ exp ] 
	  PushNode[memory,1];
	  
      59  => -- lhs					::= id $ id 
	  BEGIN
	-- go to file named by first id to lookup second id 
	  PushHash[v[top]];  PushHash[v[top+2]];
	  PushNode[fileDollar,2];
	  END;
	  
      60  => -- lhs					::= num $ id 
	    -- lhs					::= card $ id
	  BEGIN
	-- go to frame named by first id to lookup second id 
	  PushLit[v[top]];  PushHash[v[top+2]];
	  PushNode[frameDollar,2];
	  END;
	  
      61  => -- qualifier					::= [ explist ]
	  BEGIN
	  PushList[v[top+1]]; PushNode[apply,2];
	  END;
	  
      62  => -- qualifier					::= . id 
	  BEGIN
	  PushHash[v[top+1]];  PushNode[dot,2];
	  END;
	  
      63  => -- qualifier					::= ^ 
	  PushNode[uparrow,1];
	  
      64  => -- prefixop					::= LONG 
	  vTop _ Tree.NodeName[lengthen];
      65  => -- prefixop					::= ABS 
	  vTop _ Tree.NodeName[abs];
      66  => -- prefixop					::= MIN 
	  vTop _ Tree.NodeName[min];
      67  => -- prefixop					::= MAX 
	  vTop _ Tree.NodeName[max];
      68  => -- prefixop					::= BASE 
	  vTop _ Tree.NodeName[base];
      69  => -- prefixop					::= LENGTH 
	  vTop _ Tree.NodeName[length];
	  
      70  => -- typeop					::= SIZE 
	  vTop _ Tree.NodeName[size];
      71  => -- typeop					::= FIRST 
	  vTop _ Tree.NodeName[first];
      72  => -- typeop					::= LAST 
	  vTop _ Tree.NodeName[last];
	  
      73  => -- interval					::= [ bounds ]
	  PushNode[intCC,1];
      74  => -- interval					::= [ bounds )
	  PushNode[intCO,1];
      75  => -- interval					::= ( bounds ]
	  PushNode[intOC,1];
      76  => -- interval					::= ( bounds )
	  PushNode[intOO,1];
      77  => -- interval					::= [ exp ! exp ]
	  BEGIN
	  PushList[2];  PushNode[bang,1];
	  END;
	  
      78  => -- bounds					::= exp .. exp
	  PushList[2];
	  
      79  => -- desclist					::= exp , exp 
	  BEGIN
	  PushTree[Tree.Null];  PushList[3];
	  END;
	  
      80  => -- desclist					::= exp , exp , typeexp 
	  PushList[3];
	  
      81  => -- typeexp					::= typeid
	    -- typeexp					::= typecons
	    -- desclist					::= exp 
	    -- exp					::= sum
	    -- sum					::= product
	    -- product					::= factor
	    -- factor					::= primary 
	    -- primary					::= lhs
	    -- lhs					::= ( exp )  
	    -- lhs					::= lhs qualifier 
	    -- relationtail				::= relop sum 
	  NULL;
	  
      82  => -- explist					::= exp
	    -- statementlist				::= statement
	  vTop _ 1;
	  
      83  => -- explist					::= explist , exp
	  vTop _ v[top]+1;
	  
      84  => -- explist					::= 
	  vTop _ 0;  -- empty expression list
	  
      ENDCASE => SIGNAL DebugOps.ParseError[l[top]]; -- error or unimplemented
      
      v[top] _ vTop;
    ENDLOOP;
    RETURN
    END;
    
  END.