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 f7ea8182b9ccc55b46ecd95b457f1b0d88e1247b..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.


@@ -21,18 +22,22 @@
 
 
 #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 "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 *);


@@ -40,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;

 
 
 
 
 
 


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


@@ -86,25 +93,48 @@ 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.  |
+`----------------------------------------------------------------------*/
+
+static void
+escaped_file_name_output (FILE *out, char const *filename)
+{
+  char const *p;
+  fprintf (out, "[[");
+
+  for (p = quotearg_style (c_quoting_style, filename); *p; p++)
+    switch (*p)
+      {
+      case '$': fputs ("$][", out); break;
+      case '@': fputs ("@@",  out); break;
+      case '[': fputs ("@{",  out); break;
+      case ']': fputs ("@}",  out); break;
+      default: fputc (*p, out); break;
+      }
+
+  fprintf (out, "]]");
+}

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


@@ -128,31 +158,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 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);


@@ -162,7 +191,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,


@@ -174,25 +203,25 @@ prepare_symbols (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. */


@@ -205,23 +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 ("rules_number", nrules);

+  MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);

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


@@ -239,13 +270,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);


@@ -261,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)


@@ -269,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);
       }


@@ -294,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);


@@ -311,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);
 }


@@ -361,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);
 }


@@ -394,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);
 }


@@ -423,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);


@@ -463,7 +497,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


@@ -477,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.


@@ -485,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;


@@ -493,39 +529,40 @@ 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)
-    error (EXIT_FAILURE, errno, "%s", full_path);
-  xfclose (in);
-  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.  */
   fputs ("m4_init()\n", out);
 
   /* Output the definitions of all the muscles.  */
   fputs ("m4_init()\n", out);


@@ -546,7 +583,7 @@ output_skeleton (void)
   timevar_push (TV_M4);
   in = fdopen (filter_fd[1], "r");
   if (! in)
   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);
   xfclose (in);
   reap_subpipe (pid, m4);
   scan_skel (in);
   xfclose (in);
   reap_subpipe (pid, m4);


@@ -557,19 +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);

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


@@ -580,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_STRING ("skeleton", skeleton);
+  MUSCLE_INSERT_C_STRING ("skeleton", skeleton);

 }
 
 
 }