Attach actions to rules, instead of pre-outputting them to

[bison.git] / src / output.c

diff --git a/src/output.c b/src/output.c
index 87ab880e1365e8d26032a6d1fa49248b34e68bfe..7c2d0136721a335b2fc56eb116ff92a3453f55d7 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -104,7 +104,6 @@
 #include "conflicts.h"
 #include "muscle_tab.h"
 
 #include "conflicts.h"
 #include "muscle_tab.h"
 

-extern void berror PARAMS((const char *));

 
 static int nvectors;
 static int nentries;
 
 static int nvectors;
 static int nentries;


@@ -125,6 +124,8 @@ static int high;
 struct obstack muscle_obstack;
 struct obstack output_obstack;
 
 struct obstack muscle_obstack;
 struct obstack output_obstack;
 

+int error_verbose = 0;
+

 /* FIXME. */
 
 static inline void
 /* FIXME. */
 
 static inline void


@@ -197,11 +198,6 @@ output_gram (void)
 
     XFREE (yyrhs);
   }
 
     XFREE (yyrhs);
   }

-
-#if 0
-  if (!semantic_parser && !no_parser_flag)
-    obstack_sgrow (&table_obstack, "\n#endif\n");
-#endif

 }
 
 
 }
 
 


@@ -211,7 +207,7 @@ output_stos (void)
   int i;
   short *values = (short *) alloca (sizeof (short) * nstates);
   for (i = 0; i < nstates; ++i)
   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));
   output_table_data (&output_obstack, values,
                     0, 1, nstates);
   muscle_insert ("stos", obstack_finish (&output_obstack));


@@ -238,22 +234,14 @@ output_rule_data (void)
 
   j = 0;
   for (i = 0; i < nsyms; i++)
 
   j = 0;
   for (i = 0; i < nsyms; i++)

-    /* this used to be i<=nsyms, but that output a final "" symbol
-       almost by accident */

     {
     {

+      /* Be sure not to use twice the same quotearg slot. */
+      const char *cp =
+       quotearg_n_style (1, c_quoting_style,
+                         quotearg_style (escape_quoting_style, tags[i]));

       /* Width of the next token, including the two quotes, the coma
         and the space.  */
       /* Width of the next token, including the two quotes, the coma
         and the space.  */

-      int strsize = 4;
-      char *p;
-
-      for (p = tags[i]; p && *p; p++)
-       if (*p == '"' || *p == '\\' || *p == '\n' || *p == '\t'
-           || *p == '\b')
-         strsize += 2;
-       else if (*p < 040 || *p >= 0177)
-         strsize += 4;
-       else
-         strsize++;
+      int strsize = strlen (cp) + 2;

 
       if (j + strsize > 75)
        {
 
       if (j + strsize > 75)
        {


@@ -261,24 +249,8 @@ output_rule_data (void)
          j = 2;
        }
 
          j = 2;
        }
 

-      obstack_1grow (&output_obstack, '\"');
-      for (p = tags[i]; p && *p; p++)
-       {
-         if (*p == '"' || *p == '\\')
-           obstack_fgrow1 (&output_obstack, "\\%c", *p);
-         else if (*p == '\n')
-           obstack_sgrow (&output_obstack, "\\n");
-         else if (*p == '\t')
-           obstack_sgrow (&output_obstack, "\\t");
-         else if (*p == '\b')
-           obstack_sgrow (&output_obstack, "\\b");
-         else if (*p < 040 || *p >= 0177)
-           obstack_fgrow1 (&output_obstack, "\\%03o", *p);
-         else
-           obstack_1grow (&output_obstack, *p);
-       }
-
-      obstack_sgrow (&output_obstack, "\", ");
+      obstack_sgrow (&output_obstack, cp);
+      obstack_sgrow (&output_obstack, ", ");

       j += strsize;
     }
   /* add a NULL entry to list of tokens */
       j += strsize;
     }
   /* add a NULL entry to list of tokens */


@@ -313,8 +285,6 @@ output_rule_data (void)
                     0, 1, nrules + 1);
   muscle_insert ("r2", obstack_finish (&output_obstack));
   XFREE (short_tab);
                     0, 1, nrules + 1);
   muscle_insert ("r2", obstack_finish (&output_obstack));
   XFREE (short_tab);

-
-  XFREE (rule_table + 1);

 }
 
 /*------------------------------------------------------------------.
 }
 
 /*------------------------------------------------------------------.


@@ -339,15 +309,11 @@ action_row (int state)
   int k;
   int m = 0;
   int n = 0;
   int k;
   int m = 0;
   int n = 0;

-  int count;

   int default_rule;
   int nreds;
   int default_rule;
   int nreds;

-  int max;

   int rule;
   int shift_state;
   int symbol;
   int rule;
   int shift_state;
   int symbol;

-  unsigned mask;
-  unsigned *wordp;

   reductions *redp;
   shifts *shiftp;
   errs *errp;
   reductions *redp;
   shifts *shiftp;
   errs *errp;


@@ -358,7 +324,7 @@ action_row (int state)
 
   default_rule = 0;
   nreds = 0;
 
   default_rule = 0;
   nreds = 0;

-  redp = state_table[state].reduction_table;
+  redp = state_table[state]->reductions;

 
   if (redp)
     {
 
   if (redp)
     {


@@ -368,69 +334,46 @@ action_row (int state)
        {
          /* loop over all the rules available here which require
             lookahead */
        {
          /* 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--)
 
          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];

        }
     }
 
        }
     }
 

-  shiftp = state_table[state].shift_table;
-

   /* 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.  */
   /* 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.  */

-
-  if (shiftp)
+  shiftp = state_table[state]->shifts;
+  for (i = 0; i < shiftp->nshifts; i++)

     {
     {

-      k = shiftp->nshifts;
-
-      for (i = 0; i < k; i++)
-       {
-         shift_state = shiftp->shifts[i];
-         if (!shift_state)
-           continue;
+      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;
+      if (ISVAR (symbol))
+       break;

 
 

-         actrow[symbol] = shift_state;
+      actrow[symbol] = shift_state;

 
 

-         /* Do not use any default reduction if there is a shift for
-            error */
-         if (symbol == error_token_number)
-           nodefault = 1;
-       }
+      /* Do not use any default reduction if there is a shift for
+        error */
+      if (symbol == error_token_number)
+       nodefault = 1;

     }
 
     }
 

-  errp = err_table[state];
-

   /* See which tokens are an explicit error in this state (due to
      %nonassoc).  For them, record MINSHORT as the action.  */
   /* See which tokens are an explicit error in this state (due to
      %nonassoc).  For them, record MINSHORT as the action.  */

+  errp = state_table[state]->errs;

 
   if (errp)
     {
 
   if (errp)
     {


@@ -448,14 +391,14 @@ action_row (int state)
 
   if (nreds >= 1 && !nodefault)
     {
 
   if (nreds >= 1 && !nodefault)
     {

-      if (state_table[state].consistent)
+      if (state_table[state]->consistent)

        default_rule = redp->rules[0];
       else
        {
        default_rule = redp->rules[0];
       else
        {

-         max = 0;
+         int max = 0;

          for (i = m; i < n; i++)
            {
          for (i = m; i < n; i++)
            {

-             count = 0;
+             int count = 0;

              rule = -LAruleno[i];
 
              for (j = 0; j < ntokens; j++)
              rule = -LAruleno[i];
 
              for (j = 0; j < ntokens; j++)


@@ -567,33 +510,34 @@ token_actions (void)
 }
 
 
 }
 
 

-static void
-free_shifts (void)
-{
-  shifts *sp, *sptmp;  /* JF derefrenced freed ptr */
-
-  for (sp = first_shift; sp; sp = sptmp)
-    {
-      sptmp = sp->next;
-      XFREE (sp);
-    }
-}
-
+/*-----------------------------.
+| Output the actions to OOUT.  |
+`-----------------------------*/

 
 static void
 
 static void

-free_reductions (void)
+actions_output (struct obstack *oout)

 {
 {

-  reductions *rp, *rptmp;      /* JF fixed freed ptr */
-
-  for (rp = first_reduction; rp; rp = rptmp)
-    {
-      rptmp = rp->next;
-      XFREE (rp);
-    }
+  int rule;
+  for (rule = 1; rule < nrules + 1; ++rule)
+    if (rule_table[rule].action)
+      {
+       obstack_fgrow1 (oout, "  case %d:\n", rule);
+
+       if (!no_lines_flag)
+         obstack_fgrow2 (oout, muscle_find ("linef"),
+                         rule_table[rule].action_line,
+                         quotearg_style (c_quoting_style,
+                                         muscle_find ("filename")));
+       obstack_1grow (oout, '{');
+       obstack_sgrow (oout, rule_table[rule].action);
+       /* As a Bison extension, add the ending semicolon.  Since some
+          Yacc don't do that, help people using bison as a Yacc
+          finding their missing semicolons.  */
+       obstack_fgrow1 (oout, "%s}\n    break;\n\n", yacc_flag ? ";" : "");
+      }

 }
 
 
 }
 
 

-

 static void
 save_column (int symbol, int default_state)
 {
 static void
 save_column (int symbol, int default_state)
 {


@@ -841,8 +785,8 @@ pack_vector (int vector)
        }
     }
 
        }
     }
 

-  berror ("pack_vector");
-  return 0;                    /* JF keep lint happy */
+  assert (!"pack_vector");
+  return 0;

 }
 
 
 }
 
 


@@ -938,6 +882,7 @@ output_check (void)
 static void
 output_actions (void)
 {
 static void
 output_actions (void)
 {

+  int i;

   nvectors = nstates + nvars;
 
   froms = XCALLOC (short *, nvectors);
   nvectors = nstates + nvars;
 
   froms = XCALLOC (short *, nvectors);


@@ -946,8 +891,6 @@ output_actions (void)
   width = XCALLOC (short, nvectors);
 
   token_actions ();
   width = XCALLOC (short, nvectors);
 
   token_actions ();

-  free_shifts ();
-  free_reductions ();

   XFREE (LA);
   XFREE (LAruleno);
 
   XFREE (LA);
   XFREE (LAruleno);
 


@@ -963,6 +906,14 @@ output_actions (void)
   output_table ();
 
   output_check ();
   output_table ();
 
   output_check ();

+
+  for (i = 0; i < nstates; ++i)
+    {
+      XFREE (state_table[i]->shifts);
+      XFREE (state_table[i]->reductions);
+      XFREE (state_table[i]->errs);
+      free (state_table[i]);
+    }

   XFREE (state_table);
 }
 
   XFREE (state_table);
 }
 


@@ -999,20 +950,19 @@ output_parser (const char *skel_filename, struct obstack *oout)
          const char *muscle_key = 0;
          const char *muscle_value = 0;
 
          const char *muscle_key = 0;
          const char *muscle_value = 0;
 

-         while (isalnum (c = getc (fskel)) || c == '_')
+         while (isalnum (c = getc (fskel)) || c == '-')

            obstack_1grow (&muscle_obstack, c);
          obstack_1grow (&muscle_obstack, 0);
 
          /* Output the right value, or see if it's something special.  */
          muscle_key = obstack_finish (&muscle_obstack);
          muscle_value = muscle_find (muscle_key);
            obstack_1grow (&muscle_obstack, c);
          obstack_1grow (&muscle_obstack, 0);
 
          /* Output the right value, or see if it's something special.  */
          muscle_key = obstack_finish (&muscle_obstack);
          muscle_value = muscle_find (muscle_key);

-         if (muscle_value)
-           obstack_sgrow (oout, muscle_value);
+         if (!strcmp (muscle_key, "actions"))
+           actions_output (oout);

          else if (!strcmp (muscle_key, "line"))
            obstack_fgrow1 (oout, "%d", line + 1);
          else if (!strcmp (muscle_key, "line"))
            obstack_fgrow1 (oout, "%d", line + 1);

-         else if (!strcmp (muscle_key, "input_line"))
-           obstack_fgrow1 (oout, "%d", lineno);
-         /* FIXME: Insert the code to recognize %%sub-skeleton for exemple.  */
+         else if (muscle_value)
+           obstack_sgrow (oout, muscle_value);

          else
            {
              obstack_sgrow (oout, "%%");
          else
            {
              obstack_sgrow (oout, "%%");


@@ -1041,21 +991,11 @@ output_master_parser (void)
       else
        skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
     }
       else
        skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
     }

+  muscle_insert ("skeleton", skeleton);

   output_parser (skeleton, &table_obstack);
 }
 
 
   output_parser (skeleton, &table_obstack);
 }
 
 

-static void
-free_itemsets (void)
-{
-  core *cp, *cptmp;
-  for (cp = first_state; cp; cp = cptmp)
-    {
-      cptmp = cp->next;
-      XFREE (cp);
-    }
-}
-

 /* FIXME. */
 
 #define MUSCLE_INSERT_INT(Key, Value)                          \
 /* FIXME. */
 
 #define MUSCLE_INSERT_INT(Key, Value)                          \


@@ -1090,20 +1030,15 @@ prepare (void)
   MUSCLE_INSERT_INT ("final", final_state);
   MUSCLE_INSERT_INT ("maxtok", max_user_token_number);
   MUSCLE_INSERT_INT ("ntbase", ntokens);
   MUSCLE_INSERT_INT ("final", final_state);
   MUSCLE_INSERT_INT ("maxtok", max_user_token_number);
   MUSCLE_INSERT_INT ("ntbase", ntokens);

-  MUSCLE_INSERT_INT ("verbose", 0);
+  MUSCLE_INSERT_INT ("error-verbose", error_verbose);
+  MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);

 
   MUSCLE_INSERT_INT ("nnts", nvars);
   MUSCLE_INSERT_INT ("nrules", nrules);
   MUSCLE_INSERT_INT ("nstates", nstates);
   MUSCLE_INSERT_INT ("ntokens", ntokens);
 
 
   MUSCLE_INSERT_INT ("nnts", nvars);
   MUSCLE_INSERT_INT ("nrules", nrules);
   MUSCLE_INSERT_INT ("nstates", nstates);
   MUSCLE_INSERT_INT ("ntokens", ntokens);
 

-  MUSCLE_INSERT_INT ("locations_flag", locations_flag);
-
-  /* We need to save the actions in the muscle %%action.  */
-  muscle_insert ("action", obstack_finish (&action_obstack));
-
-  if (spec_name_prefix)
-    MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
+  MUSCLE_INSERT_INT ("locations-flag", locations_flag);

 }
 
 /*----------------------------------------------------------.
 }
 
 /*----------------------------------------------------------.


@@ -1115,8 +1050,6 @@ output (void)
 {
   obstack_init (&output_obstack);
 
 {
   obstack_init (&output_obstack);
 

-  free_itemsets ();
-

   output_token_translations ();
   output_gram ();
 
   output_token_translations ();
   output_gram ();
 


@@ -1127,15 +1060,14 @@ output (void)
   XFREE (user_toknums);
   output_actions ();
 
   XFREE (user_toknums);
   output_actions ();
 

-#if 0
-  if (!no_parser_flag) */
-#endif

   prepare ();
   /* Copy definitions in directive.  */
   prepare ();
   /* Copy definitions in directive.  */

+  obstack_1grow (&attrs_obstack, 0);

   muscle_insert ("prologue", obstack_finish (&attrs_obstack));
 
   output_master_parser ();
 
   muscle_insert ("prologue", obstack_finish (&attrs_obstack));
 
   output_master_parser ();
 

+  free (rule_table + 1);

   obstack_free (&muscle_obstack, 0);
   obstack_free (&output_obstack, 0);
   obstack_free (&action_obstack, 0);
   obstack_free (&muscle_obstack, 0);
   obstack_free (&output_obstack, 0);
   obstack_free (&action_obstack, 0);