* src/parse-gram.y (grammar_declaration): Location of printer

[bison.git] / src / output.c

diff --git a/src/output.c b/src/output.c
index da0d78525921b66fc73819d7cfce265fbb28e9f7..07978ed9610b4d21e00d5a32f4fc49478b2915a6 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -1,6 +1,7 @@
 /* Output the generated parsing program for Bison.
 /* Output the generated parsing program for Bison.

-   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
-   Free Software Foundation, Inc.
+
+   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004,
+   2005, 2006 Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -16,31 +17,33 @@
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to the Free
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to the Free

-   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.  */
-
+   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.  */

 
 

+#include <config.h>

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

-#include "quotearg.h"
-#include "error.h"
-#include "subpipe.h"
-#include "getargs.h"
+
+#include <error.h>
+#include <get-errno.h>
+#include <quotearg.h>
+#include <subpipe.h>
+#include <timevar.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 "output.h"
 #include "reader.h"

+#include "scan-skel.h"

 #include "symtab.h"
 #include "tables.h"
 #include "symtab.h"
 #include "tables.h"

-#include "muscle_tab.h"
-
-/* From src/scan-skel.l. */
-void scan_skel (FILE *);

 
 
 static struct obstack format_obstack;
 
 
 
 static struct obstack format_obstack;
 

-int error_verbose = 0;
+bool error_verbose = false;

 
 
 
 
 
 


@@ -55,7 +58,7 @@ int error_verbose = 0;
 #define GENERATE_MUSCLE_INSERT_TABLE(Name, Type)                       \
                                                                        \
 static void                                                            \
 #define GENERATE_MUSCLE_INSERT_TABLE(Name, Type)                       \
                                                                        \
 static void                                                            \

-Name (const char *name,                                                        \
+Name (char const *name,                                                        \

       Type *table_data,                                                        \
       Type first,                                                      \
       int begin,                                                       \
       Type *table_data,                                                        \
       Type first,                                                      \
       int begin,                                                       \


@@ -63,6 +66,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;                                                           \
                                                                        \


@@ -86,38 +91,37 @@ 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)

 
 
 
 

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

 
 static void
 
 static void

-escaped_file_name_output (FILE *out, char const *filename)
+escaped_output (FILE *out, char const *string)

 {
   char const *p;
   fprintf (out, "[[");
 
 {
   char const *p;
   fprintf (out, "[[");
 

-  for (p = quotearg_style (c_quoting_style, filename); *p; p++)
+  for (p = quotearg_style (c_quoting_style, string); *p; p++)

     switch (*p)
       {
       case '$': fputs ("$][", out); break;
     switch (*p)
       {
       case '$': fputs ("$][", out); break;


@@ -139,6 +143,7 @@ escaped_file_name_output (FILE *out, char const *filename)
 static void
 prepare_symbols (void)
 {
 static void
 prepare_symbols (void)
 {

+  MUSCLE_INSERT_BOOL ("token_table", token_table_flag);

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


@@ -152,31 +157,30 @@ prepare_symbols (void)
   /* tname -- token names.  */
   {
     int i;
   /* tname -- token names.  */
   {
     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 comma
-          and the space.  */
-       int strsize = strlen (cp) + 2;
-
-       if (j + strsize > 75)
+       char const *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;

          }
 
          }
 

+       if (i)
+         obstack_1grow (&format_obstack, ' ');

        MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
        MUSCLE_OBSTACK_SGROW (&format_obstack, cp);

-       obstack_sgrow (&format_obstack, ", ");
-       j += strsize;
+       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);


@@ -186,7 +190,7 @@ prepare_symbols (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,


@@ -204,19 +208,19 @@ prepare_symbols (void)
 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. */


@@ -229,24 +233,24 @@ 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;
     }
       /* Dynamic precedence (GLR).  */
       dprec[r] = rules[r].dprec;
       /* Merger-function index (GLR).  */
       merger[r] = rules[r].merger;
     }

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

 
   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 ("rules_number", nrules);

+  MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);

 
   free (rhs);
   free (prhs);
 
   free (rhs);
   free (prhs);


@@ -264,13 +268,13 @@ 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 ("last", high);
   MUSCLE_INSERT_INT ("final_state_number", final_state->number);


@@ -286,7 +290,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)


@@ -294,9 +298,9 @@ user_actions_output (FILE *out)
       {
        fprintf (out, "  case %d:\n", r + 1);
 
       {
        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, "]b4_syncline(%d, ",
+                rules[r].action_location.start.line);
+       escaped_output (out, rules[r].action_location.start.file);

        fprintf (out, ")[\n");
        fprintf (out, "    %s\n    break;\n\n",
                 rules[r].action);
        fprintf (out, ")[\n");
        fprintf (out, "    %s\n    break;\n\n",
                 rules[r].action);


@@ -318,10 +322,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);


@@ -335,44 +339,42 @@ 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.  */

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

 
       /* 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;
 
        continue;
 

-      fprintf (out, "%s[[[%s]], [%d]]",
-              first ? "" : ",\n", symbol->tag, number);
-
-      first = 0;
+      fprintf (out, "%s[[[%s]], %d]",
+              sep, sym->tag, number);
+      sep = ",\n";

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


@@ -386,28 +388,26 @@ 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[",
-                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;
+          destructor, optional typename.  */
+       fprintf (out, "%s[", sep);
+       sep = ",\n";
+       escaped_output (out, sym->destructor_location.start.file);
+       fprintf (out, ", %d, ", sym->destructor_location.start.line);
+       escaped_output (out, sym->tag);
+       fprintf (out, ", %d, [[%s]]", sym->number, sym->destructor);
+       if (sym->type_name)
+         fprintf (out, ", [[%s]]", sym->type_name);
+       fputc (']', out);

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


@@ -421,28 +421,26 @@ 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[",
-                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;
+          printer, optional typename.  */
+       fprintf (out, "%s[", sep);
+       sep = ",\n";
+       escaped_output (out, sym->printer_location.start.file);
+       fprintf (out, ", %d, ", sym->printer_location.start.line);
+       escaped_output (out, sym->tag);
+       fprintf (out, ", %d, [[%s]]", sym->number, sym->printer);
+       if (sym->type_name)
+         fprintf (out, ", [[%s]]", sym->type_name);
+       fputc (']', out);

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


@@ -452,7 +450,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);


@@ -492,7 +490,7 @@ prepare_actions (void)
   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,
   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);
+                                   0, 1, conflict_list_cnt);

 }
 
 \f
 }
 
 \f


@@ -506,7 +504,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[5];

   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.


@@ -514,7 +512,8 @@ 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_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;


@@ -522,36 +521,37 @@ 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);
-  xfclose (xfopen (full_path, "r"));
-  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, 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\n",
+            m4, full_m4sugar, 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_skeleton;
+  argv[4] = 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_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.  */
   fputs ("m4_init()\n", out);
 
   /* Output the definitions of all the muscles.  */
   fputs ("m4_init()\n", out);


@@ -570,9 +570,11 @@ output_skeleton (void)
 
   /* Read and process m4's output.  */
   timevar_push (TV_M4);
 
   /* Read and process m4's output.  */
   timevar_push (TV_M4);

+  end_of_output_subpipe (pid, filter_fd);

   in = fdopen (filter_fd[1], "r");
   if (! in)
   in = fdopen (filter_fd[1], "r");
   if (! in)

-    error (EXIT_FAILURE, errno, "fdopen");
+    error (EXIT_FAILURE, get_errno (),
+          "fdopen");

   scan_skel (in);
   xfclose (in);
   reap_subpipe (pid, m4);
   scan_skel (in);
   xfclose (in);
   reap_subpipe (pid, m4);


@@ -583,15 +585,25 @@ static void
 prepare (void)
 {
   /* Flags. */
 prepare (void)
 {
   /* Flags. */

-  MUSCLE_INSERT_INT ("debug", debug_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);
+  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");
 
   /* File names.  */
   MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");

+#define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
+  DEFINE (dir_prefix);
+  DEFINE (parser_file_name);
+  DEFINE (spec_defines_file);
+  DEFINE (spec_file_prefix);
+  DEFINE (spec_graph_file);
+  DEFINE (spec_name_prefix);
+  DEFINE (spec_outfile);
+  DEFINE (spec_verbose_file);
+#undef DEFINE

 
   /* User Code.  */
   obstack_1grow (&pre_prologue_obstack, 0);
 
   /* User Code.  */
   obstack_1grow (&pre_prologue_obstack, 0);


@@ -602,14 +614,18 @@ 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";
     }
 
        skeleton = "glr.c";
       else
        skeleton = "yacc.c";
     }
 

-  /* Parse the skeleton file and output the needed parsers.  */
-  MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
+  /* About the skeletons. */
+  {
+    char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
+    MUSCLE_INSERT_STRING ("pkgdatadir", pkgdatadir ? pkgdatadir : PKGDATADIR);
+    MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
+  }

 }
 
 
 }