home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / compcomp / yacc / y1.c < prev    next >
Encoding:
Text File  |  1991-11-17  |  46.3 KB  |  1,379 lines
  1. /************************************************************************/
  2. /*                              y1.c                                    */  
  3. /*  YACC source file #1 (of 4).                                         */  
  4. /************************************************************************/  
  5.    
  6. /************************************************************************/  
  7. /*                              contents                                */  
  8. /*                                                                      */  
  9. /*    y1ArrayFill    Set elements 0 through n-1 to c.        */
  10. /*  * y1CharCopy        Copy str q into p, returning next free char ptr.*/
  11. /*  * y1CheckEmpty    Mark nonterminals which derive the empty string.*/
  12. /*    y1Closure     Generate the closure of state i.        */
  13. /*    y1Error           Write out fatal error comment.                  */
  14. /*  * y1First        Compute an array with the FIRSTS of nonterminals*/
  15. /*    y1GetChar     Get one input char.                */
  16. /*  * y1Lookahead       Return lookahead set.                           */
  17. /*  * y1MakeStates      Generate the states.                            */
  18. /*    main                                */
  19. /*  * y1PrintLookahead    Print lookahead.                */
  20. /*    y1PutItem                             */
  21. /*  * y1PutRest     Put out other arrays, copy the parsers.     */
  22. /*  * y1SetUnion    A gets union of A and B.            */
  23. /*    y1State        Sort last state, check it, return state #.    */
  24. /*  * y1Summary     Write the summary on the terminal.        */
  25. /*    y1SymbolName    Return a pointer to the name of symbol i.    */
  26. /*    y1UngetChar    Unget one char.                 */
  27. /*    y1WriteItem    Creates output string for item pointed to by pp.*/
  28. /*  * y1Yield           List productions YIELDING each nonterminal.     */
  29. /*                                    */
  30. /* * Local to this file.                                                */
  31. /*                                    */
  32. /************************************************************************/
  33.    
  34. /************************************************************************/  
  35. /*                              history                                 */  
  36. /*                                                                      */  
  37. /* 85Nov14 CrT  Global variable names decrypted.                        */
  38. /* 85Nov13 CrT    Give plaintiff routine in error messages.        */
  39. /* 85Nov11 CrT  Function names decrypted. Still unique in first 6 chars.*/
  40. /* 85Nov10 CrT    y1.c reconstructed from 18 (!) subfiles.  Cosmetics.    */
  41. /* 83Dec25 SG    Questions and suggestions on the IBM PC version of YACC */
  42. /*              can be directed to Scott Guthery, 11100 Leafwood Lane,  */ 
  43. /*              Austin, Texas,  78750.  Telephone: 512 258-1342.        */ 
  44. /*                                                                      */ 
  45. /* 83Dec25 SG   Added #ifdef UNION entries in yypars.c so that YACC     */ 
  46. /*              can be used with C compilers that do not support the    */ 
  47. /*              assignment of unions and structures.  If you use        */ 
  48. /*              the %union construct (see LANDY.Y for example) and your */ 
  49. /*              C compiler doesn't support union assignment, then       */ 
  50. /*              you have to write a routine                             */ 
  51. /*                           yyunion(to, from)                          */ 
  52. /*                           YYSTYPE *to, *from;                        */ 
  53. /*              which achieves the assignment of the %union.  If your   */ 
  54. /*              C compiler does support structure and union assignment  */ 
  55. /*              then undefine UNION in yypars.c.                        */ 
  56. /*                                                                      */ 
  57. /* 83Dec25 SG   Adapted YACC for IBM PC using the DeSmet C compiler.    */ 
  58. /*                                                                      */ 
  59. /* 83Apr12 RBD  Add symbolic exit status.                               */  
  60. /* 83Apr12 RBD    Additions and minor changes for running YACC under    */
  61. /*              VAX-11 C.  The newer versions of the files in this      */ 
  62. /*              UIC are the proper ones, and should run OK under        */ 
  63. /*              RSX & RT.  I have not purged the old ones because       */ 
  64. /*              I have not tested the new ones.                         */ 
  65. /*                                                                      */ 
  66. /* 82Mar22 RBD  Minor changes to accommodate the new DECUS library and  */ 
  67. /*              compiler. Command file changed to take advantage of the */ 
  68. /*              '-m' switch to disable the preprocessor phase of the    */ 
  69. /*              compiler, since MP is used.  'iovtoa()' changed to      */ 
  70. /*              'fgetname()'.  ODL slightly changed.  Added header to   */ 
  71. /*              output file to tell the name of the input file and the  */ 
  72. /*              date and time of generation.                            */ 
  73. /*                                                                      */ 
  74. /* 81Aug28 RBD  Changed to make debug code conditionally compile.       */
  75. /*                                                                      */ 
  76. /* 81Aug28 RBD    All of the debug stuff has been turned off. This makes    */
  77. /*              for a much easier to read YACC.OUT file.                */ 
  78. /*                                                                      */ 
  79. /* 81Aug28 RBD    The options accepted by Yacc have been changed. The    */
  80. /*              changes were all in YSETUP.2C. See the docs.            */ 
  81. /*                                                                      */ 
  82. /* 81Aug28 RBD  In using YACC with Forsythe's LEX, the variable         */ 
  83. /*              "yylval" was found to be declared in both YACC's        */ 
  84. /*              output c source (yypars()) and in LEX. Apparently, the  */ 
  85. /*              UNIX LEX assumes that yylval is in YACC. Because LEX    */ 
  86. /*              sees so much use with other than YACC, we chose to      */ 
  87. /*              leave yylval declared in LEX. So the YACC module        */ 
  88. /*              YSETUP.2C was modified to emit "extern YYSTYPE yylval"  */ 
  89. /*              when compiled by the Decus compiler or MP processor.    */ 
  90. /*                                                                      */ 
  91. /* 81Aug28 RBD  Much has happened since the last entry. Yacc has been   */ 
  92. /*              brought up on RSX-11M, along with changes in the        */ 
  93. /*              command string outlined below.                          */ 
  94. /*                                                                      */ 
  95. /* 80Dec18 RBD    Add conditional code for Decus for tempfile deletion.    */
  96. /* 80Dec06 RBD  Original code broken out of y1.c.                       */ 
  97. /* 80Dec05 RBD    MP has been fixed. Note the 'beauty' prettyprinter    */
  98. /*              was distributed in this UIC, but it's been deleted.     */ 
  99. /*                                                                      */ 
  100. /* 80Dec04 RBD  Include files and their names need looking at.          */ 
  101. /* 80Dec04 RBD  MP preprocessor inserts a ' ' at the beginning of       */ 
  102. /*              a text substitution. Otherwise, it looks like it        */ 
  103. /*              does the right stuff!                                   */ 
  104. /* 80Dec04 RBD  Variable declarations inside statements exist.          */ 
  105. /*                                                                      */ 
  106. /* 7?????? SCJ    Created.                        */
  107. /*                                                                      */  
  108. /*                                                                      */  
  109. /*                              credits                                 */
  110. /*      CrT=CrT                                                         */
  111. /*      RBD=Bob Denny                                                   */ 
  112. /*      SCJ=Steven C Johnson.                                           */ 
  113. /*      SG =Scott Guthery                                               */ 
  114. /*                                    */
  115. /************************************************************************/
  116.  
  117.  
  118.  
  119. #include <stdio.h>
  120. #include "system.h"
  121. #include "dtxtrn.h"
  122.                           
  123.  
  124.  
  125. # define EMPTY      1
  126. # define WHOKNOWS 0
  127. # define OK      1
  128.  
  129.  
  130. /* The default actions of states. */
  131. extern int   y3DefaultAction[ MAXsTATES ];
  132.  
  133. /* Character stack shared by y1GetChar and y1UngetChar: */
  134. static char   y1GetStack[ 30 ],   *y1TopStack = y1GetStack;
  135.  
  136.  
  137.  
  138.  
  139. /* Lookahead computations: */
  140.                                                    
  141. /********************************************************/
  142. /* Size of lookahead sets in words. Lookahead sets are    */
  143. /* represented by bit vectors with one bit for each    */
  144. /* terminal in the grammar -- this makes set unions a    */
  145. /* simple matter of ORing two bit vectors together. On    */
  146. /* large grammars, YACC spends most of its time doing    */
  147. /* set unions.                        */
  148. /********************************************************/
  149. int y1MaxLookaheadSet;
  150.  
  151. struct looksets y1LookaheadSet [ MAXy1lOOKAHEADsETS ];
  152.  
  153. /* Next lookahead set to allocate: */
  154. static int y1NextLookaheadSet  = 0;
  155.  
  156. /* Flag to suppress lookahead computations: */
  157. int y1NoLookahead = FALSE;
  158.  
  159. /* Temporary storage for lookahead computations: */
  160. static struct looksets y1ClosureSet;
  161.  
  162.  
  163.  
  164. /* Working set computations: */
  165.                                                    
  166. struct wset y1WorkingSet[ MAXy1wORKINGsET];
  167. struct wset *y1ThisWorkingSet;
  168.                                                    
  169.  
  170.  
  171. /* State information: */
  172.                                                    
  173. /* Number of states so far: */
  174. int y1NextState = 0;
  175.  
  176. /* States generated by terminal gotos: */
  177. int y1TerminalState[    MAXtERMINALsTATES    ];
  178.  
  179. /* States generated by nonterminal gotos: */
  180. int y1NonterminalState[ MAXnONTERMINALsTATES ];
  181.  
  182. /* Type information about the states: */
  183. int y1StateType[   MAXsTATES ];
  184.  
  185. /* Index to the stored goto table: */
  186. int y1GotoIndex[   MAXsTATES ];
  187.  
  188. /* [Non/]term generation lists overflow chain:    */
  189. static int y1Link[ MAXsTATES ];
  190.  
  191. /* State-description pointers: */
  192. struct item *y1StateItem[ MAXsTATES +2 ];
  193.  
  194.  
  195.  
  196. /* Storage for the actions in the parser: */
  197.                                                    
  198. /* Action table storage: */
  199. int y1Action[ MAXaCTIONS ];
  200.  
  201. /* Next free action table position: */
  202. int *y1NextAction = y1Action;
  203.  
  204.  
  205.  
  206. /* Other storage areas: */
  207.                                                    
  208. /* Scratch area andexed variously by terms+y2NextTerminal or states: */
  209. int y1Temp[ MAXy1TEMP ];
  210.  
  211. /* Current input line number: */
  212. int y1LineNumber = 1;
  213.  
  214. /* Signal to y1Error(): If y1ErrorsFatal, errors are fatal: */
  215. static int y1ErrorsFatal = TRUE;
  216.  
  217. /* Number of errors: */
  218. int y1Errors = 0;
  219.  
  220.  
  221.                                                    
  222. /* Storage for information about the nonterminals: */
  223.                                                    
  224. /* Productions yielding each nonterminal (Ptrs):*/
  225. static int **y1YieldedBy[       MAXnONTERMINALsTATES +2 ];
  226.  
  227. /* FIRST sets for nonterminals: */
  228. static struct looksets *y1FirstOf[ MAXnONTERMINALsTATES +2 ];
  229.  
  230. /* Nonterminals nontrivially deriving <empty>: */
  231. static int y1YieldsEmpty[       MAXnONTERMINALsTATES +1 ];
  232.  
  233.  
  234.  
  235. /* Storage for statistics: */
  236.                                                    
  237. static struct wset * y1LastWorkingSet         = y1WorkingSet;
  238. int             y1GotoEntries         =          0;
  239. int             y1GotosSavedByDefault   =          0;
  240.  
  241. int             y1ShiftEntries         =          0;
  242. int             y1Exceptions         =          0;
  243. static int         y1ClosuresDone         =          0;
  244.  
  245. int             y1ShiftReduceConflicts  =          0;
  246. int             y1ReduceReduceConflicts =          0;
  247. static        *         y1Nexty2PoolLoc         =         y2Pool;
  248.  
  249.  
  250.  
  251.  
  252.  
  253. /************************************************************************/
  254. /*    y1ArrayFill    Set elements 0 through n-1 to c         */
  255. /************************************************************************/
  256. y1ArrayFill( v, n, c )
  257. int *v,n,c;
  258. {
  259.     register int i;
  260.     for( i = n;   i--;    )   v[i] = c;
  261. }
  262.  
  263. /************************************************************************/
  264. /*    y1CharCopy    Copy string q into p, returning next free char ptr. */ 
  265. /************************************************************************/ 
  266. static char *y1CharCopy( p, q )
  267. char *p, *q; 
  268. { 
  269.     while (*p++ = *q++);
  270.   
  271.     return( --p ); 
  272. } 
  273.   
  274.   
  275. /************************************************************************/
  276. /*    y1CheckEmpty    Mark nonterminals which derive the empty string.*/
  277. /************************************************************************/
  278. static y1CheckEmpty() {
  279.  
  280.     /****************************************************************/
  281.     /* Mark nonterminals which derive the empty string.         */
  282.     /* Look for nonterminals which don't derive any token strings.  */
  283.     /****************************************************************/
  284.  
  285.     register i, *p;
  286.  
  287.  
  288.  
  289.     /************************************************************/
  290.     /* First, use the array y1YieldsEmpty to detect productions */
  291.     /* that can NEVER be reduced:                */
  292.     /************************************************************/
  293.  
  294.  
  295.  
  296.     y1ArrayFill( y1YieldsEmpty, y2LastNonterminal+1, WHOKNOWS );
  297.  
  298.     /* Now, look at productions, marking    */
  299.     /* nonterminals which derive something: */
  300.  
  301. more:
  302.     FORaLLpRODUCTIONS(0,i) {
  303.  
  304.         /***********************************************************/
  305.     /* Check nonterminal defined by this production.  If we    */
  306.     /* already know that nonterminal derives the empty string, */
  307.     /* skip to next production:                   */
  308.         /***********************************************************/
  309.     if( y1YieldsEmpty[ *y2Production[i] - FIRSTnONTERMINAL ] ) continue;
  310.  
  311.         /************************************************/
  312.     /* Scan RHSide of production. Stop if we reach    */
  313.     /* a nonterminal not known to derive something: */
  314.         /************************************************/
  315.     for (p = y2Production[i] +1;   *p >= 0;   ++p) {
  316.         if (
  317.         *p >= FIRSTnONTERMINAL
  318.         &&
  319.         y1YieldsEmpty[ *p-FIRSTnONTERMINAL ] == WHOKNOWS
  320.         ) {
  321.         break;
  322.         }
  323.         }
  324.  
  325.     /* See if we reached end of production: */
  326.     if (*p < 0)  {
  327.  
  328.          /*********************************************************/
  329.              /* Reached end of rule without finding any problematical */
  330.          /* entries, so production can be derived. Mark as safe:  */
  331.          /*********************************************************/
  332.              y1YieldsEmpty[ *y2Production[i]-FIRSTnONTERMINAL ] = OK;
  333.  
  334.          /* This may make something else safe, so start over: */
  335.              goto more;
  336.      }
  337.     }
  338.  
  339.     /********************************************************************/
  340.     /* We have now marked all nonterminals known to generate something. */
  341.     /* If any do NOT generate something, issue a warning message:    */
  342.     /********************************************************************/
  343.  
  344.     /* Make the useless-nonterminal errors nonfatal so we get all of them: */
  345.     y1ErrorsFatal = FALSE;
  346.  
  347.     FORaLLnONTERMINALS(i) {
  348.  
  349.     /* Ignore the %start nonterminal, which is special: */
  350.         if (!i)   continue;
  351.  
  352.     /* All the rest should derive something: */
  353.         if ( y1YieldsEmpty[ i ] != OK ) {
  354.  
  355.         y1Error(
  356.         "y1CheckEmpty: nonterminal %s never derives any token string",
  357.         y2NonterminalState[i].name
  358.         );
  359.     }
  360.     }
  361.     y1ErrorsFatal = TRUE;
  362.  
  363.     /* Quit if there are any useless nonterminals: */
  364.     if (y1Errors) {
  365.     y1Summary();
  366.     exit(EX_ERR);
  367.     }
  368.  
  369.  
  370.  
  371.     /******************************************************************/
  372.     /* Now figure out which nonterminals can derive the empty string: */
  373.     /******************************************************************/
  374.  
  375.  
  376.  
  377.     /* Set y1YieldsEmpty to WHOKNOWS: */
  378.     y1ArrayFill( y1YieldsEmpty, y2LastNonterminal+1, WHOKNOWS );
  379.  
  380.     /* Loop as long as we keep finding empty nonterminals: */
  381.  
  382. again:
  383.     FORaLLpRODUCTIONS(1,i) {
  384.  
  385.         if (y1YieldsEmpty[ *y2Production[i]-FIRSTnONTERMINAL ] == WHOKNOWS) {
  386.  
  387.             /*****************************************************/
  388.         /* Found a production not known to be empty.     */
  389.         /* See if all items on RHSide are known to be empty: */
  390.             /*****************************************************/
  391.  
  392.             for (p = y2Production[ i ] +1;  *p >= FIRSTnONTERMINAL;  ++p) {
  393.  
  394.                 if (y1YieldsEmpty[ *p - FIRSTnONTERMINAL ]  !=  EMPTY)   break;
  395.  
  396.             }
  397.  
  398.         if (*p < 0) {
  399.  
  400.                 /* We have a nontrivially empty nonterminal: */
  401.         y1YieldsEmpty[ *y2Production[ i ] - FIRSTnONTERMINAL ] = EMPTY;
  402.  
  403.         /* This rule may make another empty, so start over: */
  404.         goto again;
  405.         }
  406.     }
  407.     }
  408. }
  409.  
  410. /************************************************************************/
  411. /*    y1Closure     Generate the closure of state i         */
  412. /************************************************************************/
  413. y1Closure( i )    /* Called from y1StateGen and y3Output. */
  414. int i;
  415. {
  416.     /************************************************************************/
  417.     /* An "item" of a grammar G is a production of G with a dot at        */
  418.     /* some position of the right side.  The the production            */
  419.     /*                                        */
  420.     /*       a : x y z                                */
  421.     /*                                        */
  422.     /* generates the items                            */
  423.     /*                                        */
  424.     /*       a :.x y z                                */
  425.     /*       a : x.y z                                */
  426.     /*       a : x y.z                                */
  427.     /*       a : x y z.                                */
  428.     /*                                        */
  429.     /*    ...                                    */
  430.     /*                                        */
  431.     /* If i is a set of items for a grammar G, then the set of items        */
  432.     /* CLOSURE(i) is constructed from i by the rules                */
  433.     /* 1.  Every item in i is in CLOSURE(i)                    */
  434.     /* 2.  If "a : x.y z" is in CLOSURE(i) and "b : w" is a production,     */
  435.     /*       add "b : .w" to i.                            */
  436.     /*                                        */
  437.     /*    (Following Aho & Ullman PRIMCIPLES OF COMPILER DESIGN p205-206.) CrT*/
  438.     /************************************************************************/
  439.  
  440.     int                     c, ch, work, k;
  441.     register struct wset    *u, *v;
  442.     int             *pi;
  443.     int             **s, **t;
  444.     struct item         *q;
  445.     register struct item    *p;
  446.     int             num;
  447.  
  448.  
  449.     ++y1ClosuresDone;
  450.  
  451.     /* First, copy kernel of state i to y1WorkingSet: */
  452.  
  453.     y1ThisWorkingSet = y1WorkingSet;
  454.     FORaLLiTEMS(i,p,q) {
  455.  
  456.         y1ThisWorkingSet->pitem  = p->pitem;
  457.  
  458.     /* This item must get closed. */
  459.     y1ThisWorkingSet->flag     = TRUE;
  460.  
  461.     /* Copy the set over: */
  462.         FORaLLlOOKAHEADwORDS(k) {
  463.         y1ThisWorkingSet->ws.lset[k] = p->look->lset[k];
  464.     }
  465.  
  466.     NEXTwORKINGsET( y1ThisWorkingSet );
  467.     }
  468.  
  469.     /* Loop until no items remain to be closed: */
  470.     for (work = TRUE;    work; )  {
  471.  
  472.         work = FALSE;
  473.  
  474.     FORaLLwORKINGsETS( y1WorkingSet, u ) {
  475.  
  476.         /* Find an item with the close flag set: */
  477.             if (!u->flag) continue;
  478.  
  479.         /* Found one. Dot is before c: */
  480.         c = *(u->pitem);
  481.  
  482.         /* Only interesting case is where dot is before a nonterminal: */
  483.         if (c < FIRSTnONTERMINAL)  {
  484.  
  485.         /* Dot is before a terminal in this item: */
  486.                 u->flag = FALSE;
  487.         continue;
  488.         }
  489.  
  490.         /* Compute the lookahead: */
  491.  
  492.             y1ArrayFill( y1ClosureSet.lset, y1MaxLookaheadSet, 0 );
  493.  
  494.         /* Find items involving c: */
  495.         FORaLLwORKINGsETS(u,v)  {
  496.  
  497.         if (v->flag   &&   *(pi=v->pitem) == c) {
  498.             v->flag = FALSE;
  499.  
  500.                     if (y1NoLookahead)   continue;
  501.  
  502.             while ((ch = *++pi)  >  0)    {
  503.  
  504.                         if (ch < FIRSTnONTERMINAL) {
  505.                 /* Terminal symbol: */
  506.                 SETBIT( y1ClosureSet.lset, ch );
  507.                 break;
  508.              }
  509.  
  510.              /* Nonterminal symbol: */
  511.              num = ch-FIRSTnONTERMINAL;
  512.              y1SetUnion( y1ClosureSet.lset, y1FirstOf[num]->lset );
  513.              if (!y1YieldsEmpty[ num ])   break;
  514.             }
  515.             if (ch <= 0)   y1SetUnion( y1ClosureSet.lset, v->ws.lset );
  516.         }
  517.         }
  518.  
  519.         /* Now loop over productions derived from c: */
  520.  
  521.         c -= FIRSTnONTERMINAL;    /* c is now nonterminal number */
  522.  
  523.         t  = y1YieldedBy[ c+1 ];
  524.         for (s = y1YieldedBy[ c ];     s < t;   ++s) {
  525.  
  526.         /* Put these items into the closure: */
  527.         FORaLLwORKINGsETS(y1WorkingSet,v)  {
  528.  
  529.                     /* Is the item there? */
  530.             if (v->pitem == *s) {
  531.  
  532.                         /* Yes, it is there: */
  533.             if (y1NoLookahead)   goto nexts;
  534.             if (y1SetUnion( v->ws.lset, y1ClosureSet.lset )) {
  535.                 v->flag = work = TRUE;
  536.             }
  537.             goto nexts;
  538.             }
  539.         }
  540.  
  541.         /*  Not there; make a new entry: */
  542.         if (y1ThisWorkingSet-y1WorkingSet+1 >= MAXy1wORKINGsET)  {
  543.             y1Error( "y1Closure: Working set overflow" );
  544.         }
  545.         y1ThisWorkingSet->pitem  = *s;
  546.         y1ThisWorkingSet->flag     = TRUE;
  547.         if (!y1NoLookahead) {
  548.             work = TRUE;
  549.             FORaLLlOOKAHEADwORDS(k) {
  550.             y1ThisWorkingSet->ws.lset[k] = y1ClosureSet.lset[k];
  551.             }
  552.                 }
  553.         NEXTwORKINGsET( y1ThisWorkingSet );
  554. nexts:        ;
  555.         }
  556.  
  557.     }
  558.     }
  559.  
  560.     /* We have computed closure. Flags are reset. Return: */
  561.     if (y1LastWorkingSet < y1ThisWorkingSet)  {
  562.     y1LastWorkingSet = y1ThisWorkingSet;
  563.     }
  564.  
  565. #ifdef debug
  566.     if (y2OutputFD != NULL)  {
  567.     fprintf(
  568.         y2OutputFD,
  569.         "\nState %d, y1NoLookahead = %d\n",
  570.         i,
  571.         y1NoLookahead
  572.     );
  573.     FORaLLwORKINGsETS(y1WorkingSet,u) {
  574.         if (u->flag)   fprintf( y2OutputFD, "flag set!\n");
  575.         u->flag = FALSE;
  576.         fprintf( y2OutputFD, "\t%s", y1WriteItem(u->pitem));
  577.         y1PrintLookahead( &u->ws );
  578.         fprintf( y2OutputFD,  "\n" );
  579.     }
  580.     }
  581. #endif
  582. }
  583.  
  584.  
  585. /************************************************************************/
  586. /*    y1Error           Write out fatal error comment.                  */ 
  587. /************************************************************************/ 
  588. y1Error( s, a1 )        /* Called from everywhere. */ 
  589. char *s; 
  590. { 
  591.     ++y1Errors;
  592.     fprintf(   stderr,     "\nFATAL ERROR: "           );
  593.     fprintf(   stderr,     s, a1                   );
  594.     fprintf(   stderr,     ", line %d\n", y1LineNumber   );
  595.  
  596.     if (!y1ErrorsFatal)   return;
  597.  
  598.     y1Summary(); 
  599.  
  600.     exit(EX_ERR); 
  601. } 
  602.   
  603. /************************************************************************/
  604. /*    y1First           Compute an array with the FIRST of nonterminals */ 
  605. /************************************************************************/ 
  606. y1First() {     /* Called only from main. */ 
  607.  
  608.    register *p, **s, i, **t, ch, changes; 
  609.   
  610.    /**************************************************************/
  611.    /* For each nonterminal NT defined by the grammar, we want to */
  612.    /* figure out which terminals can occur first in a string     */
  613.    /* defined by NT.  This is a simple matter of enumerating     */
  614.    /* all terminals which occur at the start of a production     */
  615.    /* defining NT, and then adding in the recursively computed     */
  616.    /* FIRSTs of all nonterminals starting NT productions:     */
  617.    /**************************************************************/
  618.  
  619.    y1LastWorkingSet = &y1WorkingSet[ y2LastNonterminal ];
  620.  
  621.    /********************************************************************/
  622.    /* Do the first pass, finding for each nonterminal NT all terminals */
  623.    /* occurring at the start of a production defining NT:           */
  624.    /********************************************************************/
  625.  
  626.    FORaLLnONTERMINALS(i) {
  627.  
  628.     /* Allocate a set to hold FIRST of this nonterminal: */
  629.         y1ArrayFill( y1WorkingSet[i].ws.lset, y1MaxLookaheadSet, 0 );
  630.  
  631.     /* Iterate over the list of productions defining our nonterminal: */
  632.         t = y1YieldedBy[ i+1 ];
  633.     for (s = y1YieldedBy[i];   s < t;   ++s ) {
  634.   
  635.             /*************************************************************/
  636.         /* If this rule starts with a terminal, add it to our FIRST  */
  637.         /* set.  If the rule starts with a nonterminal that can     */
  638.         /* derive the empty string, then look at the next entry:     */
  639.             /*************************************************************/
  640.  
  641.             for (p = *s;   (ch = *p) > 0;   ++p) { 
  642.   
  643.         if (ch < FIRSTnONTERMINAL) {
  644.  
  645.                     /* Found a terminal, add it to FIRST set: */
  646.                     SETBIT( y1WorkingSet[i].ws.lset, ch );
  647.             break;
  648.  
  649.                 } else { 
  650.  
  651.                     /* Found a nonterminal.  Finished with this rule */
  652.             /* unless the nonterminal can derive <empty>:    */
  653.             if (!y1YieldsEmpty[ ch-FIRSTnONTERMINAL ])     break;
  654.                 } 
  655.             } 
  656.         } 
  657.     } 
  658.   
  659.     /****************************************************************/
  660.     /* Do the second pass, adding to FIRST(NT) FIRST(NT') for all   */
  661.     /* nonterminals NT' which occur first in a rule defining NT:    */
  662.     /****************************************************************/
  663.  
  664.     for (changes = TRUE;   changes;  ) {
  665.     changes = FALSE;
  666.  
  667.         FORaLLnONTERMINALS(i) {
  668.  
  669.         /* Iterate over the set of productions defining nonterminal i: */
  670.             t = y1YieldedBy[i+1];
  671.         for (s = y1YieldedBy[i];   s < t;    ++s) {
  672.  
  673.                 /************************************************************/
  674.         /* If this production starts with a nonterminal NT, collect */
  675.         /* its FIRST set.  As before, if NT can derive the empty    */
  676.         /* string then we have to collect FIRST of the following    */
  677.         /* item also:                            */
  678.                 /************************************************************/
  679.  
  680.                 for (p = *s;   (ch = (*p-FIRSTnONTERMINAL)) >= 0;   ++p) {
  681.             changes |= y1SetUnion(
  682.             y1WorkingSet[i].ws.lset,
  683.             y1WorkingSet[ch].ws.lset
  684.             );
  685.             if (!y1YieldsEmpty[ ch ])    break;
  686.                 } 
  687.             } 
  688.         } 
  689.     } 
  690.   
  691.     /********************************************************/
  692.     /* Finished! Now index the results for later reference, */
  693.     /* simultaneously merging identical lookahead sets:     */
  694.     /********************************************************/
  695.  
  696.     FORaLLnONTERMINALS(i) y1FirstOf[i] = y1Lookahead( &y1WorkingSet[i].ws );
  697. #ifdef debug 
  698.     if (y2OutputFD != NULL) {
  699.     FORaLLnONTERMINALS(i)  {
  700.         fprintf( y2OutputFD,  "\n%s: ", y2NonterminalState[i].name );
  701.         y1PrintLookahead( y1FirstOf[i] );
  702.         fprintf( y2OutputFD,  " %d\n", y1YieldsEmpty[i] );
  703.         } 
  704.     } 
  705. #endif 
  706. } 
  707.   
  708. /************************************************************************/
  709. /*    y1GetChar         Get one input char                              */ 
  710. /************************************************************************/ 
  711. y1GetChar( iop )                /* Called from everywhere */ 
  712. FILE *iop;
  713. {
  714.     if (y1TopStack == y1GetStack)   return  getc(iop)     ;
  715.     else                            return  *--y1TopStack;
  716. }
  717.  
  718. /************************************************************************/
  719. /*    y1Lookahead    Return lookahead set                */
  720. /************************************************************************/
  721. static struct looksets *y1Lookahead( p    )
  722. struct looksets *p;          /* Called from: y1First, y1PutItem, y1State */
  723. {
  724.     /* Decide if the lookahead set pointed to by p is known. */
  725.     /* Return pointer to a permanent location for the set.   */
  726.  
  727.     register struct looksets *q;
  728.     int              j,  *w;
  729.     register             *u, *v;
  730.  
  731.     /* Over all known lookahead sets q, see if q == p: */
  732.     for( q = &y1LookaheadSet[ y1NextLookaheadSet ];   q-- > y1LookaheadSet; ) {
  733.  
  734.         u = p->lset;
  735.     v = q->lset;
  736.  
  737.         w = &v[ y1MaxLookaheadSet ];
  738.  
  739.     /* Match all pair of corresponding words in p and q: */
  740.         while (v < w)   if (*u++ != *v++) goto more;
  741.  
  742.     /* P matches q -- return q */
  743.     return( q );
  744. more:    ;
  745.     }
  746.  
  747.     /* P is different from all known lookahead sets -- enter it: */
  748.     q = &y1LookaheadSet[ y1NextLookaheadSet++ ];
  749.  
  750.     /* Check for too many lookahead sets: */
  751.     if (y1NextLookaheadSet >= MAXy1lOOKAHEADsETS) {
  752.     y1Error("y1Lookahead: Too many lookahead sets");
  753.     }
  754.  
  755.     /* Copy p to permanent storage location: */
  756.     FORaLLlOOKAHEADwORDS(j) {
  757.     q->lset[j] = p->lset[j];
  758.     }
  759.     return( q );
  760. }
  761.  
  762. /************************************************************************/
  763. /*    y1MakeStates      Generate the states.                            */ 
  764. /************************************************************************/  
  765. static y1MakeStates() {      /* Called only from main. */
  766.     int i, j;  
  767.     register c;  
  768.     register struct wset *p, *q;  
  769.    
  770.     /********************************************************************/
  771.     /* Running your eye over a yacc grammar, you can imagine the parser */
  772.     /* proceeding methodically through the appropriate rules, looking    */
  773.     /* always for the next token in the current rule.  In fact, however,*/
  774.     /* one may have several rules which begin identically (say), so the */
  775.     /* parser must keep track of where it is in all the grammar rules    */
  776.     /* which >might< turn out to be the right one.  Thus, at any given    */
  777.     /* time, the parser is in effect in a set of states rather than a    */
  778.     /* single state.  In this routine we precompute all valid sets of    */
  779.     /* states which the parser might wind up in.  This is a simple    */
  780.     /* matter of starting at the root nonterminal of the grammar and    */
  781.     /* proceeding all possible directions simultaneously... :-)      CrT*/
  782.     /********************************************************************/
  783.  
  784.     /* Initialize */  
  785.    
  786.     y1NextState = 0;
  787.    /**************************************************************************/
  788.    /* This is funny from the standpoint of portability.              */
  789.    /* It represents the magic moment when the y2Pool array, which has         */
  790.    /* been holding the productions, starts to hold item pointers, of a         */
  791.    /* different type...                              */
  792.    /* Someday, alloc should be used to allocate all this stuff. For now, we  */
  793.    /* accept that if pointers don't fit in integers, there is a problem. SCJ.*/
  794.    /**************************************************************************/
  795.    
  796.    y1StateItem[ 0 ]  = y1StateItem[ 1 ] = (struct item *) y2FreePool;
  797.  
  798.    y1ArrayFill( y1ClosureSet.lset, y1MaxLookaheadSet, 0 );
  799.  
  800.    y1PutItem( y2Production[ 0 ]+1, &y1ClosureSet );
  801.  
  802.    /* Start state expansion at the root nonterminal: */
  803.    y1StateType[ 0 ]  = MUSTdOsTATE;
  804.    y1NextState         = 1;
  805.    y1StateItem[ 2 ]  = y1StateItem[ 1 ];
  806.    
  807.    y1ArrayFill( y1Action, MAXaCTIONS, 0 );
  808.    
  809.    /* Now, the main state generation loop: */  
  810.    
  811. more:  
  812.    FORaLLsTATES(i) {
  813.  
  814.     /* Find a state which needs expanding: */
  815.         if (y1StateType[i] != MUSTdOsTATE)   continue;
  816.  
  817.     /* Mark it as done: */
  818.         y1StateType[ i ] = DONEsTATE;
  819.  
  820.     /* Erase our scratchpad set: */
  821.         y1ArrayFill( y1Temp, y2LastNonterminal+1, 0 );
  822.    
  823.         /* Take state i, close it, and do gotos: */  
  824.     y1Closure(i);
  825.  
  826.         /*************************************************************/
  827.     /*"For item set i and grammar symbol x, GOTO(i,x) is defined */
  828.     /* to be the closure of the set of all items 'a : bx.c' such */
  829.     /* that 'a : b.xc' is in i..."                               */
  830.     /*    Aho & Ullman PRINCIPLES OF COMPILER DESIGN p207.  CrT*/
  831.         /*************************************************************/
  832.  
  833.         FORaLLwORKINGsETS(y1WorkingSet,p) {
  834.    
  835.             /* Generate goto's: */  
  836.             if (p->flag)   continue;  
  837.         p->flag = TRUE;
  838.             c       = *(p->pitem);  
  839.    
  840.             if (c <= 1) {  
  841.         if (y1StateItem[i+1]-y1StateItem[i] <= p-y1WorkingSet)    {
  842.             y1StateType[i] = MUSTlOOKaHEADsTATE;
  843.                 }  
  844.                 continue;  
  845.             }  
  846.    
  847.             /* Do a goto on c: */  
  848.         FORaLLwORKINGsETS(p,q) {
  849.                 if (c == *(q->pitem)) {  
  850.  
  851.                     /* This item contributes to the goto: */  
  852.                     y1PutItem( q->pitem + 1, &q->ws );  
  853.             q->flag = TRUE;
  854.                 }  
  855.             }  
  856.    
  857.         if (c < FIRSTnONTERMINAL) {
  858.                 y1State(c);  /* Register new state */  
  859.             } else {  
  860.         y1Temp[c-FIRSTnONTERMINAL] = y1State(c);
  861.             }  
  862.         }  
  863. #ifdef debug  
  864.     if (y2OutputFD != NULL) {
  865.         fprintf( y2OutputFD,  "%d: ", i );
  866.         FORaLLnONTERMINALS(j) {
  867.         if (y1Temp[j]) {
  868.             fprintf(
  869.             y2OutputFD,
  870.             "%s %d, ",
  871.             y2NonterminalState[j].name,
  872.             y1Temp[j]
  873.             );
  874.                 }  
  875.             }  
  876.         fprintf( y2OutputFD, "\n");
  877.         }  
  878. #endif  
  879.     y1GotoIndex[i] = y3PackState( &y1Temp[1], y2LastNonterminal-1 ) - 1;
  880.    
  881.         /* We have done one goto; Do some more: */  
  882.         goto more;  
  883.     }  
  884.     /* No more to do: Stop. */  
  885. }  
  886.    
  887.    
  888. /************************************************************************/
  889. /*    main                                */
  890. /************************************************************************/
  891. main( argc, argv )
  892. int argc;
  893. char *argv[];
  894. {
  895.     /* Initialize and read productions: */
  896.     puts("\ry2Initialize...      \r");
  897.     y2Initialize(argc,argv);
  898.  
  899.     /* Process input file, stashing results in appropriate the tables: */
  900.     puts("\ry2yyParse...         \r"); 
  901.     y2yyParse();
  902.  
  903.     /* Build yyActionIndex[] so parser can find user action chunks: */
  904.     puts("\ry3ActionIndex...     \r");
  905.     y3ActionIndex();
  906.  
  907.     /* Figure how many words a set of terminals requires, taking */
  908.     /* into account bits per word and number of terminals:     */
  909.     y1MaxLookaheadSet = NWORDS(y2NextTerminal);
  910.  
  911.     /* Find all productions defining each nonterminal: */
  912.     puts("\ry1Yield...           \r");
  913.     y1Yield();
  914.  
  915.     /* Figure out which nonterminals can match the empty string: */
  916.     puts("\ry1CheckEmpty...      \r");
  917.     y1CheckEmpty();
  918.  
  919.     /* Make a table of FIRSTs of nonterminals: */
  920.     puts("\ry1First...           \r");
  921.     y1First();
  922.  
  923.     /* Generate the states: */
  924.     puts("\ry1MakeStates...      \r");
  925.     y1MakeStates();
  926.  
  927.     /* Write the states and the tables: */
  928.     puts("\ry3PutStates...       \r");
  929.     y3PutStates();
  930.  
  931.     puts("\ry3Gotos...           \r");
  932.     y3Gotos();
  933.  
  934.     puts("\ry3HideProductions... \r");
  935.     y3HideProductions();
  936.  
  937.     puts("\ry1Summary...         \r");
  938.     y1Summary();
  939.  
  940.     puts("\ry4Optimize...        \r");
  941.     y4Optimize();
  942.  
  943.     puts("\ry1PutRest...         \r");
  944.     y1PutRest();
  945.  
  946.     puts("\rDone.                \r");
  947.     exit(EX_SUC);
  948. }
  949.  
  950.  
  951. /************************************************************************/
  952. /*    y1PutRest      Put out other arrays, copy the parsers.     */
  953. /************************************************************************/
  954. static y1PutRest() {         /* Called only from main. */
  955.     register c, i, j;
  956.  
  957.     y2InputFD = fopen( PARSER, "r" );
  958.     if (y2InputFD == NULL) {
  959.     y1Error( "y1PutRest: Cannot find parser file '%s'", PARSER );
  960.     }
  961.  
  962.     y3PutArray( "yyr1", y2ProductionProperties, y2ThisProduction );
  963.  
  964.     y1ArrayFill( y1Temp, y2ThisProduction, 0 );
  965.     FORaLLpRODUCTIONS( 1,i )   y1Temp[i] = y2Production[i+1]-y2Production[i]-2;
  966.     y3PutArray( "yyr2", y1Temp, y2ThisProduction );
  967.  
  968.     y1ArrayFill( y1Temp, y1NextState, -1000 );
  969.     FORaLLtERMINALS(i) {
  970.     for(j = y1TerminalState[i];   j != 0;    j = y1Link[j]) {
  971.         y1Temp[j] = y2Terminal[i].value;
  972.     }
  973.     }
  974.     FORaLLnONTERMINALS(i) {
  975.     for (j = y1NonterminalState[i];   j != 0;   j = y1Link[j]) {
  976.         y1Temp[j] = -i;
  977.     }
  978.     }
  979.     y3PutArray( "yychk", y1Temp, y1NextState );
  980.  
  981.     y3PutArray( "yydef", y3DefaultAction, y1NextState );
  982.  
  983.     /* Copy parser text: */
  984.     while ((c = y1GetChar(y2InputFD))    !=   EOF) {
  985.     if (c == '$') {
  986.         if ((c = y1GetChar(y2InputFD)) != 'A')   putc( '$', y2ytabcFD );
  987.         else {
  988.         /* Copy actions: */
  989.         y2ActionFD = fopen( ACTNAME, "r" );
  990.         if (y2ActionFD == NULL)   {
  991.             y1Error( "y1PutRest: Cannot reopen action tempfile" );
  992.         }
  993.         while( (c=y1GetChar(y2ActionFD) ) != EOF ) putc( c, y2ytabcFD );
  994.         fclose(y2ActionFD);
  995.         ZAPFILE(ACTNAME);
  996.         c = y1GetChar(y2InputFD);
  997.         }
  998.     }
  999.     putc( c, y2ytabcFD );
  1000.     }
  1001.     fclose( y2ytabcFD );
  1002. }
  1003.  
  1004. /************************************************************************/
  1005. /*    y1PrintLookahead    Print lookahead.                */
  1006. /************************************************************************/
  1007. static y1PrintLookahead( p )        /* Called from y1Closure, y1First */
  1008. struct looksets *p;
  1009. {
  1010.     register j, *pp;
  1011.     pp = p->lset;
  1012.  
  1013.     if (pp == 0)   fprintf( y2OutputFD, "\tNULL" );
  1014.     else {
  1015.     fprintf( y2OutputFD, " { " );
  1016.     FORaLLtERMINALS(j) {
  1017.         if (GETBIT(pp,j))    fprintf( y2OutputFD,  "%s ", y1SymbolName(j) );
  1018.     }
  1019.     fprintf( y2OutputFD,  "}" );
  1020.     }
  1021. }
  1022.  
  1023. /************************************************************************/
  1024. /*    y1PutItem                             */
  1025. /************************************************************************/
  1026. y1PutItem( ptr, lptr )        /* Called from y1MakeStates, y3Output    */
  1027. int *ptr;
  1028. struct looksets *lptr;
  1029. {
  1030.     register struct item *j;
  1031.  
  1032. #ifdef debug
  1033.     if (y2OutputFD != NULL) {
  1034.     fprintf(
  1035.         y2OutputFD,
  1036.         "y1PutItem(%s), state %d\n",
  1037.         y1WriteItem(ptr),
  1038.         y1NextState
  1039.     );
  1040.     }
  1041. #endif
  1042.     j = y1StateItem[ y1NextState+1 ];
  1043.     j->pitem = ptr;
  1044.     if (!y1NoLookahead)   j->look = y1Lookahead( lptr );
  1045.     y1StateItem[ y1NextState+1 ]  = ++j;
  1046.  
  1047.     if (((int *)j)  >    y1Nexty2PoolLoc) {
  1048.     y1Nexty2PoolLoc = (int *)j;
  1049.     if( y1Nexty2PoolLoc >=    &y2Pool[MAXy2POOL] ) {
  1050.         y1Error( "y1PutItem: Out of state space" );
  1051.     }
  1052.     }
  1053. }
  1054.  
  1055.  
  1056. /************************************************************************/
  1057. /*    y1SetUnion    A gets union of A and B.            */
  1058. /************************************************************************/
  1059. static y1SetUnion( a, b )      /* Called by y1First, y1Closure, y1State. */
  1060. register *a, *b;
  1061. {
  1062.     /***************************************************/
  1063.     /* Set a to the union of a and b.               */
  1064.     /* Return 1 if b is not a subset of a, 0 otherwise.*/
  1065.     /***************************************************/
  1066.  
  1067.     register i, x, sub;
  1068.  
  1069.     sub = 0;
  1070.     FORaLLlOOKAHEADwORDS(i) {
  1071.     *a = (x = *a)|*b++;
  1072.     if (*a++ != x)     sub = 1;
  1073.     }
  1074.     return   sub;
  1075. }
  1076.  
  1077.  
  1078. /************************************************************************/
  1079. /*    y1State        Sort last state, check it, return state #.    */
  1080. /************************************************************************/
  1081. y1State( c )        /* Called in y3Output, y1MakeStates        */
  1082. int c;
  1083. {
  1084.     /* Sort last state, and see if it equals earlier ones. return state #: */
  1085.  
  1086.     int size1,size2;
  1087.     register i;
  1088.     int *s;                             /*01*/
  1089.     struct looksets *ss;                     /*01*/
  1090.     int s__;                             /*01*/
  1091.     struct item *p1, *p2, *k, *l, *q1, *q2;
  1092.  
  1093.     p1 = y1StateItem[y1NextState];
  1094.     p2 = y1StateItem[y1NextState+1];
  1095.  
  1096.     if (p1==p2)   return(0); /* Null state. */
  1097.  
  1098.     /* Sort the items: */
  1099.     for (k = p2-1;   k > p1;   k--) {
  1100.     /* Make k the biggest: */
  1101.     for (l = k-1;    l >= p1;   --l)   {
  1102.         if (l->pitem > k->pitem) {
  1103.         s = k->pitem;
  1104.         k->pitem = l->pitem;
  1105.         l->pitem = s;
  1106.         ss = k->look;
  1107.         k->look = l->look;
  1108.         l->look = ss;
  1109.         }
  1110.     }
  1111.     }
  1112.  
  1113.     /* Figure size of state: */
  1114.     size1 = p2 - p1;
  1115.  
  1116.     for (
  1117.     i =   (c >= FIRSTnONTERMINAL)    ?   y1NonterminalState[ c-FIRSTnONTERMINAL ]   :   y1TerminalState[ c ]
  1118.     ;
  1119.     i != 0
  1120.     ;
  1121.     i = y1Link[i]
  1122.     ) {
  1123.     /* Get ith state */
  1124.     q1    = y1StateItem[ i     ];
  1125.     q2    = y1StateItem[ i+1 ];
  1126.     size2 = q2 - q1;
  1127.  
  1128.     if (size1 != size2)   continue;
  1129.     k   = p1;
  1130.  
  1131.     for (l = q1;   l < q2;     l++) {
  1132.         if (l->pitem != k->pitem)    break;
  1133.         ++k;
  1134.     }
  1135.     if (l != q2)   continue;
  1136.  
  1137.     /* Found it: */
  1138.  
  1139.     /* Delete last state: */
  1140.     y1StateItem[y1NextState+1] = y1StateItem[y1NextState];
  1141.  
  1142.     /* Fix up lookaheads: */
  1143.     if (y1NoLookahead)   return(i);
  1144.     for (l = q1 , k = p1;    l < q2;   ++l, ++k) {
  1145.         FORaLLlOOKAHEADwORDS(s__) y1ClosureSet.lset[s__] = l->look->lset[s__];
  1146.  
  1147.         if (y1SetUnion( y1ClosureSet.lset, k->look->lset )) {
  1148.         y1StateType[i] = MUSTdOsTATE;
  1149.  
  1150.         /* Register the new set: */
  1151.         l->look = y1Lookahead( &y1ClosureSet );
  1152.         }
  1153.     }
  1154.     return     i;
  1155.     }
  1156.  
  1157.     /* State is new: */
  1158.     if (y1NoLookahead)         y1Error( "y1State: Yacc state/y1NoLookahead error" );
  1159.     y1StateItem[ y1NextState+2 ] = p2;
  1160.     if (y1NextState+1 >= MAXsTATES)   y1Error("y1State: Too many states" );
  1161.  
  1162.     if (c >= FIRSTnONTERMINAL) {
  1163.     y1Link[ y1NextState ]     = y1NonterminalState[ c-FIRSTnONTERMINAL ];
  1164.     y1NonterminalState[ c-FIRSTnONTERMINAL ] = y1NextState;
  1165.     } else {
  1166.     y1Link[ y1NextState ] = y1TerminalState[ c ];
  1167.     y1TerminalState[ c ] = y1NextState;
  1168.     }
  1169.     y1StateType[y1NextState]=MUSTdOsTATE;
  1170.     return  y1NextState++;
  1171. }
  1172.  
  1173.  
  1174. /************************************************************************/
  1175. /*    y1Summary         Write the summary on the terminal.              */ 
  1176. /************************************************************************/
  1177. static y1Summary() {    /* Called in y1CheckEmpty, y1Yield, y1Error, main */
  1178.  
  1179.  
  1180.     if (y2OutputFD != NULL) {
  1181.     fprintf(
  1182.         y2OutputFD,
  1183.         "\n%d/%d terminals, %d/%d nonterminals\n",
  1184.         y2NextTerminal,
  1185.         MAXtERMINALsTATES,
  1186.         y2LastNonterminal,
  1187.         MAXnONTERMINALsTATES
  1188.     );
  1189.     fprintf(
  1190.         y2OutputFD,
  1191.         "%d/%d grammar rules, %d/%d states\n",
  1192.         y2ThisProduction,
  1193.         MAXpRODUCTIONS,
  1194.         y1NextState,
  1195.         MAXsTATES
  1196.     );
  1197.     fprintf(
  1198.         y2OutputFD,
  1199.         "%d shift/reduce, %d reduce/reduce conflicts reported\n",
  1200.         y1ShiftReduceConflicts,
  1201.         y1ReduceReduceConflicts
  1202.     );
  1203.     fprintf(
  1204.         y2OutputFD,
  1205.         "%d/%d working sets used\n", y1LastWorkingSet-y1WorkingSet,
  1206.         MAXy1wORKINGsET
  1207.     );
  1208.     fprintf(
  1209.         y2OutputFD,
  1210.         "memory: states,etc. %d/%d, parser %d/%d\n",
  1211.         y1Nexty2PoolLoc-y2Pool,
  1212.         MAXy2POOL,
  1213.         y1NextAction-y1Action,
  1214.         MAXaCTIONS
  1215.     );
  1216.     fprintf(
  1217.         y2OutputFD,
  1218.         "%d/%d distinct lookahead sets\n",
  1219.         y1NextLookaheadSet,
  1220.         MAXy1lOOKAHEADsETS
  1221.     );
  1222.     fprintf( y2OutputFD, "%d extra closures\n", y1ClosuresDone - 2*y1NextState );
  1223.     fprintf(
  1224.         y2OutputFD,
  1225.         "%d shift entries, %d exceptions\n",
  1226.         y1ShiftEntries,
  1227.         y1Exceptions
  1228.     );
  1229.     fprintf( y2OutputFD, "%d goto entries\n", y1GotoEntries );
  1230.     fprintf( y2OutputFD, "%d entries saved by goto default\n", y1GotosSavedByDefault );
  1231.     }
  1232.     if (y1ShiftReduceConflicts || y1ReduceReduceConflicts) {
  1233.     fprintf( stdout,"\nconflicts: ");
  1234.     if (y1ShiftReduceConflicts)   fprintf( stdout, "%d shift/reduce" , y1ShiftReduceConflicts );
  1235.     if (y1ShiftReduceConflicts && y1ReduceReduceConflicts) fprintf( stdout, ", " );
  1236.     if (y1ReduceReduceConflicts)   fprintf( stdout, "%d reduce/reduce" , y1ReduceReduceConflicts );
  1237.     fprintf( stdout, "\n" );
  1238.     }
  1239.  
  1240.     fclose( y2TempFileFD );
  1241.     if (y2DefineFD != NULL)   fclose( y2DefineFD );
  1242. }
  1243.  
  1244.  
  1245. /************************************************************************/
  1246. /*    y1SymbolName    Return a pointer to the name of symbol i.    */
  1247. /************************************************************************/
  1248. char *y1SymbolName( i )     /* Called from all over */
  1249. int i;
  1250. {
  1251.     char *cp;
  1252.  
  1253.     cp    = (i>=FIRSTnONTERMINAL) ? y2NonterminalState[i-FIRSTnONTERMINAL].name : y2Terminal[i].name ;
  1254.  
  1255.     if (*cp == ' ')   ++cp;
  1256.  
  1257.     return   cp;
  1258. }
  1259.  
  1260. /************************************************************************/
  1261. /*    y1UngetChar    Unget one char.                 */
  1262. /************************************************************************/
  1263. y1UngetChar(c, iop)        /* Called from all over.        */
  1264. char c;
  1265. FILE iop; /* WARNING: iop ignored ... y1UngetChar's are multiplexed!!! */
  1266. {
  1267.     *y1TopStack++ = c;
  1268. }
  1269.  
  1270. /************************************************************************/
  1271. /*    y1WriteItem    Creates output string for item pointed to by pp.*/
  1272. /************************************************************************/
  1273. char *y1WriteItem(pp)    /* Called from: y1Closure, y1PutItem,        */
  1274. int *pp;        /*        y3HideProductions, y3WriteState */
  1275. {
  1276.     static char   sarr[ISIZE];
  1277.     char          *q;
  1278.     int       i;
  1279.     int       *p;
  1280.  
  1281.     for (p = pp;   *p > 0;   ++p);
  1282.     p = y2Production[-*p];
  1283.     q = y1CharCopy( sarr, y2NonterminalState[*p-FIRSTnONTERMINAL].name );
  1284.     q = y1CharCopy( q, " : " );
  1285.  
  1286.     loop {
  1287.     *q++ = ++p==pp ? '_' : ' ';
  1288.     *q = '\0';
  1289.     if ((i = *p)   <=   0)     break;
  1290.     q = y1CharCopy( q, y1SymbolName(i) );
  1291.     if (q > &sarr[ISIZE-30])   y1Error( "y1WriteItem: Item too big" );
  1292.     }
  1293.  
  1294.     if ((i = *pp)   <    0) {
  1295.     /* An item calling for a reduction: */
  1296.     q = y1CharCopy( q, "    (" );
  1297.     sprintf( q, "%d)", -i );
  1298.     }
  1299.     return( sarr );
  1300. }
  1301.  
  1302. /************************************************************************/
  1303. /*    y1Yield           List productions yielding each nonterminal.     */ 
  1304. /************************************************************************/ 
  1305. static y1Yield() {     /* Called only by main.                */
  1306.  
  1307.     /********************************************/ 
  1308.     /* First stage of grammar processing:    */
  1309.     /* For each nonterminal NT, find all the    */
  1310.     /* alternate rules defining NT.        */
  1311.     /* y1YieldedBy[] points to these lists.    */
  1312.     /* pyield[] has the lists: the        */
  1313.     /* total size is only MAXpRODUCTIONS+1    */
  1314.     /********************************************/ 
  1315.  
  1316.     static int *pyield[ MAXpRODUCTIONS ];
  1317.     register **pmem;
  1318.     register c, j, i; 
  1319.   
  1320.  
  1321.     pmem = pyield; 
  1322.   
  1323.     /*****************************************************/
  1324.     /* Want to identify all undefined nonterminals, not  */
  1325.     /* just first, so make errors nonfatal for now:     */
  1326.     /*****************************************************/
  1327.     y1ErrorsFatal = FALSE;
  1328.   
  1329.     /* Tackle all nonterminals sequentially: */
  1330.     FORaLLnONTERMINALS(i) {
  1331.  
  1332.     /* Figure internal name for this nonterminal: */
  1333.     c = i + FIRSTnONTERMINAL;
  1334.  
  1335.     y1YieldedBy[ i ]    = pmem;
  1336.  
  1337.     /* Check all productions in memory: */
  1338.     FORaLLpRODUCTIONS(0,j) {
  1339.  
  1340.             /********************************************************/
  1341.         /* The nonterminal defined by a rule is the first entry */
  1342.         /* in it.  Remember this rule if it defines our current */
  1343.         /* nonterminal:                        */
  1344.             /********************************************************/
  1345.         if (*y2Production[j] == c)     *pmem++ =  y2Production[j]+1;
  1346.         } 
  1347.  
  1348.     /* If we found no rules defining this nonterminal, complain: */
  1349.         if (y1YieldedBy[i] == pmem) {
  1350.         y1Error(
  1351.         "y1Yield:  Nonterminal %s not defined!",
  1352.         y2NonterminalState[ i ].name
  1353.         );
  1354.         } 
  1355.     } 
  1356.  
  1357.     /* Leave pointer to remaining free memory: */
  1358.     y1YieldedBy[i] = pmem;
  1359.  
  1360.     /* Errors are again fatal until further notice: */
  1361.     y1ErrorsFatal = TRUE;
  1362.  
  1363.     /* Quit if there were any undefined nonterminals: */
  1364.     if (y1Errors) {
  1365.         y1Summary(); 
  1366.         exit(EX_ERR); 
  1367.     } 
  1368.  
  1369.     /* Just for fun, check that we found exactly as many rules as expected: */
  1370.     if (pmem != &pyield[ y2ThisProduction ]) {
  1371.     y1Error(
  1372.         "y1Yield: Internal Yacc error: pyield %d",
  1373.         pmem-&pyield[y2ThisProduction]
  1374.     );
  1375.     } 
  1376. } 
  1377.   
  1378.  
  1379.