]> git.saurik.com Git - bison.git/blobdiff - src/output.c
projects / bison.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Change @dircategory from "GNU programming tools" to "Software development".
[bison.git] / src / output.c
diff --git a/src/output.c b/src/output.c
index a3680250bc173b585b2e1f63e4c79bb7ed4397bf..55a3d47e5fdce9a9a116515036882f979737de5d 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, 2004
    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,84 +21,23 @@
    02111-1307, USA.  */
 
 
    02111-1307, USA.  */
 
 
-/* The parser tables consist of these tables.
-
-   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 "quotearg.h"
-#include "error.h"
-#include "subpipe.h"
-#include "getargs.h"
+#include "complain.h"
 #include "files.h"
 #include "files.h"
+#include "getargs.h"
 #include "gram.h"
 #include "gram.h"
-#include "complain.h"
+#include "muscle_tab.h"
 #include "output.h"
 #include "reader.h"
 #include "symtab.h"
 #include "tables.h"
 #include "output.h"
 #include "reader.h"
 #include "symtab.h"
 #include "tables.h"
-#include "muscle_tab.h"
 
 /* From src/scan-skel.l. */
 void scan_skel (FILE *);
 
 /* From src/scan-skel.l. */
 void scan_skel (FILE *);
@@ -105,7 +45,7 @@ void scan_skel (FILE *);
 
 static struct obstack format_obstack;
 
 
 static struct obstack format_obstack;
 
-int error_verbose = 0;
+bool error_verbose = false;
 
 
 
 
 
 
@@ -128,6 +68,8 @@ Name (const char *name,                                                      \
 {                                                                      \
   Type min = first;                                                    \
   Type max = first;                                                    \
 {                                                                      \
   Type min = first;                                                    \
   Type max = first;                                                    \
+  long int lmin;                                                       \
+  long int lmax;                                                       \
   int i;                                                               \
   int j = 1;                                                           \
                                                                        \
   int i;                                                               \
   int j = 1;                                                           \
                                                                        \
@@ -151,67 +93,95 @@ Name (const char *name,                                                    \
   obstack_1grow (&format_obstack, 0);                                  \
   muscle_insert (name, obstack_finish (&format_obstack));              \
                                                                        \
   obstack_1grow (&format_obstack, 0);                                  \
   muscle_insert (name, obstack_finish (&format_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);                                  \
   /* 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);                              \
+  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_int_table, 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_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)
+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)
 
 
 
 
-/*-----------------------------------------------------------------.
-| Prepare the muscles related to the tokens: translate, tname, and |
-| toknum.                                                          |
-`-----------------------------------------------------------------*/
+/*----------------------------------------------------------------------.
+| Print to OUT a representation of FILENAME escaped both for C and M4.  |
+`----------------------------------------------------------------------*/
 
 static void
 
 static void
-prepare_tokens (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 symbols: translate, tname, and |
+| toknum.                                                           |
+`------------------------------------------------------------------*/
+
+static 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",
                                     token_translations,
                                     token_translations[0],
                                     1, max_user_token_number + 1);
 
   muscle_insert_symbol_number_table ("translate",
                                     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:
-          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 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);
 
     /* Finish table and store. */
     obstack_1grow (&format_obstack, 0);
@@ -221,7 +191,7 @@ prepare_tokens (void)
   /* Output YYTOKNUM. */
   {
     int i;
   /* Output YYTOKNUM. */
   {
     int i;
-    int *values = XCALLOC (int, ntokens);
+    int *values = xnmalloc (ntokens, sizeof *values);
     for (i = 0; i < ntokens; ++i)
       values[i] = symbols[i]->user_token_number;
     muscle_insert_int_table ("toknum", values,
     for (i = 0; i < ntokens; ++i)
       values[i] = symbols[i]->user_token_number;
     muscle_insert_int_table ("toknum", values,
@@ -233,25 +203,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, dprec, merger                                         |
+| rline, dprec, merger.                                        |
 `-------------------------------------------------------------*/
 
 static void
 prepare_rules (void)
 {
 `-------------------------------------------------------------*/
 
 static void
 prepare_rules (void)
 {
-  rule_number_t 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);
-  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);
+  item_number *rhs = xnmalloc (nritems, sizeof *rhs);
+  unsigned int *prhs = xnmalloc (nrules, sizeof *prhs);
+  unsigned int *rline = xnmalloc (nrules, sizeof *rline);
+  symbol_number *r1 = xnmalloc (nrules, sizeof *r1);
+  unsigned int *r2 = xnmalloc (nrules, sizeof *r2);
+  int *dprec = xnmalloc (nrules, sizeof *dprec);
+  int *merger = xnmalloc (nrules, sizeof *merger);
 
   for (r = 0; r < nrules; ++r)
     {
 
   for (r = 0; r < nrules; ++r)
     {
-      item_number_t *rhsp = NULL;
+      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. */
@@ -264,21 +234,25 @@ 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;
-      /* Dynamic precedence (GLR) */
+      rline[r] = rules[r].location.start.line;
+      /* Dynamic precedence (GLR).  */
       dprec[r] = rules[r].dprec;
       dprec[r] = rules[r].dprec;
-      /* Merger-function index (GLR) */
+      /* Merger-function index (GLR).  */
       merger[r] = rules[r].merger;
     }
       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_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_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_table ("dprec", dprec, 0, 0, nrules);
+  muscle_insert_int_table ("merger", merger, 0, 0, nrules);
+
+  MUSCLE_INSERT_INT ("rules_number", nrules);
+  MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
 
   free (rhs);
   free (prhs);
 
   free (rhs);
   free (prhs);
@@ -296,13 +270,17 @@ prepare_rules (void)
 static void
 prepare_states (void)
 {
 static void
 prepare_states (void)
 {
-  state_number_t i;
-  symbol_number_t *values =
-    (symbol_number_t *) alloca (sizeof (symbol_number_t) * nstates);
+  state_number i;
+  symbol_number *values = xnmalloc (nstates, sizeof *values);
   for (i = 0; i < nstates; ++i)
     values[i] = states[i]->accessing_symbol;
   muscle_insert_symbol_number_table ("stos", values,
                                     0, 1, nstates);
   for (i = 0; i < nstates; ++i)
     values[i] = states[i]->accessing_symbol;
   muscle_insert_symbol_number_table ("stos", values,
                                     0, 1, nstates);
+  free (values);
+
+  MUSCLE_INSERT_INT ("last", high);
+  MUSCLE_INSERT_INT ("final_state_number", final_state->number);
+  MUSCLE_INSERT_INT ("states_number", nstates);
 }
 
 
 }
 
 
@@ -314,7 +292,7 @@ prepare_states (void)
 static void
 user_actions_output (FILE *out)
 {
 static void
 user_actions_output (FILE *out)
 {
-  rule_number_t r;
+  rule_number r;
 
   fputs ("m4_define([b4_actions], \n[[", out);
   for (r = 0; r < nrules; ++r)
 
   fputs ("m4_define([b4_actions], \n[[", out);
   for (r = 0; r < nrules; ++r)
@@ -322,11 +300,10 @@ user_actions_output (FILE *out)
       {
        fprintf (out, "  case %d:\n", r + 1);
 
       {
        fprintf (out, "  case %d:\n", r + 1);
 
-       if (!no_lines_flag)
-         fprintf (out, muscle_find ("linef"),
-                  rules[r].action_location.first_line,
-                  quotearg_style (c_quoting_style,
-                                  muscle_find ("filename")));
+       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);
       }
        fprintf (out, "    %s\n    break;\n\n",
                 rules[r].action);
       }
@@ -347,10 +324,10 @@ merger_output (FILE *out)
   for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
     {
       if (p->type[0] == '\0')
   for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
     {
       if (p->type[0] == '\0')
-       fprintf (out, "  case %d: yyval = %s (*yy0, *yy1); break;\n",
+       fprintf (out, "  case %d: *yy0 = %s (*yy0, *yy1); break;\n",
                 n, p->name);
       else
                 n, p->name);
       else
-       fprintf (out, "  case %d: yyval.%s = %s (*yy0, *yy1); break;\n",
+       fprintf (out, "  case %d: yy0->%s = %s (*yy0, *yy1); break;\n",
                 n, p->type, p->name);
     }
   fputs ("]])\n\n", out);
                 n, p->type, p->name);
     }
   fputs ("]])\n\n", out);
@@ -364,43 +341,43 @@ static void
 token_definitions_output (FILE *out)
 {
   int i;
 token_definitions_output (FILE *out)
 {
   int i;
-  int first = 1;
+  char const *sep = "";
 
   fputs ("m4_define([b4_tokens], \n[", out);
   for (i = 0; i < ntokens; ++i)
     {
 
   fputs ("m4_define([b4_tokens], \n[", out);
   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 = 0;
+              sep, sym->tag, number);
+      sep = ",\n";
     }
   fputs ("])\n\n", out);
 }
     }
   fputs ("])\n\n", out);
 }
@@ -414,26 +391,28 @@ static void
 symbol_destructors_output (FILE *out)
 {
   int i;
 symbol_destructors_output (FILE *out)
 {
   int i;
-  int first = 1;
+  char const *sep = "";
 
   fputs ("m4_define([b4_symbol_destructors], \n[", out);
   for (i = 0; i < nsyms; ++i)
     if (symbols[i]->destructor)
       {
 
   fputs ("m4_define([b4_symbol_destructors], \n[", out);
   for (i = 0; i < nsyms; ++i)
     if (symbols[i]->destructor)
       {
-       symbol_t *symbol = symbols[i];
+       symbol *sym = symbols[i];
 
        /* Filename, lineno,
           Symbol-name, Symbol-number,
 
        /* Filename, lineno,
           Symbol-name, Symbol-number,
-          destructor, typename. */
-       fprintf (out, "%s[[[%s]], [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
-                first ? "" : ",\n",
-                infile, symbol->destructor_location.first_line,
-                symbol->tag,
-                symbol->number,
-                symbol->destructor,
-                symbol->type_name);
-
-       first = 0;
+          destructor, optional typename.  */
+       fprintf (out, "%s[", sep);
+       sep = ",\n";
+       escaped_file_name_output (out, sym->destructor_location.start.file);
+       fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]]",
+                sym->destructor_location.start.line,
+                sym->tag,
+                sym->number,
+                sym->destructor);
+       if (sym->type_name)
+         fprintf (out, ", [[%s]]", sym->type_name);
+       fputc (']', out);
       }
   fputs ("])\n\n", out);
 }
       }
   fputs ("])\n\n", out);
 }
@@ -447,26 +426,28 @@ static void
 symbol_printers_output (FILE *out)
 {
   int i;
 symbol_printers_output (FILE *out)
 {
   int i;
-  int first = 1;
+  char const *sep = "";
 
   fputs ("m4_define([b4_symbol_printers], \n[", out);
   for (i = 0; i < nsyms; ++i)
 
   fputs ("m4_define([b4_symbol_printers], \n[", out);
   for (i = 0; i < nsyms; ++i)
-    if (symbols[i]->destructor)
+    if (symbols[i]->printer)
       {
       {
-       symbol_t *symbol = symbols[i];
+       symbol *sym = symbols[i];
 
        /* Filename, lineno,
           Symbol-name, Symbol-number,
 
        /* Filename, lineno,
           Symbol-name, Symbol-number,
-          printer, typename. */
-       fprintf (out, "%s[[[%s]], [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
-                first ? "" : ",\n",
-                infile, symbol->printer_location.first_line,
-                symbol->tag,
-                symbol->number,
-                symbol->printer,
-                symbol->type_name);
-
-       first = 0;
+          printer, optional typename.  */
+       fprintf (out, "%s[", sep);
+       sep = ",\n";
+       escaped_file_name_output (out, sym->printer_location.start.file);
+       fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]]",
+                sym->printer_location.start.line,
+                sym->tag,
+                sym->number,
+                sym->printer);
+       if (sym->type_name)
+         fprintf (out, ", [[%s]]", sym->type_name);
+       fputc (']', out);
       }
   fputs ("])\n\n", out);
 }
       }
   fputs ("])\n\n", out);
 }
@@ -476,7 +457,7 @@ static void
 prepare_actions (void)
 {
   /* Figure out the actions for the specified state, indexed by
 prepare_actions (void)
 {
   /* Figure out the actions for the specified state, indexed by
-     lookahead token type.  */
+     look-ahead token type.  */
 
   muscle_insert_rule_number_table ("defact", yydefact,
                                   yydefact[0], 1, nstates);
 
   muscle_insert_rule_number_table ("defact", yydefact,
                                   yydefact[0], 1, nstates);
@@ -514,9 +495,9 @@ prepare_actions (void)
      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,
      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);
+                                   conflict_table[0], 1, high + 1);
   muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
   muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
-                                   conflict_list[0], 1, conflict_list_cnt);
+                                   0, 1, conflict_list_cnt);
 }
 
 \f
 }
 
 \f
@@ -530,7 +511,7 @@ output_skeleton (void)
   FILE *in;
   FILE *out;
   int filter_fd[2];
   FILE *in;
   FILE *out;
   int filter_fd[2];
-  char const *argv[7];
+  char const *argv[6];
   pid_t pid;
 
   /* Compute the names of the package data dir and skeleton file.
   pid_t pid;
 
   /* Compute the names of the package data dir and skeleton file.
@@ -538,7 +519,9 @@ output_skeleton (void)
      installation.  A faulty installation can cause deadlock, so a
      cheap sanity check is worthwhile.  */
   char const m4sugar[] = "m4sugar/m4sugar.m4";
      installation.  A faulty installation can cause deadlock, so a
      cheap sanity check is worthwhile.  */
   char const m4sugar[] = "m4sugar/m4sugar.m4";
-  char *full_path;
+  char *full_m4sugar;
+  char *full_cm4;
+  char *full_skeleton;
   char const *p;
   char const *m4 = (p = getenv ("M4")) ? p : M4;
   char const *pkgdatadir = (p = getenv ("BISON_PKGDATADIR")) ? p : PKGDATADIR;
   char const *p;
   char const *m4 = (p = getenv ("M4")) ? p : M4;
   char const *pkgdatadir = (p = getenv ("BISON_PKGDATADIR")) ? p : PKGDATADIR;
@@ -546,44 +529,42 @@ output_skeleton (void)
   size_t pkgdatadirlen = strlen (pkgdatadir);
   while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
     pkgdatadirlen--;
   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);
-  in = fopen (full_path, "r");
-  if (! in || fclose (in) != 0)
-    error (EXIT_FAILURE, errno, "%s", full_path);
-  strcpy (full_path + pkgdatadirlen + 1, skeleton);
+  full_skeleton = xmalloc (pkgdatadirlen + 1
+                          + (skeleton_size < sizeof m4sugar
+                             ? sizeof m4sugar : skeleton_size));
+  strcpy (full_skeleton, pkgdatadir);
+  full_skeleton[pkgdatadirlen] = '/';
+  strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
+  full_m4sugar = xstrdup (full_skeleton);
+  strcpy (full_skeleton + pkgdatadirlen + 1, "c.m4");
+  full_cm4 = xstrdup (full_skeleton);
+  strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
+  xfclose (xfopen (full_m4sugar, "r"));
 
   /* Create an m4 subprocess connected to us via two pipes.  */
 
   if (trace_flag & trace_tools)
 
   /* 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);
+    fprintf (stderr, "running: %s %s - %s %s\n",
+            m4, full_m4sugar, full_cm4, full_skeleton);
 
   argv[0] = m4;
 
   argv[0] = m4;
-  argv[1] = "-I";
-  argv[2] = pkgdatadir;
-  argv[3] = m4sugar;
-  argv[4] = "-";
-  argv[5] = full_path;
-  argv[6] = NULL;
+  argv[1] = full_m4sugar;
+  argv[2] = "-";
+  argv[3] = full_cm4;
+  argv[4] = full_skeleton;
+  argv[5] = NULL;
 
   init_subpipe ();
   pid = create_subpipe (argv, filter_fd);
 
   init_subpipe ();
   pid = create_subpipe (argv, filter_fd);
-  free (full_path);
+  free (full_m4sugar);
+  free (full_cm4);
+  free (full_skeleton);
 
   out = fdopen (filter_fd[0], "w");
   if (! out)
 
   out = fdopen (filter_fd[0], "w");
   if (! out)
-    error (EXIT_FAILURE, errno, "fdopen");
+    error (EXIT_FAILURE, get_errno (), "fdopen");
 
   /* Output the definitions of all the muscles.  */
 
   /* Output the definitions of all the muscles.  */
-
-  /* There are no comments, especially not `#': we do want M4 expansion
-     after `#': think of CPP macros!  */
-  fputs ("m4_changecom()\n", out);
   fputs ("m4_init()\n", out);
 
   user_actions_output (out);
   fputs ("m4_init()\n", out);
 
   user_actions_output (out);
@@ -596,18 +577,14 @@ output_skeleton (void)
 
   fputs ("m4_wrap([m4_divert_pop(0)])\n", out);
   fputs ("m4_divert_push(0)dnl\n", out);
 
   fputs ("m4_wrap([m4_divert_pop(0)])\n", out);
   fputs ("m4_divert_push(0)dnl\n", out);
-  if (ferror (out))
-    error (EXIT_FAILURE, 0, "pipe output error");
   xfclose (out);
 
   /* Read and process m4's output.  */
   timevar_push (TV_M4);
   in = fdopen (filter_fd[1], "r");
   if (! in)
   xfclose (out);
 
   /* Read and process m4's output.  */
   timevar_push (TV_M4);
   in = fdopen (filter_fd[1], "r");
   if (! in)
-    error (EXIT_FAILURE, errno, "fdopen");
+    error (EXIT_FAILURE, get_errno (), "fdopen");
   scan_skel (in);
   scan_skel (in);
-  if (ferror (in))
-    error (EXIT_FAILURE, 0, "pipe input error");
   xfclose (in);
   reap_subpipe (pid, m4);
   timevar_pop (TV_M4);
   xfclose (in);
   reap_subpipe (pid, m4);
   timevar_pop (TV_M4);
@@ -617,33 +594,15 @@ static void
 prepare (void)
 {
   /* Flags. */
 prepare (void)
 {
   /* Flags. */
-  MUSCLE_INSERT_INT ("locations_flag", locations_flag);
-  MUSCLE_INSERT_INT ("defines_flag", defines_flag);
-  MUSCLE_INSERT_INT ("error_verbose", error_verbose);
-  MUSCLE_INSERT_INT ("pure", pure_parser);
-  MUSCLE_INSERT_INT ("debug", debug_flag);
-
-  /* FIXME: This is wrong: the muscles should decide whether they hold
-     a copy or not, but the situation is too obscure currently.  */
+  MUSCLE_INSERT_BOOL ("debug", debug_flag);
+  MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
+  MUSCLE_INSERT_BOOL ("error_verbose", error_verbose);
+  MUSCLE_INSERT_BOOL ("locations_flag", locations_flag);
+  MUSCLE_INSERT_BOOL ("pure", pure_parser);
+  MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
+
+  /* File names.  */
   MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");
   MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");
-  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);
-
-  /* Symbols. */
-  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);
-
-  /* Rules. */
-  MUSCLE_INSERT_INT ("rules_number", nrules);
-
-  /* States. */
-  MUSCLE_INSERT_INT ("last", high);
-  MUSCLE_INSERT_INT ("final_state_number", final_state->number);
-  MUSCLE_INSERT_INT ("states_number", nstates);
 
   /* User Code.  */
   obstack_1grow (&pre_prologue_obstack, 0);
 
   /* User Code.  */
   obstack_1grow (&pre_prologue_obstack, 0);
@@ -654,14 +613,14 @@ prepare (void)
   /* Find the right skeleton file.  */
   if (!skeleton)
     {
   /* Find the right skeleton file.  */
   if (!skeleton)
     {
-      if (glr_parser)
+      if (glr_parser || nondeterministic_parser)
        skeleton = "glr.c";
       else
        skeleton = "yacc.c";
     }
 
   /* Parse the skeleton file and output the needed parsers.  */
        skeleton = "glr.c";
       else
        skeleton = "yacc.c";
     }
 
   /* Parse the skeleton file and output the needed parsers.  */
-  muscle_insert ("skeleton", xstrdup (skeleton));
+  MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
 }
 
 
 }
 
 
@@ -674,7 +633,7 @@ output (void)
 {
   obstack_init (&format_obstack);
 
 {
   obstack_init (&format_obstack);
 
-  prepare_tokens ();
+  prepare_symbols ();
   prepare_rules ();
   prepare_states ();
   prepare_actions ();
   prepare_rules ();
   prepare_states ();
   prepare_actions ();
bison