* src/output.c (output, prepare): Make sure the values of the

[bison.git] / src / output.c

diff --git a/src/output.c b/src/output.c
index dd64fe7d03d7328f47fa07bc35ba2eaad2f5c4fa..dbcfbf0119924a480af72a8880bde8d765f84c92 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -104,7 +104,6 @@
 #include "conflicts.h"
 #include "muscle_tab.h"
 
-extern void berror PARAMS((const char *));
 
 static int nvectors;
 static int nentries;
@@ -213,7 +212,7 @@ output_stos (void)
   int i;
   short *values = (short *) alloca (sizeof (short) * nstates);
   for (i = 0; i < nstates; ++i)
-    values[i] = state_table[i].accessing_symbol;
+    values[i] = state_table[i]->accessing_symbol;
   output_table_data (&output_obstack, values,
                     0, 1, nstates);
   muscle_insert ("stos", obstack_finish (&output_obstack));
@@ -341,15 +340,11 @@ action_row (int state)
   int k;
   int m = 0;
   int n = 0;
-  int count;
   int default_rule;
   int nreds;
-  int max;
   int rule;
   int shift_state;
   int symbol;
-  unsigned mask;
-  unsigned *wordp;
   reductions *redp;
   shifts *shiftp;
   errs *errp;
@@ -360,7 +355,7 @@ action_row (int state)
 
   default_rule = 0;
   nreds = 0;
-  redp = state_table[state].reduction_table;
+  redp = state_table[state]->reductions;
 
   if (redp)
     {
@@ -370,47 +365,31 @@ action_row (int state)
        {
          /* loop over all the rules available here which require
             lookahead */
-         m = state_table[state].lookaheads;
-         n = state_table[state + 1].lookaheads;
+         m = state_table[state]->lookaheads;
+         n = state_table[state + 1]->lookaheads;
 
          for (i = n - 1; i >= m; i--)
-           {
-             rule = -LAruleno[i];
-             wordp = LA (i);
-             mask = 1;
-
-             /* and find each token which the rule finds acceptable
-                to come next */
-             for (j = 0; j < ntokens; j++)
-               {
-                 /* and record this rule as the rule to use if that
-                    token follows.  */
-                 if (mask & *wordp)
-                   actrow[j] = rule;
-
-                 mask <<= 1;
-                 if (mask == 0)
-                   {
-                     mask = 1;
-                     wordp++;
-                   }
-               }
-           }
+           /* and find each token which the rule finds acceptable
+              to come next */
+           for (j = 0; j < ntokens; j++)
+             /* and record this rule as the rule to use if that
+                token follows.  */
+             if (BITISSET (LA (i), j))
+               actrow[j] = -LAruleno[i];
        }
     }
 
   /* Now see which tokens are allowed for shifts in this state.  For
      them, record the shift as the thing to do.  So shift is preferred
      to reduce.  */
-  shiftp = state_table[state].shift_table;
-
+  shiftp = state_table[state]->shifts;
   for (i = 0; i < shiftp->nshifts; i++)
     {
       shift_state = shiftp->shifts[i];
       if (!shift_state)
        continue;
 
-      symbol = state_table[shift_state].accessing_symbol;
+      symbol = state_table[shift_state]->accessing_symbol;
 
       if (ISVAR (symbol))
        break;
@@ -425,7 +404,7 @@ action_row (int state)
 
   /* See which tokens are an explicit error in this state (due to
      %nonassoc).  For them, record MINSHORT as the action.  */
-  errp = err_table[state];
+  errp = state_table[state]->errs;
 
   if (errp)
     {
@@ -443,14 +422,14 @@ action_row (int state)
 
   if (nreds >= 1 && !nodefault)
     {
-      if (state_table[state].consistent)
+      if (state_table[state]->consistent)
        default_rule = redp->rules[0];
       else
        {
-         max = 0;
+         int max = 0;
          for (i = m; i < n; i++)
            {
-             count = 0;
+             int count = 0;
              rule = -LAruleno[i];
 
              for (j = 0; j < ntokens; j++)
@@ -809,8 +788,8 @@ pack_vector (int vector)
        }
     }
 
-  berror ("pack_vector");
-  return 0;                    /* JF keep lint happy */
+  assert (!"pack_vector");
+  return 0;
 }
 
 
@@ -931,6 +910,7 @@ output_actions (void)
   output_table ();
 
   output_check ();
+  LIST_FREE (state_t, first_state);
   XFREE (state_table);
 }
 
@@ -1008,7 +988,7 @@ output_master_parser (void)
       else
        skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
     }
-  muscle_insert ("skeleton", skeleton);    
+  muscle_insert ("skeleton", skeleton);
   output_parser (skeleton, &table_obstack);
 }
 
@@ -1057,6 +1037,7 @@ prepare (void)
   MUSCLE_INSERT_INT ("locations-flag", locations_flag);
 
   /* We need to save the actions in the muscle %%action.  */
+  obstack_1grow (&action_obstack, 0);
   muscle_insert ("action", obstack_finish (&action_obstack));
 
   if (spec_name_prefix)
@@ -1072,8 +1053,6 @@ output (void)
 {
   obstack_init (&output_obstack);
 
-  LIST_FREE (core, first_state);
-
   output_token_translations ();
   output_gram ();
 
@@ -1089,6 +1068,7 @@ output (void)
 #endif
   prepare ();
   /* Copy definitions in directive.  */
+  obstack_1grow (&attrs_obstack, 0);
   muscle_insert ("prologue", obstack_finish (&attrs_obstack));
 
   output_master_parser ();