(prepare_rules, token_definitions_output): Use abort rather than assert.

[bison.git] / src / output.c

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

    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,944 +20,479 @@
    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.
-
-   YYFINAL = the state number of the termination state.  YYFLAG = most
-   negative short int.  Used to flag ??  */
-

 #include "system.h"
 #include "quotearg.h"
 #include "system.h"
 #include "quotearg.h"

+#include "error.h"
+#include "subpipe.h"

 #include "getargs.h"
 #include "files.h"
 #include "gram.h"
 #include "getargs.h"
 #include "files.h"
 #include "gram.h"

-#include "LR0.h"

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

-#include "lalr.h"

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

-#include "conflicts.h"
+#include "tables.h"

 #include "muscle_tab.h"
 #include "muscle_tab.h"

-#include "skeleton.h"
-
-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;
-static short *table = NULL;
-static short *check = NULL;
-static int lowzero;
-static int high;
-
-struct obstack muscle_obstack;
-static struct obstack format_obstack;

 
 

-int error_verbose = 0;
+/* From src/scan-skel.l. */
+void scan_skel (FILE *);

 
 

-/* Returns the number of lines of S.  */
-size_t
-get_lines_number (const char *s)
-{
-  size_t lines = 0;

 
 

-  size_t i;
-  for (i = 0; s[i]; ++i)
-    if (s[i] == '\n')
-      ++lines;
+static struct obstack format_obstack;

 
 

-  return lines;
-}
+int error_verbose = 0;

 
 
 
 

-/* FIXME. */

 
 

-static inline void
-output_table_data (struct obstack *oout,
-                  short *table_data,
-                  short first,
-                  int begin,
-                  int end)
-{
-  int i;
-  int j = 1;
+/*-------------------------------------------------------------------.
+| Create a function NAME which associates to the muscle NAME the     |
+| result of formatting the FIRST and then TABLE_DATA[BEGIN..END[ (of |
+| TYPE), and to the muscle NAME_max, the max value of the            |
+| TABLE_DATA.                                                        |
+`-------------------------------------------------------------------*/

 
 

-  obstack_fgrow1 (oout, "%6d", first);
-  for (i = begin; i < end; ++i)
-    {
-      obstack_1grow (oout, ',');
-      if (j >= 10)
-       {
-         obstack_sgrow (oout, "\n  ");
-         j = 1;
-       }
-      else
-       ++j;
-      obstack_fgrow1 (oout, "%6d", table_data[i]);
-    }
-  obstack_1grow (oout, 0);
+
+#define GENERATE_MUSCLE_INSERT_TABLE(Name, Type)                       \
+                                                                       \
+static void                                                            \
+Name (const char *name,                                                        \
+      Type *table_data,                                                        \
+      Type first,                                                      \
+      int begin,                                                       \
+      int end)                                                         \
+{                                                                      \
+  Type min = first;                                                    \
+  Type max = first;                                                    \
+  int i;                                                               \
+  int j = 1;                                                           \
+                                                                       \
+  obstack_fgrow1 (&format_obstack, "%6d", first);                      \
+  for (i = begin; i < end; ++i)                                                \
+    {                                                                  \
+      obstack_1grow (&format_obstack, ',');                            \
+      if (j >= 10)                                                     \
+       {                                                               \
+         obstack_sgrow (&format_obstack, "\n  ");                      \
+         j = 1;                                                        \
+       }                                                               \
+      else                                                             \
+       ++j;                                                            \
+      obstack_fgrow1 (&format_obstack, "%6d", table_data[i]);          \
+      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));              \
+                                                                       \
+  /* 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),            \
+                         (long int) min);                              \
+  obstack_fgrow1 (&format_obstack, "%s_max", name);                    \
+  obstack_1grow (&format_obstack, 0);                                  \
+  MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack),            \
+                         (long int) max);                              \

 }
 
 }
 

+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_base_table, base_t)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number_t)
+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_state_number_table, state_number_t)

 
 

-static void
-output_token_translations (void)
-{
-  output_table_data (&format_obstack, token_translations,
-                    0, 1, max_user_token_number + 1);
-  muscle_insert ("translate", obstack_finish (&format_obstack));
-  XFREE (token_translations);
-}

 
 

+/*----------------------------------------------------------------------.
+| Print to OUT a representation of FILENAME escaped both for C and M4.  |
+`----------------------------------------------------------------------*/

 
 static void
 
 static void

-output_gram (void)
+escaped_file_name_output (FILE *out, char const *filename)

 {
 {

-  {
-    int i;
-    short *values = XCALLOC (short, nrules + 1);
-    for (i = 0; i < nrules + 1; ++i)
-      values[i] = rules[i].rhs;
-    output_table_data (&format_obstack, values,
-                      0, 1, nrules + 1);
-    XFREE (values);
-  }
-
-  muscle_insert ("prhs", obstack_finish (&format_obstack));
-
-  {
-    short *yyrhs;
-    int i;
+  char const *p;
+  fprintf (out, "[[");

 
 

-    yyrhs = XMALLOC (short, nritems);
-
-    for (i = 1; i < nritems; ++i)
-      yyrhs[i] = ritem[i] >= 0 ? ritem[i] : -1;
-
-    output_table_data (&format_obstack, yyrhs,
-                      ritem[0], 1, nritems);
-    muscle_insert ("rhs", obstack_finish (&format_obstack));
-
-    XFREE (yyrhs);
-  }
+  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;
+      }

 
 

-#if 0
-  if (!semantic_parser)
-    obstack_sgrow (&table_obstack, "\n#endif\n");
-#endif
+  fprintf (out, "]]");

 }
 
 
 }
 
 

-static void
-output_stos (void)
-{
-  int i;
-  short *values = (short *) alloca (sizeof (short) * nstates);
-  for (i = 0; i < nstates; ++i)
-    values[i] = states[i]->accessing_symbol;
-  output_table_data (&format_obstack, values,
-                    0, 1, nstates);
-  muscle_insert ("stos", obstack_finish (&format_obstack));
-}
-
+/*------------------------------------------------------------------.
+| Prepare the muscles related to the symbols: translate, tname, and |
+| toknum.                                                           |
+`------------------------------------------------------------------*/

 
 static void
 
 static void

-output_rule_data (void)
+prepare_symbols (void)

 {
 {

-  int i;
-  int j;
-  short *short_tab = NULL;
+  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);

 
 

-  {
-    short *values = XCALLOC (short, nrules + 1);
-    for (i = 0; i < nrules + 1; ++i)
-      values[i] = rules[i].line;
-    output_table_data (&format_obstack, values,
-                      0, 1, nrules + 1);
-    muscle_insert ("rline", obstack_finish (&format_obstack));
-    XFREE (values);
-  }
+  muscle_insert_symbol_number_table ("translate",
+                                    token_translations,
+                                    token_translations[0],
+                                    1, max_user_token_number + 1);

 
 

+  /* tname -- token names.  */
+  {
+    int i;
+    int j = 0;
+    for (i = 0; i < nsyms; i++)
+      {
+       /* Be sure not to use twice the same QUOTEARG slot:
+          SYMBOL_TAG_GET uses slot 0.  */
+       const char *cp =
+         quotearg_n_style (1, c_quoting_style,
+                           symbols[i]->tag);
+       /* Width of the next token, including the two quotes, the comma
+          and the space.  */
+       int strsize = strlen (cp) + 2;
+
+       if (j + strsize > 75)
+         {
+           obstack_sgrow (&format_obstack, "\n  ");
+           j = 2;
+         }
+
+       MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
+       obstack_sgrow (&format_obstack, ", ");
+       j += strsize;
+      }
+    /* Add a NULL entry to list of tokens (well, 0, as NULL might not be
+       defined).  */
+    obstack_sgrow (&format_obstack, "0");

 
 

-  j = 0;
-  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)
-       {
-         obstack_sgrow (&format_obstack, "\n  ");
-         j = 2;
-       }
-
-      obstack_sgrow (&format_obstack, cp);
-      obstack_sgrow (&format_obstack, ", ");
-      j += strsize;
-    }
-  /* add a NULL entry to list of tokens */
-  obstack_sgrow (&format_obstack, "NULL");
-
-  /* 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. */
   {

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

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

-    output_table_data (&format_obstack, values,
-                      0, 1, ntokens + 1);
-    muscle_insert ("toknum", obstack_finish (&format_obstack));
-    XFREE (values);
-  }
-
-
-  /* Output YYR1. */
-  {
-    short *values = XCALLOC (short, nrules + 1);
-    for (i = 0; i < nrules + 1; ++i)
-      values[i] = rules[i].lhs;
-    output_table_data (&format_obstack, values,
-                      0, 1, nrules + 1);
-    muscle_insert ("r1", obstack_finish (&format_obstack));
-    XFREE (values);
+    muscle_insert_int_table ("toknum", values,
+                            values[0], 1, ntokens);
+    free (values);

   }
   }

-
-  /* Output YYR2. */
-  short_tab = XMALLOC (short, nrules + 1);
-  for (i = 1; i < nrules; i++)
-    short_tab[i] = rules[i + 1].rhs - rules[i].rhs - 1;
-  short_tab[nrules] =  nritems - rules[nrules].rhs - 1;
-  output_table_data (&format_obstack, short_tab,
-                    0, 1, nrules + 1);
-  muscle_insert ("r2", obstack_finish (&format_obstack));
-  XFREE (short_tab);

 }
 
 }
 

-/*------------------------------------------------------------------.
-| 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       |
-| MINSHORT, 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 (BITISSET (LA (state->lookaheadsp + i), j))
-           actrow[j] = -LAruleno[state->lookaheadsp + 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.  */
-  for (i = 0; i < shiftp->nshifts; i++)
-    {
-      int symbol;
-      int shift_state = shiftp->shifts[i];
-      if (!shift_state)
-       continue;

 
 

-      symbol = states[shift_state]->accessing_symbol;
+/*-------------------------------------------------------------.
+| Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
+| rline, dprec, merger.                                        |
+`-------------------------------------------------------------*/

 
 

-      if (ISVAR (symbol))
-       break;
-
-      actrow[symbol] = shift_state;
-
-      /* Do not use any default reduction if there is a shift for
-        error */
-      if (symbol == error_token_number)
-       nodefault = 1;
-    }
-
-  /* See which tokens are an explicit error in this state (due to
-     %nonassoc).  For them, record MINSHORT as the action.  */
-  for (i = 0; i < errp->nerrs; i++)
+static void
+prepare_rules (void)
+{
+  rule_number_t r;
+  unsigned int i = 0;
+  item_number_t *rhs = XMALLOC (item_number_t, nritems);
+  unsigned int *prhs = XMALLOC (unsigned int, nrules);
+  unsigned int *rline = XMALLOC (unsigned int, nrules);
+  symbol_number_t *r1 = XMALLOC (symbol_number_t, nrules);
+  unsigned int *r2 = XMALLOC (unsigned int, nrules);
+  short *dprec = XMALLOC (short, nrules);
+  short *merger = XMALLOC (short, nrules);
+
+  for (r = 0; r < nrules; ++r)

     {
     {

-      int symbol = errp->errs[i];
-      actrow[symbol] = MINSHORT;
+      item_number_t *rhsp = NULL;
+      /* Index of rule R in RHS. */
+      prhs[r] = i;
+      /* RHS of the rule R. */
+      for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
+       rhs[i++] = *rhsp;
+      /* LHS of the rule R. */
+      r1[r] = rules[r].lhs->number;
+      /* Length of rule R's RHS. */
+      r2[r] = i - prhs[r];
+      /* Separator in RHS. */
+      rhs[i++] = -1;
+      /* Line where rule was defined. */
+      rline[r] = rules[r].location.first_line;
+      /* Dynamic precedence (GLR).  */
+      dprec[r] = rules[r].dprec;
+      /* Merger-function index (GLR).  */
+      merger[r] = rules[r].merger;

     }
     }

+  if (i != nritems)
+    abort ();
+
+  muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
+  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 (dprec);
+  free (merger);
+}

 
 

-  /* Now find the most common reduction and make it the default action
-     for this state.  */
+/*--------------------------------------------.
+| Prepare the muscles related to the states.  |
+`--------------------------------------------*/

 
 

-  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 = -LAruleno[state->lookaheadsp + i];
-             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;
-           }
-       }
-    }
+static void
+prepare_states (void)
+{
+  state_number_t i;
+  symbol_number_t *values =
+    (symbol_number_t *) alloca (sizeof (symbol_number_t) * nstates);
+  for (i = 0; i < nstates; ++i)
+    values[i] = states[i]->accessing_symbol;
+  muscle_insert_symbol_number_table ("stos", values,
+                                    0, 1, nstates);

 
 

-  /* 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] == MINSHORT)
-       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;
-
-  count = 0;
-  for (i = 0; i < ntokens; i++)
-    if (actrow[i] != 0)
-      count++;
-
-  if (count == 0)
-    return;
+  rule_number_t r;

 
 

-  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);
+
+       fprintf (out, "]b4_syncline([[%d]], ",
+                rules[r].action_location.first_line);
+       escaped_file_name_output (out, rules[r].action_location.file);
+       fprintf (out, ")[\n");
+       fprintf (out, "    %s\n    break;\n\n",
+                rules[r].action);

       }
       }

-
-  tally[state] = count;
-  width[state] = sp1[-1] - sp[0] + 1;
+  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)

 {
 {

-  int 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);

     }
     }

-
-  output_table_data (&format_obstack, yydefact,
-                    yydefact[0], 1, nstates);
-  muscle_insert ("defact", obstack_finish (&format_obstack));
-
-  XFREE (actrow);
-  XFREE (yydefact);
+  fputs ("]])\n\n", out);

 }
 
 }
 

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

 
 

-/*-----------------------------.
-| Output the actions to OOUT.  |
-`-----------------------------*/
-
-void
-actions_output (FILE *out, size_t *line)
-{
-  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_line,
-                  quotearg_style (c_quoting_style,
-                                  muscle_find ("filename")));
-       /* 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.  */
-       fprintf (out, "{ %s%s }\n    break;\n\n",
-                rules[rule].action,
-                yacc_flag ? ";" : "");
-
-       /* We always output 4 '\n' per action.  */
-       *line += 4;
-       /* Plus one if !no_lines_flag.  */
-       if (!no_lines_flag)
-         ++*line;
-       /* Get the number of lines written by the user.  */
-       *line += get_lines_number (rules[rule].action);
-      }
-}
-
-
-/*----------------------------.
-| Output the guards to OOUT.  |
-`----------------------------*/
-
-void
-guards_output (FILE *out, size_t *line)
-{
-  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].guard_line,
-                  quotearg_style (c_quoting_style,
-                                  muscle_find ("filename")));
-       fprintf (out, "{ %s; }\n    break;\n\n",
-                rules[rule].guard);
-
-       /* We always output 4 '\n' per action.  */
-       *line += 4;
-       /* Plus one if !no_lines_flag.  */
-       if (!no_lines_flag)
-         ++*line;
-       /* Get the number of lines written by the user.  */
-       *line += get_lines_number (rules[rule].guard);
-      }
-}
-
-
-/*---------------------------------------.
-| Output the tokens definition to OOUT.  |
-`---------------------------------------*/
-
-void
-token_definitions_output (FILE *out, size_t *line)
+static void
+token_definitions_output (FILE *out)

 {
   int i;
 {
   int i;

+  int first = 1;
+
+  fputs ("m4_define([b4_tokens], \n[", out);

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

-      bucket *symbol = symbols[i];
+      symbol_t *symbol = symbols[i];

       int number = symbol->user_token_number;
 
       int number = symbol->user_token_number;
 

-      if (number == SALIAS)
-       continue;
+      /* At this stage, if there are literal aliases, they are part of
+        SYMBOLS, so we should not find symbols which are the aliases
+        here.  */
+      if (number == USER_NUMBER_ALIAS)
+       abort ();
+

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

-      if (symbol->value == error_token_number)
+      if (symbol == errtoken)
+       continue;
+
+      /* If this string has an alias, then it is necessarily the alias
+        which is to be output.  */
+      if (symbol->alias)
+       symbol = symbol->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"'.  */
+      if (symbol->tag[0] == '\'' || symbol->tag[0] == '\"')

        continue;
        continue;

-      if (symbol->tag[0] == '\'')
-       continue;               /* skip literal character */
-      if (symbol->tag[0] == '\"')
-       {
-         /* use literal string only if given a symbol with an alias */
-         if (symbol->alias)
-           symbol = symbol->alias;
-         else
-           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, '$'))
        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, '$'))
        continue;
 

-      fprintf (out, "# define %s\t%d\n",
-              symbol->tag, number);
-      ++*line;
-      if (semantic_parser)
-       {
-         /* FIXME: This is probably wrong, and should be just as
-            above. --akim.  */
-         fprintf (out, "# define T%s\t%d\n", symbol->tag, symbol->value);
-         ++*line;
-       }
-    }
-}
-
-
-static void
-save_column (int symbol, int default_state)
-{
-  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)
-{
-  int i;
-  int m = goto_map[symbol];
-  int 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]]++;
-
-  for (i = 0; i < nstates; i++)
-    if (state_count[i] > max)
-      {
-       max = state_count[i];
-       default_state = i;
-      }
-
-  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.                                        |
-`-------------------------------------------------------------------*/
+      fprintf (out, "%s[[[%s]], [%d]]",
+              first ? "" : ",\n", symbol->tag, number);

 
 

-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;
+      first = 0;

     }
     }

-
-  output_table_data (&format_obstack, yydefgoto,
-                    yydefgoto[0], 1, nsyms - ntokens);
-  muscle_insert ("defgoto", obstack_finish (&format_obstack));
-
-  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 destructors to OUT.  |
+`---------------------------------------*/

 
 static void
 
 static void

-sort_actions (void)
+symbol_destructors_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_destructors], \n[", out);
+  for (i = 0; i < nsyms; ++i)
+    if (symbols[i]->destructor)

       {
       {

-       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_t *symbol = symbols[i];
+
+       /* Filename, lineno,
+          Symbol-name, Symbol-number,
+          destructor, typename. */
+       fprintf (out, "%s[",
+                first ? "" : ",\n");
+       escaped_file_name_output (out, symbol->destructor_location.file);
+       fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
+                symbol->destructor_location.first_line,
+                symbol->tag,
+                symbol->number,
+                symbol->destructor,
+                symbol->type_name);
+
+       first = 0;

       }
       }

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

 }
 
 
 }
 
 

-static int
-matching_state (int vector)
-{
-  int i = order[vector];
-  int t;
-  int w;
-  int prev;
-
-  if (i >= 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 < MAXTABLE; j++)
-    {
-      int k;
-      int ok = 1;
-
-      for (k = 0; ok && k < t; k++)
-       {
-         loc = j + from[k];
-         if (loc > MAXTABLE)
-           fatal (_("maximum table size (%d) exceeded"), MAXTABLE);
-
-         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;
-}
-
+/*------------------------------------.
+| Output the symbol printers to OUT.  |
+`------------------------------------*/

 
 static void
 
 static void

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

 {
   int i;
 {
   int i;

-  int place;
-  int state;
-
-  base = XCALLOC (short, nvectors);
-  pos = XCALLOC (short, nentries);
-  table = XCALLOC (short, MAXTABLE);
-  check = XCALLOC (short, MAXTABLE);
+  int first = 1;

 
 

-  lowzero = 0;
-  high = 0;
-
-  for (i = 0; i < nvectors; i++)
-    base[i] = MINSHORT;
-
-  for (i = 0; i < MAXTABLE; 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. */
-  output_table_data (&format_obstack, base,
-                    base[0], 1, nstates);
-  muscle_insert ("pact", obstack_finish (&format_obstack));
-
-  /* Output pgoto. */
-  output_table_data (&format_obstack, base,
-                    base[nstates], nstates + 1, nvectors);
-  muscle_insert ("pgoto", obstack_finish (&format_obstack));
-
-  XFREE (base);
-}
-
-
-static void
-output_table (void)
-{
-  output_table_data (&format_obstack, table,
-                    table[0], 1, high + 1);
-  muscle_insert ("table", obstack_finish (&format_obstack));
-  XFREE (table);
-}
-
-
-static void
-output_check (void)
-{
-  output_table_data (&format_obstack, check,
-                    check[0], 1, high + 1);
-  muscle_insert ("check", obstack_finish (&format_obstack));
-  XFREE (check);
+  fputs ("m4_define([b4_symbol_printers], \n[", out);
+  for (i = 0; i < nsyms; ++i)
+    if (symbols[i]->destructor)
+      {
+       symbol_t *symbol = symbols[i];
+
+       /* Filename, lineno,
+          Symbol-name, Symbol-number,
+          printer, typename. */
+       fprintf (out, "%s[",
+                first ? "" : ",\n");
+       escaped_file_name_output (out, symbol->printer_location.file);
+       fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
+                symbol->printer_location.first_line,
+                symbol->tag,
+                symbol->number,
+                symbol->printer,
+                symbol->type_name);
+
+       first = 0;
+      }
+  fputs ("])\n\n", out);

 }
 
 }
 

-/* compute and output yydefact, yydefgoto, yypact, yypgoto, yytable
-   and yycheck.  */

 
 static void
 
 static void

-output_actions (void)
+prepare_actions (void)

 {
 {

-  int i;
-  nvectors = nstates + nvars;
-
-  froms = XCALLOC (short *, nvectors);
-  tos = XCALLOC (short *, nvectors);
-  tally = XCALLOC (short, nvectors);
-  width = XCALLOC (short, nvectors);
-
-  token_actions ();
-  XFREE (LA);
-  XFREE (LAruleno);
-
-  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);
+  /* Figure out the actions for the specified state, indexed by
+     lookahead token type.  */
+
+  muscle_insert_rule_number_table ("defact", yydefact,
+                                  yydefact[0], 1, nstates);
+
+  /* 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);
+
+
+  /* Output PACT. */
+  muscle_insert_base_table ("pact", base,
+                            base[0], 1, nstates);
+  MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
+
+  /* Output PGOTO. */
+  muscle_insert_base_table ("pgoto", base,
+                            base[nstates], nstates + 1, nvectors);
+
+  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


@@ -968,105 +503,113 @@ output_actions (void)
 static void
 output_skeleton (void)
 {
 static void
 output_skeleton (void)
 {

-  /* Find the right skeleton file.  */
-  if (!skeleton)
-    {
-      if (semantic_parser)
-       skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY);
-      else
-       skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
-    }
+  FILE *in;
+  FILE *out;
+  int filter_fd[2];
+  char const *argv[7];
+  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_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);
+  xfclose (xfopen (full_path, "r"));
+  strcpy (full_path + pkgdatadirlen + 1, skeleton);
+
+  /* Create an m4 subprocess connected to us via two pipes.  */
+
+  if (trace_flag & trace_tools)
+    fprintf (stderr, "running: %s -I %s %s - %s\n",
+            m4, pkgdatadir, m4sugar, full_path);
+
+  argv[0] = m4;
+  argv[1] = "-I";
+  argv[2] = pkgdatadir;
+  argv[3] = m4sugar;
+  argv[4] = "-";
+  argv[5] = full_path;
+  argv[6] = NULL;
+
+  init_subpipe ();
+  pid = create_subpipe (argv, filter_fd);
+  free (full_path);
+
+  out = fdopen (filter_fd[0], "w");
+  if (! out)
+    error (EXIT_FAILURE, errno, "fdopen");
+
+  /* Output the definitions of all the muscles.  */
+  fputs ("m4_init()\n", out);
+
+  user_actions_output (out);
+  merger_output (out);
+  token_definitions_output (out);
+  symbol_destructors_output (out);
+  symbol_printers_output (out);
+
+  muscles_m4_output (out);
+
+  fputs ("m4_wrap([m4_divert_pop(0)])\n", out);
+  fputs ("m4_divert_push(0)dnl\n", out);
+  xfclose (out);

 
 

-  /* Parse the skeleton file and output the needed parsers.  */
-  muscle_insert ("skeleton", skeleton);
-  process_skeleton (skeleton);
+  /* Read and process m4's output.  */
+  timevar_push (TV_M4);
+  in = fdopen (filter_fd[1], "r");
+  if (! in)
+    error (EXIT_FAILURE, 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", MINSHORT);
-  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 ("maxtok", max_user_token_number);
-  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_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 ("defines_flag", defines_flag);
+  MUSCLE_INSERT_INT ("error_verbose", error_verbose);
+  MUSCLE_INSERT_INT ("locations_flag", locations_flag);
+  MUSCLE_INSERT_INT ("pure", pure_parser);
+  MUSCLE_INSERT_INT ("synclines_flag", !no_lines_flag);

 
 

-/*-------------------------.
-| Output the header file.  |
-`-------------------------*/
+  /* File names.  */
+  MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");

 
 

-static void
-header_output (void)
-{
-  size_t dummy_line;
-  FILE *out = xfopen (spec_defines_file, "w");
-  char *macro_name = compute_header_macro ();
-
-  fprintf (out, "#ifndef %s\n", macro_name);
-  fprintf (out, "# define %s\n\n", macro_name);
-
-  token_definitions_output (out, &dummy_line);
-  fprintf (out, "\
-#ifndef YYSTYPE\n\
-typedef %s
-yystype;\n\
-# define YYSTYPE yystype\n\
-#endif\n",
-                   muscle_find ("stype"));
-
-  if (!pure_parser)
-    fprintf (out, "\nextern YYSTYPE %slval;\n",
-            spec_name_prefix ? spec_name_prefix : "yy");
-
-  if (locations_flag)
-    {
-      fputs ("\n\n", out);
-      fprintf (out, "\
-#ifndef YYLTYPE\n\
-typedef struct yyltype\n\
-{\n\
-  int first_line;\n\
-  int first_column;\n\
-  int last_line;\n\
-  int last_column;\n\
-} yyltype;\n\
-# define YYLTYPE yyltype\n\
-#endif\n");
-      if (!pure_parser)
-       fprintf (out, "\nextern YYLTYPE %slloc;\n",
-                spec_name_prefix ? spec_name_prefix : "yy");
-    }
+  /* User Code.  */
+  obstack_1grow (&pre_prologue_obstack, 0);
+  obstack_1grow (&post_prologue_obstack, 0);
+  muscle_insert ("pre_prologue", obstack_finish (&pre_prologue_obstack));
+  muscle_insert ("post_prologue", obstack_finish (&post_prologue_obstack));

 
 

-  if (semantic_parser)
+  /* Find the right skeleton file.  */
+  if (!skeleton)

     {
     {

-      int i;
-
-      for (i = ntokens; i < nsyms; i++)
-       /* don't make these for dummy nonterminals made by gensym.  */
-       if (*symbols[i]->tag != '@')
-         fprintf (out, "# define NT%s\t%d\n", symbols[i]->tag, i);
+      if (glr_parser)
+       skeleton = "glr.c";
+      else
+       skeleton = "yacc.c";

     }
 
     }
 

-  fprintf (out, "\n#endif /* not %s */\n", macro_name);
-  free (macro_name);
-  xfclose (out);
+  /* Parse the skeleton file and output the needed parsers.  */
+  MUSCLE_INSERT_C_STRING ("skeleton", skeleton);

 }
 
 
 }
 
 


@@ -1079,30 +622,17 @@ output (void)
 {
   obstack_init (&format_obstack);
 
 {
   obstack_init (&format_obstack);
 

-  output_token_translations ();
-  output_gram ();
-
-  XFREE (ritem);
-  if (semantic_parser)
-    output_stos ();
-  output_rule_data ();
-  output_actions ();
+  prepare_symbols ();
+  prepare_rules ();
+  prepare_states ();
+  prepare_actions ();

 
   prepare ();
 
   prepare ();

-  /* Copy definitions in directive.  */
-  obstack_1grow (&attrs_obstack, 0);
-  muscle_insert ("prologue", obstack_finish (&attrs_obstack));

 
   /* Process the selected skeleton file.  */
   output_skeleton ();
 
 
   /* Process the selected skeleton file.  */
   output_skeleton ();
 

-  /* Output the header if needed. */
-  if (defines_flag)
-    header_output ();
-
-  free (rules + 1);
-  obstack_free (&muscle_obstack, NULL);

   obstack_free (&format_obstack, NULL);
   obstack_free (&format_obstack, NULL);

-  obstack_free (&action_obstack, NULL);
-  obstack_free (&attrs_obstack, NULL);
+  obstack_free (&pre_prologue_obstack, NULL);
+  obstack_free (&post_prologue_obstack, NULL);

 }
 }