home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / compcomp / yacc / y3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-17  |  19.3 KB  |  694 lines
  1. /************************************************************************/
  2. /*                              y3.c                                    */ 
  3. /*  YACC source file #3 (of 4).                                         */ 
  4. /************************************************************************/    
  5.      
  6. /************************************************************************/    
  7. /*                              contents                                */    
  8. /*                                                                      */    
  9. /*    y3ActionIndex     Write out the array of action-function pointers.*/
  10. /*  * y3AGoto        Write the gotos for one nonterminal.        */
  11. /*    y3Gotos        Write the gotos for all nonterminals.        */
  12. /*    y3HideProductions Free up mem[] and y1Action[] for optimizer.    */
  13. /*    y3PackState    Pack state i from y1Temp into y1Action.     */
  14. /*    y3PutArray        Write out an array.                             */
  15. /*    y3PutStates    Write the states and tables.            */
  16. /*  * y3ShiftReduce    Decide a shift/reduce conflict by precedence.    */
  17. /*  * y3WrtAction    Write out state i.                */
  18. /*  * y3WrtState    Write state i.                    */
  19. /*                                                                      */
  20. /* * Local to this file.                                                */ 
  21. /*                                    */
  22. /************************************************************************/    
  23.     
  24.     
  25. /************************************************************************/
  26. /*                              history                                 */    
  27. /*                                                                      */    
  28. /* 85Nov19 CrT    y3ActionIndex.                        */
  29. /* 85Nov15 CrT    Global variable names decrypted.            */
  30. /* 85Nov13 CrT    Give plaintiff routine in error messages.        */
  31. /* 85Nov12 CrT    Function names decrypted. Still unique in first 6 chars.*/
  32. /* 85Nov11 CrT    y3.c reconstructed from  9 subfiles.  Cosmetics.    */
  33. /* 81Aug28 RBD  Modified to make debug code conditionally compile.      */ 
  34. /* 7?????? SCJ  Created.                                                */ 
  35. /*                                                                      */ 
  36. /*                              credits                                 */ 
  37. /*      CrT=CrT                                                         */ 
  38. /*      RBD=Bob Denny                                                   */  
  39. /*      SCJ=Steven C Johnson.                                           */  
  40. /*      SG =Scott Guthery                                               */  
  41. /************************************************************************/ 
  42.   
  43.    
  44.  
  45. #include <stdio.h>
  46. #include "system.h"
  47. #include "dtxtrn.h"
  48.                                                                   
  49. /* The number of the last reduction of a state: */
  50. static int y3LastReduction;
  51.  
  52. /* The default actions of states: */
  53. int y3DefaultAction[MAXsTATES];
  54.  
  55. /************************************************************************/
  56. /*    y3ActionIndex    Write out the array of action-function pointers.*/
  57. /************************************************************************/
  58. y3ActionIndex() {
  59.     int i;
  60.  
  61.     /* First, declare all action functions: */
  62.  
  63.     /* Declare the default (null) action: */
  64.     fprintf( y2ytabcFD, "\nint yyANop();" );
  65.  
  66.     /* Declare all action functions created from user-supplied code chunks: */
  67.     FORaLLpRODUCTIONS(0,i)  {
  68.         if (y2ProductionProperties[ i ]   &   RULEhASaCTION) { 
  69.             fprintf( y2ytabcFD, "\nint yyA%03d();", i ); 
  70.         } 
  71.     } 
  72.  
  73.     /* Now declare and initialize yyActionIndex[]: */
  74.     fprintf( y2ytabcFD, "\n\n/* Table with an action function per rule: */" );
  75.     fprintf(
  76.     y2ytabcFD,
  77.         "\nstatic (*(yyActionIndex[%d]))() = {",
  78.     y2ThisProduction
  79.     );
  80.     FORaLLpRODUCTIONS(0,i)  {
  81.         if (y2ProductionProperties[ i ]   &   RULEhASaCTION) { 
  82.         fprintf( y2ytabcFD, "\n    yyA%03d", i );
  83.     } else {
  84.         fprintf( y2ytabcFD, "\n    yyANop"       );
  85.     }
  86.     if (i < y2ThisProduction-1)   fprintf( y2ytabcFD, "," );
  87.     }
  88.     fprintf( y2ytabcFD, "\n};\n\n" );
  89. }
  90.  
  91. /************************************************************************/
  92. /*    y3AGoto        Write the gotos for one nonterminal.        */
  93. /************************************************************************/
  94. static y3AGoto( c )           /* Called only from y3Gotos */
  95. int c;
  96. {
  97.     int     i, work, cc;
  98.     struct item *p, *q;
  99.   
  100.   
  101.     /* First, find nonterminals with gotos on c: */
  102.   
  103.     y1ArrayFill( y1Temp, y2LastNonterminal+1, 0 );
  104.  
  105.     y1Temp[ c ] = 1;
  106.   
  107.     for (work = 1;   work;   )     {
  108.     work = 0;
  109.  
  110.     FORaLLpRODUCTIONS(0,i) {
  111.  
  112.         if ((cc = y2Production[ i ][ 1 ] - FIRSTnONTERMINAL)   >=    0) {
  113.  
  114.                 /* cc is a nonterminal: */
  115.  
  116.         if (y1Temp[ cc ]) {
  117.  
  118.             /* cc has a goto on c: */
  119.  
  120.             /* Thus, the left side of production i does too: */
  121.             cc = *y2Production[ i ] - FIRSTnONTERMINAL;
  122.  
  123.             if (y1Temp[cc] == 0) {
  124.             work      = 1;
  125.             y1Temp[cc] = 1;
  126.             }
  127.         }
  128.             } 
  129.     }
  130.     }
  131.   
  132.     /* "Now, we have y1Temp[c] = 1 if a goto on c in closure of cc" :-) */
  133.   
  134. #ifdef debug 
  135.     if (y2OutputFD != NULL) {
  136.  
  137.     fprintf( y2OutputFD, "%s: gotos on ", y2NonterminalState[c].name );
  138.  
  139.     FORaLLnONTERMINALS(i) {
  140.         if (y1Temp[i]) {
  141.         fprintf( y2OutputFD, "%s ", y2NonterminalState[i].name);
  142.         }
  143.         }
  144.     fprintf( y2OutputFD, "\n");
  145.     }
  146. #endif 
  147.  
  148.     /* Now, go through and put gotos into y1StateType: */
  149.   
  150.     y1ArrayFill( y1StateType, y1NextState, 0 );
  151.  
  152.     FORaLLsTATES(i) {
  153.  
  154.     FORaLLiTEMS(i,p,q) {
  155.  
  156.         if ((cc = *p->pitem)   >=    FIRSTnONTERMINAL) {
  157.  
  158.         if (y1Temp[cc -= FIRSTnONTERMINAL]) {
  159.  
  160.             /* goto on c is possible: */
  161.             y1StateType[ i ]    = y1Action[ y1GotoIndex[ i ] +c ];
  162.             break;
  163.         }
  164.             } 
  165.     }
  166.     }
  167. }
  168.  
  169. /************************************************************************/
  170. /*    y3Gotos           Write the gotos for all nonterminals.           */
  171. /************************************************************************/
  172. y3Gotos() {        /* Called only from main. */
  173.     int   i, j, k, best, count, cbest, times;
  174.   
  175.     /* Mark begining of gotos: */
  176.     fprintf( y2TempFileFD, "$\n" );
  177.  
  178.     for (i = 1;   i <= y2LastNonterminal;   ++i) {
  179.  
  180.     y3AGoto( i );
  181.   
  182.     /* Find the best one to make default: */
  183.   
  184.     best    = -1;
  185.     times    = 0;
  186.   
  187.     for (j = 0;   j <= y1NextState;   ++j) {
  188.  
  189.         /* Is j the most frequent? */
  190.         if (y1StateType[ j ]   ==     0)   continue;
  191.         if (y1StateType[ j ]   == best)   continue;
  192.   
  193.         /* Is y1StateType[j] the most frequent? */
  194.   
  195.         count   = 0;
  196.         cbest   = y1StateType[ j ];
  197.   
  198.         for (k = j;   k <= y1NextState;   ++k) {
  199.  
  200.         if (y1StateType[ k ]   ==   cbest)   ++count;
  201.   
  202.         }
  203.         if (count > times) {
  204.         best    = cbest;
  205.         times    = count;
  206.         }
  207.     }
  208.  
  209.     /* Best is now the default entry: */
  210.  
  211.     y1GotosSavedByDefault += (times-1);
  212.  
  213.     for (j = 0;   j <= y1NextState;   ++j) {
  214.  
  215.         if (y1StateType[ j ] != 0    &&   y1StateType[ j ] != best) {
  216.  
  217.         fprintf( y2TempFileFD, "%d,%d,", j, y1StateType[j] );
  218.         y1GotoEntries += 1;
  219.         }
  220.     }
  221.  
  222.     /* Now, the default: */
  223.  
  224.     y1GotoEntries += 1;
  225.     fprintf( y2TempFileFD, "%d\n", best );
  226.     }
  227. }
  228.  
  229. /************************************************************************/
  230. /*    y3HideProductions Free up mem[] and y1Action[] for optimizer.        */
  231. /************************************************************************/
  232. y3HideProductions() {        /* Called only from main. */
  233.  
  234.     /********************************************************************/
  235.     /* In order to free up the mem and y1Action arrays for the optimizer,   */
  236.     /* and still be able to output yyr1, etc., after the sizes of    */
  237.     /* the action array is known, we hide the nonterminals        */
  238.     /* derived by productions in y2ProductionProperties:                */
  239.     /********************************************************************/
  240.  
  241.     register i, j;
  242.           
  243.     j        = 0;
  244.     y2ProductionProperties[0]    = 0;
  245.  
  246.     FORaLLpRODUCTIONS(1,i) {
  247.     if ( !(y2ProductionProperties[i] & RULEhASbEENrEDUCED) ) {
  248.         ++j;
  249.  
  250.         if (y2OutputFD != NULL) {
  251.         fprintf(
  252.             y2OutputFD,
  253.             "Rule not reduced:   %s\n",
  254.             y1WriteItem( y2Production[i] )
  255.         );
  256.             } 
  257.     }
  258.     y2ProductionProperties[i] = *y2Production[i] - FIRSTnONTERMINAL;
  259.     }
  260.     if (j)  fprintf( stdout, "%d rules never reduced\n", j );
  261. }
  262.  
  263. /************************************************************************/
  264. /*    y3PackState    Pack state i from y1Temp into y1Action.          */
  265. /************************************************************************/ 
  266. y3PackState( p, n )     /* Called only from y1MakeStates        */ 
  267. int *p; 
  268. { 
  269.     int off; 
  270.     register *pp, *qq, *rr; 
  271.     int *q, *r; 
  272.            
  273.     /****************************************************/ 
  274.     /* We don't need to worry about checking because we */ 
  275.     /* will only look for entries known to be there.    */
  276.     /****************************************************/ 
  277.   
  278.     /* Eliminate leading and trailing 0's: */ 
  279.            
  280.     q   = p+n; 
  281.   
  282.     for (pp=p, off=0;   *pp==0 && pp<=q;   ++pp, --off); 
  283.   
  284.     if (pp > q)   return(0);  /* no actions */ 
  285.   
  286.     p   = pp; 
  287.            
  288.     /* Now, find a place for the elements from p to q, inclusive: */ 
  289.            
  290.     r    = &y1Action[ MAXaCTIONS -1 ];
  291.   
  292.     for (rr = y1Action;   rr <= r;   ++rr, ++off) {
  293.   
  294.         /* Try rr: */ 
  295.         for (qq=rr, pp=p;   pp <= q;   ++pp, ++qq) { 
  296.   
  297.             if (*pp != 0 ) { 
  298.                 if (*pp != *qq   &&   *qq != 0)   goto nextk; 
  299.             }  
  300.         } 
  301.            
  302.         /* We have found an acceptable k: */ 
  303.            
  304. #ifdef debug  
  305.     if (y2OutputFD != NULL) {
  306.          fprintf(y2OutputFD,"off = %d, k = %d\n",off,rr-y1Action);
  307.     }
  308. #endif     
  309.   
  310.         for (qq=rr, pp=p;   pp <= q;   ++pp, ++qq) { 
  311.   
  312.             if (*pp) { 
  313.         if (qq > r   )     {
  314.             y1Error( "y3PackState: Action table overflow" );
  315.         }
  316.                 if (qq > y1NextAction)   y1NextAction = qq;
  317.                 *qq = *pp; 
  318.             }  
  319.         } 
  320.   
  321. #ifdef debug  
  322.     if (y2OutputFD != NULL) {
  323.         for (pp = y1Action;   pp <= y1NextAction;    pp += 10) {
  324.         fprintf( y2OutputFD, "\t");
  325.                 for (qq = pp;   qq <= pp+9;   ++qq) { 
  326.             fprintf( y2OutputFD, "%d ", *qq );
  327.                 } 
  328.         fprintf( y2OutputFD, "\n" );
  329.             }  
  330.         } 
  331. #endif     
  332.   
  333.         return   off; 
  334.            
  335. nextk:  ; 
  336.     } 
  337.   
  338.     y1Error( "y3PackState: No space in action table" );
  339.   
  340.     /* NOTREACHED */ 
  341. } 
  342.   
  343. /************************************************************************/
  344. /*    y3PutArray        Write out an array.                             */ 
  345. /************************************************************************/ 
  346. y3PutArray( s, v, n )           /* Called only from y1Others */ 
  347. char *s; 
  348. int  *v, n; 
  349. { 
  350.     register i; 
  351.            
  352.     fprintf( y2ytabcFD, "\nshort %s[] = {\n", s );
  353.   
  354.     for (i = 0;   i < n;   ) { 
  355.   
  356.     if (i % 10   ==   0)   fprintf( y2ytabcFD, "\n" );
  357.   
  358.     fprintf( y2ytabcFD, "%4d", v[i] );
  359.   
  360.     if (++i == n)    fprintf( y2ytabcFD, "\n};\n" );
  361.     else        fprintf( y2ytabcFD, ","      );
  362.     } 
  363. } 
  364.   
  365. /************************************************************************/
  366. /*    y3PutStates       Write the states and tables.                    */
  367. /************************************************************************/
  368. y3PutStates() {     /* Called only from main. */
  369.  
  370.     int          i, k, c;
  371.     register struct wset *u, *v;
  372.           
  373.     fprintf( y2ytabcFD, "\nshort yyexca[] = {\n" );
  374.           
  375.     FORaLLsTATES(i) {
  376.           
  377.     /* Write the stuff for state i: */
  378.     y1NoLookahead = !(y1StateType[i]==MUSTlOOKaHEADsTATE);
  379.     y1Closure(i);
  380.           
  381.     /* Write actions: */
  382.     y1NoLookahead = 1;
  383.     y1ArrayFill( y1Temp, y2NextTerminal+y2LastNonterminal+1, 0 );
  384.  
  385.     FORaLLwORKINGsETS(y1WorkingSet,u)  {
  386.           
  387.         c = *( u->pitem );
  388.  
  389.         if (c > 1    &&   c < FIRSTnONTERMINAL   &&     y1Temp[ c ] == 0) {
  390.  
  391.         FORaLLwORKINGsETS(u,v) {
  392.  
  393.             if (c == *(v->pitem)) {
  394.             y1PutItem( v->pitem+1, (struct looksets *)0 );
  395.             }
  396.         }
  397.         y1Temp[ c ]  = y1State( c );
  398.  
  399.         } else if( c > FIRSTnONTERMINAL && !y1Temp[ (c -= FIRSTnONTERMINAL) + y2NextTerminal ]) {
  400.  
  401.         y1Temp[ c+y2NextTerminal ] = y1Action[y1GotoIndex[i]+c];
  402.             } 
  403.     }
  404.           
  405.     if (i == 1)   y1Temp[ 1 ] = ACCEPTaCTION;
  406.           
  407.     /* We have the shifts;    Look at the reductions: */
  408.           
  409.     y3LastReduction = 0;
  410.  
  411.     FORaLLwORKINGsETS(y1WorkingSet,u) {
  412.  
  413.         c = *( u->pitem );
  414.  
  415.         if (c <= 0) {
  416.  
  417.         /* Reduction: */
  418.         y3LastReduction = -c;
  419.  
  420.         FORaLLtERMINALS(k) {
  421.  
  422.             if (GETBIT(u->ws.lset,k)) {
  423.  
  424.             if (y1Temp[ k ] == 0)  {
  425.  
  426.                 y1Temp[ k ] = c;
  427.  
  428.             } else if( y1Temp[k]<0 ) {
  429.  
  430.                 /* Reduce/reduce conflict: */
  431.                 if (y2OutputFD != NULL) {
  432.                 fprintf(
  433.                     y2OutputFD,
  434.                     "\n%d: reduce/reduce conflict (red'ns %d and %d ) on %s",
  435.                     i,
  436.                     -y1Temp[k],
  437.                     y3LastReduction,
  438.                     y1SymbolName(k)
  439.                 );
  440.                 }
  441.  
  442.                 if (-y1Temp[k] > y3LastReduction)    y1Temp[k] = -y3LastReduction;
  443.                 ++y1ReduceReduceConflicts;
  444.  
  445.             } else {
  446.  
  447.                 /* Potential shift/reduce conflict: */
  448.                 y3ShiftReduce( y3LastReduction, k, i );
  449.             }
  450.             }
  451.         }
  452.         }
  453.     }
  454.     y3WrtAction(i);
  455.     }
  456.     fprintf( y2ytabcFD, "\n};\n" );
  457.           
  458.     fprintf( y2ytabcFD, "# define %s %d\n", "YYNPROD", y2ThisProduction );
  459. }
  460.  
  461. /************************************************************************/
  462. /*      y3ShiftReduce   Decide a shift/reduce conflict by precedence.   */ 
  463. /************************************************************************/ 
  464. y3ShiftReduce(r,t,s)            /* Called only from y3PutStates */ 
  465. int r, t, s; 
  466. { 
  467.     /*****************************************************/ 
  468.     /* Decide a shift/reduce conflict by precedence.     */ 
  469.     /* r is a rule number, t a token number.             */ 
  470.     /* The conflict is in state s.                       */ 
  471.     /* y1Temp[t] is changed to reflect the action.      */
  472.     /*****************************************************/ 
  473.            
  474.     int lp,lt, action; 
  475.            
  476.     lp    = y2ProductionProperties[ r ];
  477.     lt    = y2TerminalProperties[ t ];
  478.   
  479.     if ( 
  480.     ! PRECEDENCElEVEL(lt)
  481.         || 
  482.     ! PRECEDENCElEVEL(lp)
  483.     ) { 
  484.   
  485.         /* Conflict: */ 
  486.     if (y2OutputFD != NULL) {
  487.             fprintf( 
  488.         y2OutputFD,
  489.                 "\n%d: shift/reduce conflict (shift %d, red'n %d) on %s", 
  490.                 s, 
  491.         y1Temp[t],
  492.                 r, 
  493.                 y1SymbolName(t) 
  494.             ); 
  495.         } 
  496.     ++y1ShiftReduceConflicts;
  497.         return; 
  498.     } 
  499.   
  500.     if (PRECEDENCElEVEL(lt) == PRECEDENCElEVEL(lp)) {
  501.   
  502.     action = ASSOCIATIVITY(lt);
  503.   
  504.     } else if( PRECEDENCElEVEL(lt) > PRECEDENCElEVEL(lp) ) {
  505.   
  506.         /* Shift: */ 
  507.     action = RIGHTaSSOCIATIVE;
  508.   
  509.     } else { 
  510.   
  511.         /* Reduce: */ 
  512.     action = LEFTaSSOCIATIVE;
  513.     } 
  514.            
  515.     switch (action) { 
  516.   
  517.     case BINARYaSSOCIATIVE:
  518.         /* Error action: */ 
  519.     y1Temp[t] = ERRORaCTION;
  520.         return; 
  521.            
  522.     case LEFTaSSOCIATIVE:
  523.         /* Reduce: */ 
  524.     y1Temp[t] = -r;
  525.         return; 
  526.     } 
  527. } 
  528.   
  529.   
  530. /************************************************************************/
  531. /*    y3WrtAction    Write out state i.                */
  532. /************************************************************************/
  533. static y3WrtAction( i )     /* Called only from y3PutStates */
  534. int i;
  535. {
  536.     /* Write out state i.  y1Temp has the actions, y3LastReduction the default: */
  537.     int p, p0, p1;
  538.     int ntimes, tred, count, j;
  539.     int flag;
  540.           
  541.     /* Find the best choice for y3LastReduction: */
  542.           
  543.     y3LastReduction = 0;
  544.     ntimes  = 0;
  545.  
  546.     FORaLLtERMINALS(j) {
  547.  
  548.     if (y1Temp[ j ]         >=     0)   continue;
  549.     if (y1Temp[ j ] + y3LastReduction   ==     0)   continue;
  550.  
  551.     /* Count the number of appearances of y1Temp[j]: */
  552.  
  553.     count        = 0;
  554.     tred        = -y1Temp[ j ];
  555.     y2ProductionProperties[tred]   |= RULEhASbEENrEDUCED;
  556.  
  557.     FORaLLtERMINALS(p) {
  558.         if (y1Temp[ p ] + tred   ==   0)   ++count;
  559.     }
  560.  
  561.     if (count > ntimes) {
  562.         y3LastReduction = tred;
  563.         ntimes = count;
  564.     }
  565.     }
  566.           
  567.     /**********************************************************************/
  568.     /* For error recovery, arrange that, if there is a shift on the error */
  569.     /* recovery token, `error', that the default be the error action:      */
  570.     /**********************************************************************/
  571.  
  572.     if (y1Temp[ 1 ]   >   0)   y3LastReduction = 0;
  573.           
  574.     /* Clear out entries in y1Temp which equal y3LastReduction: */
  575.  
  576.     FORaLLtERMINALS(p)     if (y1Temp[ p ] + y3LastReduction   ==   0)   y1Temp[ p ] = 0;
  577.           
  578.     y3WrtState( i );
  579.  
  580.     y3DefaultAction[ i ] = y3LastReduction;
  581.     flag    =    0;
  582.  
  583.     FORaLLtERMINALS(p0) {
  584.  
  585.     if (p1 = y1Temp[ p0 ]) {
  586.  
  587.             if (p1 < 0) {
  588.  
  589.                 p1 = -p1;
  590.         goto exc;
  591.  
  592.         } else if( p1 == ACCEPTaCTION ) {
  593.  
  594.         p1 = -1;
  595.         goto exc;
  596.  
  597.         } else if( p1 ==    ERRORaCTION ) {
  598.  
  599.         p1 = 0;
  600.         goto exc;
  601. exc:      
  602.         if (flag++ == 0)   fprintf( y2ytabcFD, "-1, %d,\n", i );
  603.         fprintf( y2ytabcFD, "\t%d, %d,\n", y2Terminal[p0].value, p1 );
  604.         ++y1Exceptions;
  605.  
  606.             } else {
  607.         fprintf( y2TempFileFD, "%d,%d,", y2Terminal[p0].value, p1 );
  608.         ++y1ShiftEntries;
  609.             } 
  610.     }
  611.     }
  612.  
  613.     if (flag) {
  614.     y3DefaultAction[ i ] = -2;
  615.     fprintf( y2ytabcFD, "\t-2, %d,\n", y3LastReduction );
  616.     }
  617.     fprintf( y2TempFileFD, "\n" );
  618.     return;
  619. }
  620.  
  621. /************************************************************************/
  622. /*    y3WrtState    Write state i.                    */
  623. /************************************************************************/
  624. static y3WrtState( i )           /* Called only from y3WrtAction */
  625. int i;
  626. {
  627.     register          j0,j1;
  628.     register struct   item *pp, *qq;
  629.     register struct   wset *u;
  630.           
  631.     if (y2OutputFD == NULL)   return;
  632.     fprintf( y2OutputFD, "\nstate %d\n", i );
  633.  
  634.     FORaLLiTEMS( i, pp, qq ) {
  635.     fprintf( y2OutputFD, "\t%s\n", y1WriteItem(pp->pitem) );
  636.     }
  637.  
  638.     if (y1StateType[i] == MUSTlOOKaHEADsTATE) {
  639.  
  640.     /* Print out empty productions in closure: */
  641.     FORaLLwORKINGsETS( y1WorkingSet+(y1StateItem[i+1]-y1StateItem[i]), u ){
  642.  
  643.         if( *(u->pitem) < 0 )  {
  644.         fprintf( y2OutputFD, "\t%s\n", y1WriteItem(u->pitem) );
  645.         }
  646.     }
  647.     }
  648.           
  649.     /* Check for state equal to another: */
  650.           
  651.     FORaLLtERMINALS(j0) {
  652.  
  653.     if (j1 = y1Temp[ j0 ]) {
  654.  
  655.         fprintf( y2OutputFD, "\n\t%s  ", y1SymbolName(j0) );
  656.  
  657.         if (j1 <= 0) {
  658.         fprintf( y2OutputFD, "reduce %d",-j1 );
  659.         } else {
  660.  
  661.         /* Shift, error, or accept: */
  662.         if    (j1 == ACCEPTaCTION ) fprintf( y2OutputFD, "accept"  );
  663.         else if (j1 ==    ERRORaCTION ) fprintf( y2OutputFD, "error"   );
  664.         else             fprintf( y2OutputFD, "shift %d", j1 );
  665.         }
  666.     }
  667.     }
  668.           
  669.     /* Write the final production: */
  670.           
  671.     if (y3LastReduction)  {
  672.     fprintf( y2OutputFD, "\n\t.  reduce %d\n\n", y3LastReduction );
  673.     } else {
  674.     fprintf( y2OutputFD, "\n\t.  error\n\n"              );
  675.     }
  676.           
  677.     /* Now, output nonterminal actions: */
  678.           
  679.     j1    = y2NextTerminal;
  680.  
  681.     for (j0 = 1;   j0 <= y2LastNonterminal;   ++j0) {
  682.     if (y1Temp[ ++j1 ])  {
  683.         fprintf(
  684.         y2OutputFD,
  685.         "\t%s  goto %d\n",
  686.         y1SymbolName( j0+FIRSTnONTERMINAL),
  687.         y1Temp[j1]
  688.         );
  689.     }
  690.     }
  691. }
  692.           
  693.  
  694.