* src/gram.h, src/gram.c (pure_parser, glr_parser): Move to...

[bison.git] / src / output.c

diff --git a/src/output.c b/src/output.c
index 832f4ed9037319e98ccab02cc09b99ef951151f6..939775af4e11fdb755dffba864082fb00a2b58c2 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -1,5 +1,6 @@
-/* Output the generated parsing program for bison,
-   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
+/* Output the generated parsing program for Bison.
+
+   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003

    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.


@@ -20,151 +21,33 @@
    02111-1307, USA.  */
 
 
    02111-1307, USA.  */
 
 

-/* The parser tables consist of these tables.  Marked ones needed only
-   for the semantic parser.  Double marked are output only if switches
-   are set.
-
-   YYTRANSLATE = vector mapping yylex's token numbers into bison's
-   token numbers.
-
-   ++ YYTNAME = vector of string-names indexed by bison token number.
-
-   ++ YYTOKNUM = vector of yylex token numbers corresponding to
-   entries in YYTNAME.
-
-   YYRLINE = vector of line-numbers of all rules.  For yydebug
-   printouts.
-
-   YYRHS = vector of items of all rules.  This is exactly what RITEMS
-   contains.  For yydebug and for semantic parser.
-
-   YYPRHS[R] = index in YYRHS of first item for rule R.
-
-   YYR1[R] = symbol number of symbol that rule R derives.
-
-   YYR2[R] = number of symbols composing right hand side of rule R.
-
-   + YYSTOS[S] = the symbol number of the symbol that leads to state
-   S.
-
-   YYDEFACT[S] = default rule to reduce with in state s, when YYTABLE
-   doesn't specify something else to do.  Zero means the default is an
-   error.
-
-   YYDEFGOTO[I] = default state to go to after a reduction of a rule
-   that generates variable NTOKENS + I, except when YYTABLE specifies
-   something else to do.
-
-   YYPACT[S] = index in YYTABLE of the portion describing state S.
-   The lookahead token's type is used to index that portion to find
-   out what to do.
-
-   If the value in YYTABLE is positive, we shift the token and go to
-   that state.
-
-   If the value is negative, it is minus a rule number to reduce by.
-
-   If the value is zero, the default action from YYDEFACT[S] is used.
-
-   YYPGOTO[I] = the index in YYTABLE of the portion describing what to
-   do after reducing a rule that derives variable I + NTOKENS.  This
-   portion is indexed by the parser state number, S, as of before the
-   text for this nonterminal was read.  The value from YYTABLE is the
-   state to go to if the corresponding value in YYCHECK is S.
-
-   YYTABLE = a vector filled with portions for different uses, found
-   via YYPACT and YYPGOTO.
-
-   YYCHECK = a vector indexed in parallel with YYTABLE.  It indicates,
-   in a roundabout way, the bounds of the portion you are trying to
-   examine.
-
-   Suppose that the portion of yytable starts at index P and the index
-   to be examined within the portion is I.  Then if YYCHECK[P+I] != I,
-   I is outside the bounds of what is actually allocated, and the
-   default (from YYDEFACT or YYDEFGOTO) should be used.  Otherwise,
-   YYTABLE[P+I] should be used.
+#include "system.h"

 
 

-   YYFINAL = the state number of the termination state.  YYFLAG = most
-   negative short int.  Used to flag ??  */
+#include <error.h>
+#include <get-errno.h>
+#include <quotearg.h>
+#include <subpipe.h>
+#include <timevar.h>

 
 

-#include "system.h"
-#include "bitsetv.h"
-#include "quotearg.h"
-#include "error.h"
-#include "getargs.h"
+#include "complain.h"

 #include "files.h"
 #include "files.h"

+#include "getargs.h"

 #include "gram.h"
 #include "gram.h"

-#include "LR0.h"
-#include "complain.h"
+#include "muscle_tab.h"

 #include "output.h"
 #include "output.h"

-#include "lalr.h"

 #include "reader.h"
 #include "symtab.h"
 #include "reader.h"
 #include "symtab.h"

-#include "conflicts.h"
-#include "muscle_tab.h"
-
-/* From lib/readpipe.h.  */
-FILE *readpipe PARAMS ((const char *, ...));
+#include "tables.h"

 
 /* From src/scan-skel.l. */
 
 /* From src/scan-skel.l. */

-int skel_lex PARAMS ((void));
-extern FILE *skel_in;
-
-static int nvectors;
-static int nentries;
-static short **froms = NULL;
-static short **tos = NULL;
-static short *tally = NULL;
-static short *width = NULL;
-static short *actrow = NULL;
-static short *state_count = NULL;
-static short *order = NULL;
-static short *base = NULL;
-static short *pos = NULL;
-
-/* TABLE_SIZE is the allocated size of both TABLE and CHECK.
-   We start with the original hard-coded value: SHRT_MAX
-   (yes, not USHRT_MAX). */
-static size_t table_size = SHRT_MAX;
-static short *table = NULL;
-static short *check = NULL;
-static int lowzero;
-static int high;
+void scan_skel (FILE *);
+

 
 static struct obstack format_obstack;
 
 int error_verbose = 0;
 
 
 
 static struct obstack format_obstack;
 
 int error_verbose = 0;
 
 

-/*----------------------------------------------------------------.
-| If TABLE (and CHECK) appear to be small to be addressed at      |
-| DESIRED, grow them.  Note that TABLE[DESIRED] is to be used, so |
-| the desired size is at least DESIRED + 1.                       |
-`----------------------------------------------------------------*/
-
-static void
-table_grow (size_t desired)
-{
-  size_t old_size = table_size;
-
-  while (table_size <= desired)
-    table_size *= 2;
-
-  if (trace_flag)
-    fprintf (stderr, "growing table and check from: %d to %d\n",
-            old_size, table_size);
-
-  table = XREALLOC (table, short, table_size);
-  check = XREALLOC (check, short, table_size);
-
-  for (/* Nothing. */; old_size < table_size; ++old_size)
-    {
-      table[old_size] = 0;
-      check[old_size] = -1;
-    }
-}
-

 
 /*-------------------------------------------------------------------.
 | Create a function NAME which associates to the muscle NAME the     |
 
 /*-------------------------------------------------------------------.
 | Create a function NAME which associates to the muscle NAME the     |


@@ -183,7 +66,10 @@ Name (const char *name,                                                     \
       int begin,                                                       \
       int end)                                                         \
 {                                                                      \
       int begin,                                                       \
       int end)                                                         \
 {                                                                      \

+  Type min = first;                                                    \

   Type max = first;                                                    \
   Type max = first;                                                    \

+  long int lmin;                                                       \
+  long int lmax;                                                       \

   int i;                                                               \
   int j = 1;                                                           \
                                                                        \
   int i;                                                               \
   int j = 1;                                                           \
                                                                        \


@@ -199,78 +85,118 @@ Name (const char *name,                                                   \
       else                                                             \
        ++j;                                                            \
       obstack_fgrow1 (&format_obstack, "%6d", table_data[i]);          \
       else                                                             \
        ++j;                                                            \
       obstack_fgrow1 (&format_obstack, "%6d", table_data[i]);          \

-      if (table_data[i] > max)                                         \
+      if (table_data[i] < min)                                         \
+       min = table_data[i];                                            \
+      if (max < table_data[i])                                         \

        max = table_data[i];                                            \
     }                                                                  \
   obstack_1grow (&format_obstack, 0);                                  \
   muscle_insert (name, obstack_finish (&format_obstack));              \
                                                                        \
        max = table_data[i];                                            \
     }                                                                  \
   obstack_1grow (&format_obstack, 0);                                  \
   muscle_insert (name, obstack_finish (&format_obstack));              \
                                                                        \

-  /* Build `NAME_max' in the obstack. */                               \
+  lmin = min;                                                          \
+  lmax = max;                                                          \
+  /* Build `NAME_min' and `NAME_max' in the obstack. */                        \
+  obstack_fgrow1 (&format_obstack, "%s_min", name);                    \
+  obstack_1grow (&format_obstack, 0);                                  \
+  MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmin);     \

   obstack_fgrow1 (&format_obstack, "%s_max", name);                    \
   obstack_1grow (&format_obstack, 0);                                  \
   obstack_fgrow1 (&format_obstack, "%s_max", name);                    \
   obstack_1grow (&format_obstack, 0);                                  \

-  MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack),            \
-                         (long int) max);                              \
+  MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmax);     \

 }
 
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int)
 }
 
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int)

+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_int_table, int)

 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_short_table, short)
 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_short_table, short)

-GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number_t)
-GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number_t)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_base_table, base_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number)
+
+
+/*----------------------------------------------------------------------.
+| Print to OUT a representation of FILENAME escaped both for C and M4.  |
+`----------------------------------------------------------------------*/
+
+static void
+escaped_file_name_output (FILE *out, char const *filename)
+{
+  char const *p;
+  fprintf (out, "[[");
+
+  for (p = quotearg_style (c_quoting_style, filename); *p; p++)
+    switch (*p)
+      {
+      case '$': fputs ("$][", out); break;
+      case '@': fputs ("@@",  out); break;
+      case '[': fputs ("@{",  out); break;
+      case ']': fputs ("@}",  out); break;
+      default: fputc (*p, out); break;
+      }
+
+  fprintf (out, "]]");
+}

 
 
 
 

-/*-----------------------------------------------------------------.
-| Prepare the muscles related to the tokens: translate, tname, and |
-| toknum.                                                          |
-`-----------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| Prepare the muscles related to the symbols: translate, tname, and |
+| toknum.                                                           |
+`------------------------------------------------------------------*/

 
 static void
 
 static void

-prepare_tokens (void)
+prepare_symbols (void)

 {
 {

+  MUSCLE_INSERT_INT ("tokens_number", ntokens);
+  MUSCLE_INSERT_INT ("nterms_number", nvars);
+  MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
+  MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
+

   muscle_insert_symbol_number_table ("translate",
   muscle_insert_symbol_number_table ("translate",

-                                   token_translations,
-                                   0, 1, max_user_token_number + 1);
+                                    token_translations,
+                                    token_translations[0],
+                                    1, max_user_token_number + 1);

 
 

+  /* tname -- token names.  */

   {
     int i;
   {
     int i;

-    int j = 0;
+    /* We assume that the table will be output starting at column 2. */
+    int j = 2;

     for (i = 0; i < nsyms; i++)
       {
     for (i = 0; i < nsyms; i++)
       {

-       /* 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,
-                                           symbols[i]->tag));
-       /* Width of the next token, including the two quotes, the coma
-          and the space.  */
-       int strsize = strlen (cp) + 2;
-
-       if (j + strsize > 75)
+       const char *cp = quotearg_style (c_quoting_style, symbols[i]->tag);
+       /* Width of the next token, including the two quotes, the
+          comma and the space.  */
+       int width = strlen (cp) + 2;
+
+       if (j + width > 75)

          {
          {

-           obstack_sgrow (&format_obstack, "\n  ");
-           j = 2;
+           obstack_sgrow (&format_obstack, "\n ");
+           j = 1;

          }
 
          }
 

-       obstack_sgrow (&format_obstack, cp);
-       obstack_sgrow (&format_obstack, ", ");
-       j += strsize;
+       if (i)
+         obstack_1grow (&format_obstack, ' ');
+       MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
+       obstack_1grow (&format_obstack, ',');
+       j += width;

       }
     /* Add a NULL entry to list of tokens (well, 0, as NULL might not be
        defined).  */
       }
     /* Add a NULL entry to list of tokens (well, 0, as NULL might not be
        defined).  */

-    obstack_sgrow (&format_obstack, "0");
+    obstack_sgrow (&format_obstack, " 0");

 
     /* Finish table and store. */
     obstack_1grow (&format_obstack, 0);
     muscle_insert ("tname", obstack_finish (&format_obstack));
   }
 
 
     /* Finish table and store. */
     obstack_1grow (&format_obstack, 0);
     muscle_insert ("tname", obstack_finish (&format_obstack));
   }
 

-    /* Output YYTOKNUM. */
+  /* Output YYTOKNUM. */

   {
     int i;
   {
     int i;

-    short *values = XCALLOC (short, ntokens + 1);
-    for (i = 0; i < ntokens + 1; ++i)
+    int *values = MALLOC (values, ntokens);
+    for (i = 0; i < ntokens; ++i)

       values[i] = symbols[i]->user_token_number;
       values[i] = symbols[i]->user_token_number;

-    muscle_insert_short_table ("toknum", values,
-                              0, 1, ntokens + 1);
+    muscle_insert_int_table ("toknum", values,
+                            values[0], 1, ntokens);

     free (values);
   }
 }
     free (values);
   }
 }


@@ -278,23 +204,25 @@ prepare_tokens (void)
 
 /*-------------------------------------------------------------.
 | Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
 
 /*-------------------------------------------------------------.
 | Prepare the muscles related to the rules: rhs, prhs, r1, r2, |

-| rline.                                                       |
+| rline, dprec, merger.                                        |

 `-------------------------------------------------------------*/
 
 static void
 prepare_rules (void)
 {
 `-------------------------------------------------------------*/
 
 static void
 prepare_rules (void)
 {

-  int r;
+  rule_number r;

   unsigned int i = 0;
   unsigned int i = 0;

-  item_number_t *rhs = XMALLOC (item_number_t, nritems);
-  unsigned int *prhs = XMALLOC (unsigned int, nrules + 1);
-  unsigned int *rline = XMALLOC (unsigned int, nrules + 1);
-  symbol_number_t *r1 = XMALLOC (symbol_number_t, nrules + 1);
-  unsigned int *r2 = XMALLOC (unsigned int, nrules + 1);
-
-  for (r = 1; r < nrules + 1; ++r)
+  item_number *rhs = MALLOC (rhs, nritems);
+  unsigned int *prhs = MALLOC (prhs, nrules);
+  unsigned int *rline = MALLOC (rline, nrules);
+  symbol_number *r1 = MALLOC (r1, nrules);
+  unsigned int *r2 = MALLOC (r2, nrules);
+  short *dprec = MALLOC (dprec, nrules);
+  short *merger = MALLOC (merger, nrules);
+
+  for (r = 0; r < nrules; ++r)

     {
     {

-      item_number_t *rhsp;
+      item_number *rhsp = NULL;

       /* Index of rule R in RHS. */
       prhs[r] = i;
       /* RHS of the rule R. */
       /* Index of rule R in RHS. */
       prhs[r] = i;
       /* RHS of the rule R. */


@@ -307,21 +235,32 @@ prepare_rules (void)
       /* Separator in RHS. */
       rhs[i++] = -1;
       /* Line where rule was defined. */
       /* Separator in RHS. */
       rhs[i++] = -1;
       /* Line where rule was defined. */

-      rline[r] = rules[r].location.first_line;
+      rline[r] = rules[r].location.start.line;
+      /* Dynamic precedence (GLR).  */
+      dprec[r] = rules[r].dprec;
+      /* Merger-function index (GLR).  */
+      merger[r] = rules[r].merger;

     }
     }

-  assert (i == nritems);
+  if (i != nritems)
+    abort ();

 
   muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
 
   muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);

-  muscle_insert_unsigned_int_table ("prhs", prhs, 0, 1, nrules + 1);
-  muscle_insert_unsigned_int_table ("rline", rline, 0, 1, nrules + 1);
-  muscle_insert_symbol_number_table ("r1", r1, 0, 1, nrules + 1);
-  muscle_insert_unsigned_int_table ("r2", r2, 0, 1, nrules + 1);
+  muscle_insert_unsigned_int_table ("prhs", prhs, 0, 0, nrules);
+  muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
+  muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
+  muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
+  muscle_insert_short_table ("dprec", dprec, 0, 0, nrules);
+  muscle_insert_short_table ("merger", merger, 0, 0, nrules);
+
+  MUSCLE_INSERT_INT ("rules_number", nrules);

 
   free (rhs);
   free (prhs);
   free (rline);
   free (r1);
   free (r2);
 
   free (rhs);
   free (prhs);
   free (rline);
   free (r1);
   free (r2);

+  free (dprec);
+  free (merger);

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


@@ -331,656 +270,238 @@ prepare_rules (void)
 static void
 prepare_states (void)
 {
 static void
 prepare_states (void)
 {

-  size_t i;
-  symbol_number_t *values =
-    (symbol_number_t *) alloca (sizeof (symbol_number_t) * nstates);
+  state_number i;
+  symbol_number *values = MALLOC (values, nstates);

   for (i = 0; i < nstates; ++i)
     values[i] = states[i]->accessing_symbol;
   muscle_insert_symbol_number_table ("stos", values,
   for (i = 0; i < nstates; ++i)
     values[i] = states[i]->accessing_symbol;
   muscle_insert_symbol_number_table ("stos", values,

-                                   0, 1, nstates);
-}
-
-
-/*------------------------------------------------------------------.
-| Decide what to do for each type of token if seen as the lookahead |
-| token in specified state.  The value returned is used as the      |
-| default action (yydefact) for the state.  In addition, actrow is  |
-| filled with what to do for each kind of token, index by symbol    |
-| number, with zero meaning do the default action.  The value       |
-| SHRT_MIN, a very negative number, means this situation is an      |
-| error.  The parser recognizes this value specially.               |
-|                                                                   |
-| This is where conflicts are resolved.  The loop over lookahead    |
-| rules considered lower-numbered rules last, and the last rule     |
-| considered that likes a token gets to handle it.                  |
-`------------------------------------------------------------------*/
-
-static int
-action_row (state_t *state)
-{
-  int i;
-  int default_rule = 0;
-  reductions *redp = state->reductions;
-  shifts *shiftp = state->shifts;
-  errs *errp = state->errs;
-  /* set nonzero to inhibit having any default reduction */
-  int nodefault = 0;
-
-  for (i = 0; i < ntokens; i++)
-    actrow[i] = 0;
-
-  if (redp->nreds >= 1)
-    {
-      int j;
-      /* loop over all the rules available here which require
-        lookahead */
-      for (i = state->nlookaheads - 1; i >= 0; --i)
-       /* 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 (bitset_test (LA[state->lookaheadsp + i], j))
-           actrow[j] = -LArule[state->lookaheadsp + i]->number;
-    }
-
-  /* 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.  */
-  for (i = 0; i < shiftp->nshifts; i++)
-    {
-      symbol_number_t symbol;
-      int shift_state = shiftp->shifts[i];
-      if (!shift_state)
-       continue;
-
-      symbol = states[shift_state]->accessing_symbol;
-
-      if (ISVAR (symbol))
-       break;
-
-      actrow[symbol] = shift_state;
-
-      /* Do not use any default reduction if there is a shift for
-        error */
-      if (symbol == errtoken->number)
-       nodefault = 1;
-    }
+                                    0, 1, nstates);
+  free (values);

 
 

-  /* See which tokens are an explicit error in this state (due to
-     %nonassoc).  For them, record SHRT_MIN as the action.  */
-  for (i = 0; i < errp->nerrs; i++)
-    {
-      int symbol = errp->errs[i];
-      actrow[symbol] = SHRT_MIN;
-    }
-
-  /* Now find the most common reduction and make it the default action
-     for this state.  */
-
-  if (redp->nreds >= 1 && !nodefault)
-    {
-      if (state->consistent)
-       default_rule = redp->rules[0];
-      else
-       {
-         int max = 0;
-         for (i = 0; i < state->nlookaheads; i++)
-           {
-             int count = 0;
-             int rule = -LArule[state->lookaheadsp + i]->number;
-             int j;
-
-             for (j = 0; j < ntokens; j++)
-               if (actrow[j] == rule)
-                 count++;
-
-             if (count > max)
-               {
-                 max = count;
-                 default_rule = rule;
-               }
-           }
-
-         /* actions which match the default are replaced with zero,
-            which means "use the default" */
-
-         if (max > 0)
-           {
-             int j;
-             for (j = 0; j < ntokens; j++)
-               if (actrow[j] == default_rule)
-                 actrow[j] = 0;
-
-             default_rule = -default_rule;
-           }
-       }
-    }
-
-  /* If have no default rule, the default is an error.
-     So replace any action which says "error" with "use default".  */
+  MUSCLE_INSERT_INT ("last", high);
+  MUSCLE_INSERT_INT ("final_state_number", final_state->number);
+  MUSCLE_INSERT_INT ("states_number", nstates);
+}

 
 

-  if (default_rule == 0)
-    for (i = 0; i < ntokens; i++)
-      if (actrow[i] == SHRT_MIN)
-       actrow[i] = 0;

 
 

-  return default_rule;
-}

 
 

+/*---------------------------------.
+| Output the user actions to OUT.  |
+`---------------------------------*/

 
 static void
 
 static void

-save_row (int state)
+user_actions_output (FILE *out)

 {
 {

-  int i;
-  int count;
-  short *sp;
-  short *sp1;
-  short *sp2;
+  rule_number r;

 
 

-  count = 0;
-  for (i = 0; i < ntokens; i++)
-    if (actrow[i] != 0)
-      count++;
-
-  if (count == 0)
-    return;
-
-  froms[state] = sp1 = sp = XCALLOC (short, count);
-  tos[state] = sp2 = XCALLOC (short, count);
-
-  for (i = 0; i < ntokens; i++)
-    if (actrow[i] != 0)
+  fputs ("m4_define([b4_actions], \n[[", out);
+  for (r = 0; r < nrules; ++r)
+    if (rules[r].action)

       {
       {

-       *sp1++ = i;
-       *sp2++ = actrow[i];
-      }
+       fprintf (out, "  case %d:\n", r + 1);

 
 

-  tally[state] = count;
-  width[state] = sp1[-1] - sp[0] + 1;
+       fprintf (out, "]b4_syncline([[%d]], ",
+                rules[r].action_location.start.line);
+       escaped_file_name_output (out, rules[r].action_location.start.file);
+       fprintf (out, ")[\n");
+       fprintf (out, "    %s\n    break;\n\n",
+                rules[r].action);
+      }
+  fputs ("]])\n\n", out);

 }
 
 }
 

-
-/*------------------------------------------------------------------.
-| Figure out the actions for the specified state, indexed by        |
-| lookahead token type.                                             |
-|                                                                   |
-| The YYDEFACT table is output now.  The detailed info is saved for |
-| putting into YYTABLE later.                                       |
-`------------------------------------------------------------------*/
+/*--------------------------------------.
+| Output the merge functions to OUT.   |
+`--------------------------------------*/

 
 static void
 
 static void

-token_actions (void)
+merger_output (FILE *out)

 {
 {

-  size_t i;
-  short *yydefact = XCALLOC (short, nstates);
+  int n;
+  merger_list* p;

 
 

-  actrow = XCALLOC (short, ntokens);
-  for (i = 0; i < nstates; ++i)
+  fputs ("m4_define([b4_mergers], \n[[", out);
+  for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)

     {
     {

-      yydefact[i] = action_row (states[i]);
-      save_row (i);
+      if (p->type[0] == '\0')
+       fprintf (out, "  case %d: yyval = %s (*yy0, *yy1); break;\n",
+                n, p->name);
+      else
+       fprintf (out, "  case %d: yyval.%s = %s (*yy0, *yy1); break;\n",
+                n, p->type, p->name);

     }
     }

-
-  muscle_insert_short_table ("defact", yydefact,
-                            yydefact[0], 1, nstates);
-  XFREE (actrow);
-  XFREE (yydefact);
-}
-
-
-/*-----------------------------.
-| Output the actions to OOUT.  |
-`-----------------------------*/
-
-void
-actions_output (FILE *out)
-{
-  int rule;
-  for (rule = 1; rule < nrules + 1; ++rule)
-    if (rules[rule].action)
-      {
-       fprintf (out, "  case %d:\n", rule);
-
-       if (!no_lines_flag)
-         fprintf (out, muscle_find ("linef"),
-                  rules[rule].action_location.first_line,
-                  quotearg_style (c_quoting_style,
-                                  muscle_find ("filename")));
-       fprintf (out, "    %s\n    break;\n\n",
-                rules[rule].action);
-      }
+  fputs ("]])\n\n", out);

 }
 
 }
 

+/*--------------------------------------.
+| Output the tokens definition to OUT.  |
+`--------------------------------------*/

 
 

-/*---------------------------------------.
-| Output the tokens definition to OOUT.  |
-`---------------------------------------*/
-
-void
+static void

 token_definitions_output (FILE *out)
 {
   int i;
   int first = 1;
 token_definitions_output (FILE *out)
 {
   int i;
   int first = 1;

+
+  fputs ("m4_define([b4_tokens], \n[", out);

   for (i = 0; i < ntokens; ++i)
     {
   for (i = 0; i < ntokens; ++i)
     {

-      symbol_t *symbol = symbols[i];
-      int number = symbol->user_token_number;
+      symbol *sym = symbols[i];
+      int number = sym->user_token_number;

 
       /* At this stage, if there are literal aliases, they are part of
         SYMBOLS, so we should not find symbols which are the aliases
         here.  */
 
       /* At this stage, if there are literal aliases, they are part of
         SYMBOLS, so we should not find symbols which are the aliases
         here.  */

-      assert (number != USER_NUMBER_ALIAS);
+      if (number == USER_NUMBER_ALIAS)
+       abort ();

 
       /* Skip error token.  */
 
       /* Skip error token.  */

-      if (symbol == errtoken)
+      if (sym == errtoken)

        continue;
 
       /* If this string has an alias, then it is necessarily the alias
         which is to be output.  */
        continue;
 
       /* If this string has an alias, then it is necessarily the alias
         which is to be output.  */

-      if (symbol->alias)
-       symbol = symbol->alias;
+      if (sym->alias)
+       sym = sym->alias;

 
       /* Don't output literal chars or strings (when defined only as a
         string).  Note that must be done after the alias resolution:
         think about `%token 'f' "f"'.  */
 
       /* Don't output literal chars or strings (when defined only as a
         string).  Note that must be done after the alias resolution:
         think about `%token 'f' "f"'.  */

-      if (symbol->tag[0] == '\'' || symbol->tag[0] == '\"')
+      if (sym->tag[0] == '\'' || sym->tag[0] == '\"')

        continue;
 
       /* Don't #define nonliteral tokens whose names contain periods
         or '$' (as does the default value of the EOF token).  */
        continue;
 
       /* Don't #define nonliteral tokens whose names contain periods
         or '$' (as does the default value of the EOF token).  */

-      if (strchr (symbol->tag, '.') || strchr (symbol->tag, '$'))
+      if (strchr (sym->tag, '.') || strchr (sym->tag, '$'))

        continue;
 
       fprintf (out, "%s[[[%s]], [%d]]",
        continue;
 
       fprintf (out, "%s[[[%s]], [%d]]",

-              first ? "" : ",\n", symbol->tag, number);
+              first ? "" : ",\n", sym->tag, number);

 
       first = 0;
     }
 
       first = 0;
     }

+  fputs ("])\n\n", out);

 }
 
 
 }
 
 

+/*---------------------------------------.
+| Output the symbol destructors to OUT.  |
+`---------------------------------------*/
+

 static void
 static void

-save_column (int symbol, int default_state)
+symbol_destructors_output (FILE *out)

 {
   int i;
 {
   int i;

-  short *sp;
-  short *sp1;
-  short *sp2;
-  int count;
-  int symno = symbol - ntokens + nstates;
-
-  short begin = goto_map[symbol];
-  short end = goto_map[symbol + 1];
-
-  count = 0;
-  for (i = begin; i < end; i++)
-    if (to_state[i] != default_state)
-      count++;
-
-  if (count == 0)
-    return;
-
-  froms[symno] = sp1 = sp = XCALLOC (short, count);
-  tos[symno] = sp2 = XCALLOC (short, count);
-
-  for (i = begin; i < end; i++)
-    if (to_state[i] != default_state)
-      {
-       *sp1++ = from_state[i];
-       *sp2++ = to_state[i];
-      }
-
-  tally[symno] = count;
-  width[symno] = sp1[-1] - sp[0] + 1;
-}
-
-static int
-default_goto (int symbol)
-{
-  size_t i;
-  size_t m = goto_map[symbol];
-  size_t n = goto_map[symbol + 1];
-  int default_state = -1;
-  int max = 0;
-
-  if (m == n)
-    return -1;
-
-  for (i = 0; i < nstates; i++)
-    state_count[i] = 0;
-
-  for (i = m; i < n; i++)
-    state_count[to_state[i]]++;
+  int first = 1;

 
 

-  for (i = 0; i < nstates; i++)
-    if (state_count[i] > max)
+  fputs ("m4_define([b4_symbol_destructors], \n[", out);
+  for (i = 0; i < nsyms; ++i)
+    if (symbols[i]->destructor)

       {
       {

-       max = state_count[i];
-       default_state = i;
+       symbol *sym = symbols[i];
+
+       /* Filename, lineno,
+          Symbol-name, Symbol-number,
+          destructor, typename. */
+       fprintf (out, "%s[",
+                first ? "" : ",\n");
+       escaped_file_name_output (out, sym->destructor_location.start.file);
+       fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
+                sym->destructor_location.start.line,
+                sym->tag,
+                sym->number,
+                sym->destructor,
+                sym->type_name);
+
+       first = 0;

       }
       }

-
-  return default_state;
-}
-
-
-/*-------------------------------------------------------------------.
-| Figure out what to do after reducing with each rule, depending on  |
-| the saved state from before the beginning of parsing the data that |
-| matched this rule.                                                 |
-|                                                                    |
-| The YYDEFGOTO table is output now.  The detailed info is saved for |
-| putting into YYTABLE later.                                        |
-`-------------------------------------------------------------------*/
-
-static void
-goto_actions (void)
-{
-  int i;
-  short *yydefgoto = XMALLOC (short, nsyms - ntokens);
-
-  state_count = XCALLOC (short, nstates);
-  for (i = ntokens; i < nsyms; ++i)
-    {
-      int default_state = default_goto (i);
-      save_column (i, default_state);
-      yydefgoto[i - ntokens] = default_state;
-    }
-
-  muscle_insert_short_table ("defgoto", yydefgoto,
-                            yydefgoto[0], 1, nsyms - ntokens);
-  XFREE (state_count);
-  XFREE (yydefgoto);
+  fputs ("])\n\n", out);

 }
 
 
 }
 
 

-/* The next few functions decide how to pack the actions and gotos
-   information into yytable. */
+/*------------------------------------.
+| Output the symbol printers to OUT.  |
+`------------------------------------*/

 
 static void
 
 static void

-sort_actions (void)
+symbol_printers_output (FILE *out)

 {
   int i;
 {
   int i;

+  int first = 1;

 
 

-  order = XCALLOC (short, nvectors);
-  nentries = 0;
-
-  for (i = 0; i < nvectors; i++)
-    if (tally[i] > 0)
+  fputs ("m4_define([b4_symbol_printers], \n[", out);
+  for (i = 0; i < nsyms; ++i)
+    if (symbols[i]->printer)

       {
       {

-       int k;
-       int t = tally[i];
-       int w = width[i];
-       int j = nentries - 1;
-
-       while (j >= 0 && (width[order[j]] < w))
-         j--;
-
-       while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t))
-         j--;
-
-       for (k = nentries - 1; k > j; k--)
-         order[k + 1] = order[k];
-
-       order[j + 1] = i;
-       nentries++;
+       symbol *sym = symbols[i];
+
+       /* Filename, lineno,
+          Symbol-name, Symbol-number,
+          printer, typename. */
+       fprintf (out, "%s[",
+                first ? "" : ",\n");
+       escaped_file_name_output (out, sym->printer_location.start.file);
+       fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
+                sym->printer_location.start.line,
+                sym->tag,
+                sym->number,
+                sym->printer,
+                sym->type_name);
+
+       first = 0;

       }
       }

-}
-
-
-static int
-matching_state (int vector)
-{
-  int i = order[vector];
-  int t;
-  int w;
-  int prev;
-
-  if (i >= (int) nstates)
-    return -1;
-
-  t = tally[i];
-  w = width[i];
-
-  for (prev = vector - 1; prev >= 0; prev--)
-    {
-      int j = order[prev];
-      int k;
-      int match = 1;
-
-      if (width[j] != w || tally[j] != t)
-       return -1;
-
-      for (k = 0; match && k < t; k++)
-       if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k])
-         match = 0;
-
-      if (match)
-       return j;
-    }
-
-  return -1;
-}
-
-
-static int
-pack_vector (int vector)
-{
-  int i = order[vector];
-  int j;
-  int t = tally[i];
-  int loc = 0;
-  short *from = froms[i];
-  short *to = tos[i];
-
-  assert (t);
-
-  for (j = lowzero - from[0]; j < (int) table_size; j++)
-    {
-      int k;
-      int ok = 1;
-
-      for (k = 0; ok && k < t; k++)
-       {
-         loc = j + from[k];
-         if (loc > (int) table_size)
-           table_grow (loc);
-
-         if (table[loc] != 0)
-           ok = 0;
-       }
-
-      for (k = 0; ok && k < vector; k++)
-       if (pos[k] == j)
-         ok = 0;
-
-      if (ok)
-       {
-         for (k = 0; k < t; k++)
-           {
-             loc = j + from[k];
-             table[loc] = to[k];
-             check[loc] = from[k];
-           }
-
-         while (table[lowzero] != 0)
-           lowzero++;
-
-         if (loc > high)
-           high = loc;
-
-         return j;
-       }
-    }
-#define pack_vector_succeeded 0
-  assert (pack_vector_succeeded);
-  return 0;
+  fputs ("])\n\n", out);

 }
 
 
 static void
 }
 
 
 static void

-pack_table (void)
+prepare_actions (void)

 {
 {

-  int i;
-  int place;
-  int state;
-
-  base = XCALLOC (short, nvectors);
-  pos = XCALLOC (short, nentries);
-  table = XCALLOC (short, table_size);
-  check = XCALLOC (short, table_size);
+  /* Figure out the actions for the specified state, indexed by
+     lookahead token type.  */

 
 

-  lowzero = 0;
-  high = 0;
+  muscle_insert_rule_number_table ("defact", yydefact,
+                                  yydefact[0], 1, nstates);

 
 

-  for (i = 0; i < nvectors; i++)
-    base[i] = SHRT_MIN;
+  /* Figure out what to do after reducing with each rule, depending on
+     the saved state from before the beginning of parsing the data
+     that matched this rule.  */
+  muscle_insert_state_number_table ("defgoto", yydefgoto,
+                                   yydefgoto[0], 1, nsyms - ntokens);

 
 

-  for (i = 0; i < (int) table_size; i++)
-    check[i] = -1;
-
-  for (i = 0; i < nentries; i++)
-    {
-      state = matching_state (i);
-
-      if (state < 0)
-       place = pack_vector (i);
-      else
-       place = base[state];

 
 

-      pos[i] = place;
-      base[order[i]] = place;
-    }
-
-  for (i = 0; i < nvectors; i++)
-    {
-      XFREE (froms[i]);
-      XFREE (tos[i]);
-    }
-
-  XFREE (froms);
-  XFREE (tos);
-  XFREE (pos);
-}
-
-/* the following functions output yytable, yycheck
-   and the vectors whose elements index the portion starts */
-
-static void
-output_base (void)
-{
-  /* Output pact. */
-  muscle_insert_short_table ("pact", base,
+  /* Output PACT. */
+  muscle_insert_base_table ("pact", base,

                             base[0], 1, nstates);
                             base[0], 1, nstates);

+  MUSCLE_INSERT_INT ("pact_ninf", base_ninf);

 
 

-  /* Output pgoto. */
-  muscle_insert_short_table ("pgoto", base,
+  /* Output PGOTO. */
+  muscle_insert_base_table ("pgoto", base,

                             base[nstates], nstates + 1, nvectors);
                             base[nstates], nstates + 1, nvectors);

-  XFREE (base);
-}
-
-
-static void
-output_table (void)
-{
-  muscle_insert_short_table ("table", table,
-                            table[0], 1, high + 1);
-  XFREE (table);
-}

 
 

-
-static void
-output_check (void)
-{
-  muscle_insert_short_table ("check", check,
-                            check[0], 1, high + 1);
-  XFREE (check);
-}
-
-/*-----------------------------------------------------------------.
-| Compute and output yydefact, yydefgoto, yypact, yypgoto, yytable |
-| and yycheck.                                                     |
-`-----------------------------------------------------------------*/
-
-static void
-output_actions (void)
-{
-  size_t i;
-  nvectors = nstates + nvars;
-
-  froms = XCALLOC (short *, nvectors);
-  tos = XCALLOC (short *, nvectors);
-  tally = XCALLOC (short, nvectors);
-  width = XCALLOC (short, nvectors);
-
-  token_actions ();
-  bitsetv_free (LA);
-  free (LArule);
-
-  goto_actions ();
-  XFREE (goto_map + ntokens);
-  XFREE (from_state);
-  XFREE (to_state);
-
-  sort_actions ();
-  pack_table ();
-
-  output_base ();
-  output_table ();
-
-  output_check ();
-
-  for (i = 0; i < nstates; ++i)
-    {
-      free (states[i]->shifts);
-      XFREE (states[i]->reductions);
-      free (states[i]->errs);
-      free (states[i]);
-    }
-  XFREE (states);
+  muscle_insert_base_table ("table", table,
+                           table[0], 1, high + 1);
+  MUSCLE_INSERT_INT ("table_ninf", table_ninf);
+
+  muscle_insert_base_table ("check", check,
+                           check[0], 1, high + 1);
+
+  /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
+     YYPACT) so that in states with unresolved conflicts, the default
+     reduction is not used in the conflicted entries, so that there is
+     a place to put a conflict pointer.
+
+     This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
+     parser, so we could avoid accidents by not writing them out in
+     that case.  Nevertheless, it seems even better to be able to use
+     the GLR skeletons even without the non-deterministic tables.  */
+  muscle_insert_unsigned_int_table ("conflict_list_heads", conflict_table,
+                                   conflict_table[0], 1, high + 1);
+  muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
+                                   conflict_list[0], 1, conflict_list_cnt);

 }
 
 \f
 }
 
 \f

-/*----------------------.
-| Run our backend, M4.  |
-`----------------------*/
-
-static void
-m4_invoke (const char *definitions)
-{
-  /* Invoke m4 on the definition of the muscles, and the skeleton. */
-  const char *bison_pkgdatadir = getenv ("BISON_PKGDATADIR");
-  const char *m4 = getenv ("M4");
-  int pkg_data_len;
-  char *full_skeleton;
-
-  if (!m4)
-    m4 = M4;
-  if (!bison_pkgdatadir)
-    bison_pkgdatadir = PKGDATADIR;
-  pkg_data_len = strlen (bison_pkgdatadir);
-  full_skeleton = XMALLOC (char, pkg_data_len + strlen (skeleton) + 2);
-  if (bison_pkgdatadir[pkg_data_len-1] == '/')
-    sprintf (full_skeleton, "%s%s", bison_pkgdatadir, skeleton);
-  else
-    sprintf (full_skeleton, "%s/%s", bison_pkgdatadir, skeleton);
-  if (trace_flag)
-    fprintf (stderr,
-            "running: %s -I %s m4sugar/m4sugar.m4 %s %s\n",
-            m4, bison_pkgdatadir, definitions, full_skeleton);
-  skel_in = readpipe (m4,
-                     "-I", bison_pkgdatadir,
-                     "m4sugar/m4sugar.m4",
-                     definitions,
-                     full_skeleton,
-                     NULL);
-  XFREE (full_skeleton);
-  if (!skel_in)
-    error (EXIT_FAILURE, errno, "cannot run m4");
-  skel_lex ();
-
-}
-

 /*---------------------------.
 | Call the skeleton parser.  |
 `---------------------------*/
 /*---------------------------.
 | Call the skeleton parser.  |
 `---------------------------*/


@@ -988,36 +509,70 @@ m4_invoke (const char *definitions)
 static void
 output_skeleton (void)
 {
 static void
 output_skeleton (void)
 {

-  /* Store the definition of all the muscles. */
-  const char *tempdir = getenv ("TMPDIR");
-  char *tempfile = NULL;
-  FILE *out = NULL;
-  int fd;
-
-  if (tempdir == NULL)
-    tempdir = DEFAULT_TMPDIR;
-  tempfile = xmalloc (strlen (tempdir) + 11);
-  sprintf (tempfile, "%s/bsnXXXXXX", tempdir);
-  fd = mkstemp (tempfile);
-  if (fd == -1)
-    error (EXIT_FAILURE, errno, "%s", tempfile);
-
-  out = fdopen (fd, "w");
-  if (out == NULL)
-    error (EXIT_FAILURE, errno, "%s", tempfile);
-
-  /* There are no comments, especially not `#': we do want M4 expansion
-     after `#': think of CPP macros!  */
-  fputs ("m4_changecom()\n", out);
+  FILE *in;
+  FILE *out;
+  int filter_fd[2];
+  char const *argv[6];
+  pid_t pid;
+
+  /* Compute the names of the package data dir and skeleton file.
+     Test whether m4sugar.m4 is readable, to check for proper
+     installation.  A faulty installation can cause deadlock, so a
+     cheap sanity check is worthwhile.  */
+  char const m4sugar[] = "m4sugar/m4sugar.m4";
+  char *full_m4sugar;
+  char *full_cm4;
+  char *full_path;
+  char const *p;
+  char const *m4 = (p = getenv ("M4")) ? p : M4;
+  char const *pkgdatadir = (p = getenv ("BISON_PKGDATADIR")) ? p : PKGDATADIR;
+  size_t skeleton_size = strlen (skeleton) + 1;
+  size_t pkgdatadirlen = strlen (pkgdatadir);
+  while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
+    pkgdatadirlen--;
+  full_path = xmalloc (pkgdatadirlen + 1
+                      + (skeleton_size < sizeof m4sugar
+                         ? sizeof m4sugar : skeleton_size));
+  strcpy (full_path, pkgdatadir);
+  full_path[pkgdatadirlen] = '/';
+  strcpy (full_path + pkgdatadirlen + 1, m4sugar);
+  full_m4sugar = xstrdup (full_path);
+  strcpy (full_path + pkgdatadirlen + 1, "c.m4");
+  full_cm4 = xstrdup (full_path);
+  strcpy (full_path + pkgdatadirlen + 1, skeleton);
+  xfclose (xfopen (full_m4sugar, "r"));
+
+  /* Create an m4 subprocess connected to us via two pipes.  */
+
+  if (trace_flag & trace_tools)
+    fprintf (stderr, "running: %s %s - %s %s\n",
+            m4, full_m4sugar, full_cm4, full_path);
+
+  argv[0] = m4;
+  argv[1] = full_m4sugar;
+  argv[2] = "-";
+  argv[3] = full_cm4;
+  argv[4] = full_path;
+  argv[5] = NULL;
+
+  init_subpipe ();
+  pid = create_subpipe (argv, filter_fd);
+  free (full_m4sugar);
+  free (full_cm4);
+  free (full_path);
+
+  out = fdopen (filter_fd[0], "w");
+  if (! out)
+    error (EXIT_FAILURE, get_errno (), "fdopen");
+
+  /* Output the definitions of all the muscles.  */

   fputs ("m4_init()\n", out);
 
   fputs ("m4_init()\n", out);
 

-  fputs ("m4_define([b4_actions], \n[[", out);
-  actions_output (out);
-  fputs ("]])\n\n", out);
-
-  fputs ("m4_define([b4_tokens], \n[", out);
+  user_actions_output (out);
+  merger_output (out);

   token_definitions_output (out);
   token_definitions_output (out);

-  fputs ("])\n\n", out);
+  symbol_destructors_output (out);
+  symbol_printers_output (out);

 
   muscles_m4_output (out);
 
 
   muscles_m4_output (out);
 


@@ -1025,45 +580,32 @@ output_skeleton (void)
   fputs ("m4_divert_push(0)dnl\n", out);
   xfclose (out);
 
   fputs ("m4_divert_push(0)dnl\n", out);
   xfclose (out);
 

-  m4_invoke (tempfile);
-
-  /* If `debugging', keep this file alive. */
-  if (!trace_flag)
-    unlink (tempfile);
-
-  free (tempfile);
+  /* Read and process m4's output.  */
+  timevar_push (TV_M4);
+  in = fdopen (filter_fd[1], "r");
+  if (! in)
+    error (EXIT_FAILURE, get_errno (), "fdopen");
+  scan_skel (in);
+  xfclose (in);
+  reap_subpipe (pid, m4);
+  timevar_pop (TV_M4);

 }
 
 static void
 prepare (void)
 {
 }
 
 static void
 prepare (void)
 {

-  MUSCLE_INSERT_INT ("last", high);
-  MUSCLE_INSERT_INT ("flag", SHRT_MIN);
-  MUSCLE_INSERT_INT ("pure", pure_parser);
-  MUSCLE_INSERT_INT ("nsym", nsyms);
+  /* Flags. */

   MUSCLE_INSERT_INT ("debug", debug_flag);
   MUSCLE_INSERT_INT ("debug", debug_flag);

-  MUSCLE_INSERT_INT ("final", final_state);
-  MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
-  MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
+  MUSCLE_INSERT_INT ("defines_flag", defines_flag);

   MUSCLE_INSERT_INT ("error_verbose", error_verbose);
   MUSCLE_INSERT_INT ("error_verbose", error_verbose);

-  MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");
-
-  /* FIXME: This is wrong: the muscles should decide whether they hold
-     a copy or not, but the situation is too obscure currently.  */
-  MUSCLE_INSERT_STRING ("output_infix", output_infix ? output_infix : "");
-  MUSCLE_INSERT_STRING ("output_prefix", short_base_name);
-  MUSCLE_INSERT_STRING ("output_parser_name", parser_file_name);
-  MUSCLE_INSERT_STRING ("output_header_name", spec_defines_file);
-
-  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);
   MUSCLE_INSERT_INT ("locations_flag", locations_flag);

-  MUSCLE_INSERT_INT ("defines_flag", defines_flag);
+  MUSCLE_INSERT_INT ("pure", pure_parser);
+  MUSCLE_INSERT_INT ("synclines_flag", !no_lines_flag);
+
+  /* File names.  */
+  MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");

 
 

-  /* Copy definitions in directive.  */
+  /* User Code.  */

   obstack_1grow (&pre_prologue_obstack, 0);
   obstack_1grow (&post_prologue_obstack, 0);
   muscle_insert ("pre_prologue", obstack_finish (&pre_prologue_obstack));
   obstack_1grow (&pre_prologue_obstack, 0);
   obstack_1grow (&post_prologue_obstack, 0);
   muscle_insert ("pre_prologue", obstack_finish (&pre_prologue_obstack));


@@ -1071,10 +613,15 @@ prepare (void)
 
   /* Find the right skeleton file.  */
   if (!skeleton)
 
   /* Find the right skeleton file.  */
   if (!skeleton)

-    skeleton = "bison.simple";
+    {
+      if (glr_parser || nondeterministic_parser)
+       skeleton = "glr.c";
+      else
+       skeleton = "yacc.c";
+    }

 
   /* Parse the skeleton file and output the needed parsers.  */
 
   /* Parse the skeleton file and output the needed parsers.  */

-  muscle_insert ("skeleton", skeleton);
+  MUSCLE_INSERT_C_STRING ("skeleton", skeleton);

 }
 
 
 }
 
 


@@ -1087,10 +634,10 @@ output (void)
 {
   obstack_init (&format_obstack);
 
 {
   obstack_init (&format_obstack);
 

-  prepare_tokens ();
+  prepare_symbols ();

   prepare_rules ();
   prepare_states ();
   prepare_rules ();
   prepare_states ();

-  output_actions ();
+  prepare_actions ();

 
   prepare ();
 
 
   prepare ();