* src/reader.c (gensym): `gensym_count' is your own.

[bison.git] / src / reader.c

diff --git a/src/reader.c b/src/reader.c
index cc24af65904feb5b8755b6dfbde63ddc7510837e..fdd483aef6cf9ef2c0d18d8906134bca930402e5 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -63,9 +63,6 @@ static int typed;
 /* Incremented for each %left, %right or %nonassoc seen */
 static int lastprec;
 
 /* Incremented for each %left, %right or %nonassoc seen */
 static int lastprec;
 

-/* Incremented for each generated symbol */
-static int gensym_count;
-

 static bucket *errtoken;
 static bucket *undeftoken;
 \f
 static bucket *errtoken;
 static bucket *undeftoken;
 \f


@@ -153,20 +150,17 @@ get_type_name (int n, symbol_list * rule)
   return rp->sym->type_name;
 }
 \f
   return rp->sym->type_name;
 }
 \f

-/*-----------------------------------------------------------------.
-| Dump the string from FIN to FOUT and OOUT if non null.  MATCH is |
-| the delimiter of the string (either ' or ").                     |
-`-----------------------------------------------------------------*/
+/*------------------------------------------------------------.
+| Dump the string from FIN to OOUT if non null.  MATCH is the |
+| delimiter of the string (either ' or ").                    |
+`------------------------------------------------------------*/

 
 static inline void
 
 static inline void

-copy_string (FILE *fin, FILE *fout, struct obstack *oout, int match)
+copy_string (FILE *fin, struct obstack *oout, int match)

 {
   int c;
 
 {
   int c;
 

-  if (fout)
-    putc (match, fout);
-  if (oout)
-    obstack_1grow (oout, match);
+  obstack_1grow (oout, match);

 
   c = getc (fin);
 
 
   c = getc (fin);
 


@@ -182,20 +176,14 @@ copy_string (FILE *fin, FILE *fout, struct obstack *oout, int match)
          continue;
        }
 
          continue;
        }
 

-      if (fout)
-       putc (c, fout);
-      if (oout)
-       obstack_1grow (oout, c);
+      obstack_1grow (oout, c);

 
       if (c == '\\')
        {
          c = getc (fin);
          if (c == EOF)
            fatal (_("unterminated string at end of file"));
 
       if (c == '\\')
        {
          c = getc (fin);
          if (c == EOF)
            fatal (_("unterminated string at end of file"));

-         if (fout)
-           putc (c, fout);
-         if (oout)
-           obstack_1grow (oout, c);
+         obstack_1grow (oout, c);

 
          if (c == '\n')
            lineno++;
 
          if (c == '\n')
            lineno++;


@@ -204,34 +192,27 @@ copy_string (FILE *fin, FILE *fout, struct obstack *oout, int match)
       c = getc (fin);
     }
 
       c = getc (fin);
     }
 

-  if (fout)
-    putc (c, fout);
-  if (oout)
-    obstack_1grow (oout, c);
+  obstack_1grow (oout, c);

 }
 
 
 }
 
 

-/*----------------------------------------------------------------.
-| Dump the wannabee comment from IN to OUT1 and OUT2.  In fact we |
-| just saw a `/', which might or might not be a comment.  In any  |
-| case, copy what we saw.                                         |
-|                                                                 |
-| OUT2 might be NULL.                                             |
-`----------------------------------------------------------------*/
+/*-----------------------------------------------------------------.
+| Dump the wannabee comment from IN to OUT1 and OUT2 (which can be |
+| NULL).  In fact we just saw a `/', which might or might not be a |
+| comment.  In any case, copy what we saw.                         |
+|                                                                  |
+| OUT2 might be NULL.                                              |
+`-----------------------------------------------------------------*/

 
 static inline void
 
 static inline void

-copy_comment2 (FILE *fin, FILE *out1,
-              struct obstack *oout2, struct obstack *oout)
+copy_comment2 (FILE *fin, struct obstack *oout1, struct obstack *oout2)

 {
   int cplus_comment;
   int ended;
   int c;
 
   /* We read a `/', output it. */
 {
   int cplus_comment;
   int ended;
   int c;
 
   /* We read a `/', output it. */

-  if (out1)
-    putc ('/', out1);
-  if (oout)
-    obstack_1grow (oout, '/');
+  obstack_1grow (oout1, '/');

   if (oout2)
     obstack_1grow (oout2, '/');
 
   if (oout2)
     obstack_1grow (oout2, '/');
 


@@ -248,10 +229,7 @@ copy_comment2 (FILE *fin, FILE *out1,
       return;
     }
 
       return;
     }
 

-  if (out1)
-    putc (c, out1);
-  if (oout)
-    obstack_1grow (oout, c);
+  obstack_1grow (oout1, c);

   if (oout2)
     obstack_1grow (oout2, c);
   c = getc (fin);
   if (oout2)
     obstack_1grow (oout2, c);
   c = getc (fin);


@@ -263,10 +241,7 @@ copy_comment2 (FILE *fin, FILE *out1,
        {
          while (c == '*')
            {
        {
          while (c == '*')
            {

-             if (out1)
-               putc (c, out1);
-             if (oout)
-               obstack_1grow (oout, c);
+             obstack_1grow (oout1, c);

              if (oout2)
                obstack_1grow (oout2, c);
              c = getc (fin);
              if (oout2)
                obstack_1grow (oout2, c);
              c = getc (fin);


@@ -274,10 +249,7 @@ copy_comment2 (FILE *fin, FILE *out1,
 
          if (c == '/')
            {
 
          if (c == '/')
            {

-             if (out1)
-               putc (c, out1);
-             if (oout)
-               obstack_1grow (oout, c);
+             obstack_1grow (oout1, c);

              if (oout2)
                obstack_1grow (oout2, c);
              ended = 1;
              if (oout2)
                obstack_1grow (oout2, c);
              ended = 1;


@@ -286,10 +258,7 @@ copy_comment2 (FILE *fin, FILE *out1,
       else if (c == '\n')
        {
          lineno++;
       else if (c == '\n')
        {
          lineno++;

-         if (out1)
-           putc (c, out1);
-         if (oout)
-           obstack_1grow (oout, c);
+         obstack_1grow (oout1, c);

          if (oout2)
            obstack_1grow (oout2, c);
          if (cplus_comment)
          if (oout2)
            obstack_1grow (oout2, c);
          if (cplus_comment)


@@ -301,10 +270,7 @@ copy_comment2 (FILE *fin, FILE *out1,
        fatal (_("unterminated comment"));
       else
        {
        fatal (_("unterminated comment"));
       else
        {

-         if (out1)
-           putc (c, out1);
-         if (oout)
-           obstack_1grow (oout, c);
+         obstack_1grow (oout1, c);

          if (oout2)
            obstack_1grow (oout2, c);
          c = getc (fin);
          if (oout2)
            obstack_1grow (oout2, c);
          c = getc (fin);


@@ -315,35 +281,32 @@ copy_comment2 (FILE *fin, FILE *out1,
 
 /*-------------------------------------------------------------------.
 | Dump the comment (actually the current string starting with a `/') |
 
 /*-------------------------------------------------------------------.
 | Dump the comment (actually the current string starting with a `/') |

-| from FIN to FOUT.                                                  |
+| from FIN to OOUT.                                                  |

 `-------------------------------------------------------------------*/
 
 static inline void
 `-------------------------------------------------------------------*/
 
 static inline void

-copy_comment (FILE *fin, FILE *fout, struct obstack *oout)
+copy_comment (FILE *fin, struct obstack *oout)

 {
 {

-  copy_comment2 (fin, fout, NULL, oout);
+  copy_comment2 (fin, oout, NULL);

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

-| FIN is pointing to a location (i.e., a `@').  Output to FOUT a   |
+| FIN is pointing to a location (i.e., a `@').  Output to OOUT a   |

 | reference to this location. STACK_OFFSET is the number of values |
 | in the current rule so far, which says where to find `$0' with   |
 | respect to the top of the stack.                                 |
 `-----------------------------------------------------------------*/
 
 static inline void
 | reference to this location. STACK_OFFSET is the number of values |
 | in the current rule so far, which says where to find `$0' with   |
 | respect to the top of the stack.                                 |
 `-----------------------------------------------------------------*/
 
 static inline void

-copy_at (FILE *fin, FILE *fout, struct obstack *oout, int stack_offset)
+copy_at (FILE *fin, struct obstack *oout, int stack_offset)

 {
   int c;
 
   c = getc (fin);
   if (c == '$')
     {
 {
   int c;
 
   c = getc (fin);
   if (c == '$')
     {

-      if (fout)
-       fprintf (fout, "yyloc");
-      if (oout)
-       obstack_grow_literal_string (oout, "yyloc");
+      obstack_sgrow (oout, "yyloc");

       locations_flag = 1;
     }
   else if (isdigit (c) || c == '-')
       locations_flag = 1;
     }
   else if (isdigit (c) || c == '-')


@@ -354,11 +317,7 @@ copy_at (FILE *fin, FILE *fout, struct obstack *oout, int stack_offset)
       ungetc (c, fin);
       n = read_signed_integer (fin);
 
       ungetc (c, fin);
       n = read_signed_integer (fin);
 

-      sprintf (buf, "yylsp[%d]", n - stack_offset);
-      if (fout)
-       fputs (buf, fout);
-      if (oout)
-       obstack_grow (oout, buf, strlen (buf));
+      obstack_fgrow1 (oout, "yylsp[%d]", n - stack_offset);

       locations_flag = 1;
     }
   else
       locations_flag = 1;
     }
   else


@@ -375,13 +334,13 @@ copy_at (FILE *fin, FILE *fout, struct obstack *oout, int stack_offset)
 |                                                                    |
 | Possible inputs: $[<TYPENAME>]($|integer)                          |
 |                                                                    |
 |                                                                    |
 | Possible inputs: $[<TYPENAME>]($|integer)                          |
 |                                                                    |

-| Output to FOUT a reference to this semantic value. STACK_OFFSET is |
+| Output to OOUT a reference to this semantic value. STACK_OFFSET is |

 | the number of values in the current rule so far, which says where  |
 | to find `$0' with respect to the top of the stack.                 |
 `-------------------------------------------------------------------*/
 
 static inline void
 | the number of values in the current rule so far, which says where  |
 | to find `$0' with respect to the top of the stack.                 |
 `-------------------------------------------------------------------*/
 
 static inline void

-copy_dollar (FILE *fin, FILE *fout, struct obstack *oout,
+copy_dollar (FILE *fin, struct obstack *oout,

             symbol_list *rule, int stack_offset)
 {
   int c = getc (fin);
             symbol_list *rule, int stack_offset)
 {
   int c = getc (fin);


@@ -398,20 +357,12 @@ copy_dollar (FILE *fin, FILE *fout, struct obstack *oout,
 
   if (c == '$')
     {
 
   if (c == '$')
     {

-      if (fout)
-       fputs ("yyval", fout);
-      if (oout)
-       obstack_grow_literal_string (oout, "yyval");
+      obstack_sgrow (oout, "yyval");

 
       if (!type_name)
        type_name = get_type_name (0, rule);
       if (type_name)
 
       if (!type_name)
        type_name = get_type_name (0, rule);
       if (type_name)

-       {
-         if (fout)
-           fprintf (fout, ".%s", type_name);
-         if (oout)
-           obstack_fgrow1 (oout, ".%s", type_name);
-       }
+       obstack_fgrow1 (oout, ".%s", type_name);

       if (!type_name && typed)
        complain (_("$$ of `%s' has no declared type"),
                  rule->sym->tag);
       if (!type_name && typed)
        complain (_("$$ of `%s' has no declared type"),
                  rule->sym->tag);


@@ -425,18 +376,10 @@ copy_dollar (FILE *fin, FILE *fout, struct obstack *oout,
       if (!type_name && n > 0)
        type_name = get_type_name (n, rule);
 
       if (!type_name && n > 0)
        type_name = get_type_name (n, rule);
 

-      if (fout)
-       fprintf (fout, "yyvsp[%d]", n - stack_offset);
-      if (oout)
-       obstack_fgrow1 (oout, "yyvsp[%d]", n - stack_offset);
+      obstack_fgrow1 (oout, "yyvsp[%d]", n - stack_offset);

 
       if (type_name)
 
       if (type_name)

-       {
-         if (fout)
-           fprintf (fout, ".%s", type_name);
-         if (oout)
-           obstack_fgrow1 (oout, ".%s", type_name);
-       }
+       obstack_fgrow1 (oout, ".%s", type_name);

       if (!type_name && typed)
        complain (_("$%d of `%s' has no declared type"),
                  n, rule->sym->tag);
       if (!type_name && typed)
        complain (_("$%d of `%s' has no declared type"),
                  n, rule->sym->tag);


@@ -484,11 +427,11 @@ copy_definition (void)
 
        case '\'':
        case '"':
 
        case '\'':
        case '"':

-         copy_string (finput, 0, &attrs_obstack, c);
+         copy_string (finput, &attrs_obstack, c);

          break;
 
        case '/':
          break;
 
        case '/':

-         copy_comment (finput, 0, &attrs_obstack);
+         copy_comment (finput, &attrs_obstack);

          break;
 
        case EOF:
          break;
 
        case EOF:


@@ -520,7 +463,7 @@ copy_definition (void)
 static void
 parse_token_decl (symbol_class what_is, symbol_class what_is_not)
 {
 static void
 parse_token_decl (symbol_class what_is, symbol_class what_is_not)
 {

-  int token = 0;
+  token_t token = 0;

   char *typename = 0;
 
   /* The symbol being defined.  */
   char *typename = 0;
 
   /* The symbol being defined.  */


@@ -540,18 +483,18 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
        fatal (_("Premature EOF after %s"), token_buffer);
 
       token = lex ();
        fatal (_("Premature EOF after %s"), token_buffer);
 
       token = lex ();

-      if (token == COMMA)
+      if (token == tok_comma)

        {
          symbol = NULL;
          continue;
        }
        {
          symbol = NULL;
          continue;
        }

-      if (token == TYPENAME)
+      if (token == tok_typename)

        {
          typename = xstrdup (token_buffer);
          value_components_used = 1;
          symbol = NULL;
        }
        {
          typename = xstrdup (token_buffer);
          value_components_used = 1;
          symbol = NULL;
        }

-      else if (token == IDENTIFIER && *symval->tag == '\"' && symbol)
+      else if (token == tok_identifier && *symval->tag == '\"' && symbol)

        {
          if (symval->alias)
            warn (_("symbol `%s' used more than once as a literal string"),
        {
          if (symval->alias)
            warn (_("symbol `%s' used more than once as a literal string"),


@@ -573,7 +516,7 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
          translations = 1;
          symbol = NULL;
        }
          translations = 1;
          symbol = NULL;
        }

-      else if (token == IDENTIFIER)
+      else if (token == tok_identifier)

        {
          int oldclass = symval->class;
          symbol = symval;
        {
          int oldclass = symval->class;
          symbol = symval;


@@ -592,7 +535,7 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
                complain (_("type redeclaration for %s"), symbol->tag);
            }
        }
                complain (_("type redeclaration for %s"), symbol->tag);
            }
        }

-      else if (symbol && token == NUMBER)
+      else if (symbol && token == tok_number)

        {
          symbol->user_token_number = numval;
          translations = 1;
        {
          symbol->user_token_number = numval;
          translations = 1;


@@ -617,7 +560,7 @@ parse_start_decl (void)
 {
   if (start_flag)
     complain (_("multiple %s declarations"), "%start");
 {
   if (start_flag)
     complain (_("multiple %s declarations"), "%start");

-  if (lex () != IDENTIFIER)
+  if (lex () != tok_identifier)

     complain (_("invalid %s declaration"), "%start");
   else
     {
     complain (_("invalid %s declaration"), "%start");
   else
     {


@@ -636,7 +579,7 @@ parse_type_decl (void)
 {
   char *name;
 
 {
   char *name;
 

-  if (lex () != TYPENAME)
+  if (lex () != tok_typename)

     {
       complain ("%s", _("%type declaration has no <typename>"));
       skip_to_char ('%');
     {
       complain ("%s", _("%type declaration has no <typename>"));
       skip_to_char ('%');


@@ -647,7 +590,7 @@ parse_type_decl (void)
 
   for (;;)
     {
 
   for (;;)
     {

-      int t;
+      token_t t;

       int tmp_char = ungetc (skip_white_space (), finput);
 
       if (tmp_char == '%')
       int tmp_char = ungetc (skip_white_space (), finput);
 
       if (tmp_char == '%')


@@ -660,11 +603,11 @@ parse_type_decl (void)
       switch (t)
        {
 
       switch (t)
        {
 

-       case COMMA:
-       case SEMICOLON:
+       case tok_comma:
+       case tok_semicolon:

          break;
 
          break;
 

-       case IDENTIFIER:
+       case tok_identifier:

          if (symval->type_name == NULL)
            symval->type_name = name;
          else if (strcmp (name, symval->type_name) != 0)
          if (symval->type_name == NULL)
            symval->type_name = name;
          else if (strcmp (name, symval->type_name) != 0)


@@ -697,7 +640,7 @@ parse_assoc_decl (associativity assoc)
 
   for (;;)
     {
 
   for (;;)
     {

-      int t;
+      token_t t;

       int tmp_char = ungetc (skip_white_space (), finput);
 
       if (tmp_char == '%')
       int tmp_char = ungetc (skip_white_space (), finput);
 
       if (tmp_char == '%')


@@ -709,14 +652,14 @@ parse_assoc_decl (associativity assoc)
 
       switch (t)
        {
 
       switch (t)
        {

-       case TYPENAME:
+       case tok_typename:

          name = xstrdup (token_buffer);
          break;
 
          name = xstrdup (token_buffer);
          break;
 

-       case COMMA:
+       case tok_comma:

          break;
 
          break;
 

-       case IDENTIFIER:
+       case tok_identifier:

          if (symval->prec != 0)
            complain (_("redefining precedence of %s"), symval->tag);
          symval->prec = lastprec;
          if (symval->prec != 0)
            complain (_("redefining precedence of %s"), symval->tag);
          symval->prec = lastprec;


@@ -733,8 +676,8 @@ parse_assoc_decl (associativity assoc)
            }
          break;
 
            }
          break;
 

-       case NUMBER:
-         if (prev == IDENTIFIER)
+       case tok_number:
+         if (prev == tok_identifier)

            {
              symval->user_token_number = numval;
              translations = 1;
            {
              symval->user_token_number = numval;
              translations = 1;


@@ -748,7 +691,7 @@ token_buffer);
            }
          break;
 
            }
          break;
 

-       case SEMICOLON:
+       case tok_semicolon:

          return;
 
        default:
          return;
 
        default:


@@ -786,9 +729,9 @@ parse_union_decl (void)
   else
     obstack_1grow (&attrs_obstack, '\n');
 
   else
     obstack_1grow (&attrs_obstack, '\n');
 

-  obstack_grow_literal_string (&attrs_obstack, "typedef union");
+  obstack_sgrow (&attrs_obstack, "typedef union");

   if (defines_flag)
   if (defines_flag)

-    obstack_grow_literal_string (&defines_obstack, "typedef union");
+    obstack_sgrow (&defines_obstack, "typedef union");

 
   c = getc (finput);
 
 
   c = getc (finput);
 


@@ -805,7 +748,7 @@ parse_union_decl (void)
          break;
 
        case '/':
          break;
 
        case '/':

-         copy_comment2 (finput, 0, &defines_obstack, &attrs_obstack);
+         copy_comment2 (finput, &defines_obstack, &attrs_obstack);

          break;
 
        case '{':
          break;
 
        case '{':


@@ -818,9 +761,9 @@ parse_union_decl (void)
          count--;
          if (count <= 0)
            {
          count--;
          if (count <= 0)
            {

-             obstack_grow_literal_string (&attrs_obstack, " YYSTYPE;\n");
+             obstack_sgrow (&attrs_obstack, " YYSTYPE;\n");

              if (defines_flag)
              if (defines_flag)

-               obstack_grow_literal_string (&defines_obstack, " YYSTYPE;\n");
+               obstack_sgrow (&defines_obstack, " YYSTYPE;\n");

              /* JF don't choke on trailing semi */
              c = skip_white_space ();
              if (c != ';')
              /* JF don't choke on trailing semi */
              c = skip_white_space ();
              if (c != ';')


@@ -875,14 +818,14 @@ parse_expect_decl (void)
 static void
 parse_thong_decl (void)
 {
 static void
 parse_thong_decl (void)
 {

-  int token;
+  token_t token;

   struct bucket *symbol;
   char *typename = 0;
   int usrtoknum;
 
   translations = 1;
   token = lex ();              /* fetch typename or first token */
   struct bucket *symbol;
   char *typename = 0;
   int usrtoknum;
 
   translations = 1;
   token = lex ();              /* fetch typename or first token */

-  if (token == TYPENAME)
+  if (token == tok_typename)

     {
       typename = xstrdup (token_buffer);
       value_components_used = 1;
     {
       typename = xstrdup (token_buffer);
       value_components_used = 1;


@@ -891,7 +834,7 @@ parse_thong_decl (void)
 
   /* process first token */
 
 
   /* process first token */
 

-  if (token != IDENTIFIER)
+  if (token != tok_identifier)

     {
       complain (_("unrecognized item %s, expected an identifier"),
                token_buffer);
     {
       complain (_("unrecognized item %s, expected an identifier"),
                token_buffer);


@@ -905,7 +848,7 @@ parse_thong_decl (void)
 
   token = lex ();              /* get number or literal string */
 
 
   token = lex ();              /* get number or literal string */
 

-  if (token == NUMBER)
+  if (token == tok_number)

     {
       usrtoknum = numval;
       token = lex ();          /* okay, did number, now get literal */
     {
       usrtoknum = numval;
       token = lex ();          /* okay, did number, now get literal */


@@ -915,7 +858,7 @@ parse_thong_decl (void)
 
   /* process literal string token */
 
 
   /* process literal string token */
 

-  if (token != IDENTIFIER || *symval->tag != '\"')
+  if (token != tok_identifier || *symval->tag != '\"')

     {
       complain (_("expected string constant instead of %s"), token_buffer);
       skip_to_char ('%');
     {
       complain (_("expected string constant instead of %s"), token_buffer);
       skip_to_char ('%');


@@ -955,63 +898,54 @@ read_declarations (void)
 
          switch (tok)
            {
 
          switch (tok)
            {

-           case TWO_PERCENTS:
+           case tok_two_percents:

              return;
 
              return;
 

-           case PERCENT_LEFT_CURLY:
+           case tok_percent_left_curly:

              copy_definition ();
              break;
 
              copy_definition ();
              break;
 

-           case TOKEN:
+           case tok_token:

              parse_token_decl (token_sym, nterm_sym);
              break;
 
              parse_token_decl (token_sym, nterm_sym);
              break;
 

-           case NTERM:
+           case tok_nterm:

              parse_token_decl (nterm_sym, token_sym);
              break;
 
              parse_token_decl (nterm_sym, token_sym);
              break;
 

-           case TYPE:
+           case tok_type:

              parse_type_decl ();
              break;
 
              parse_type_decl ();
              break;
 

-           case START:
+           case tok_start:

              parse_start_decl ();
              break;
 
              parse_start_decl ();
              break;
 

-           case UNION:
+           case tok_union:

              parse_union_decl ();
              break;
 
              parse_union_decl ();
              break;
 

-           case EXPECT:
+           case tok_expect:

              parse_expect_decl ();
              break;
              parse_expect_decl ();
              break;

-           case THONG:
+
+           case tok_thong:

              parse_thong_decl ();
              break;
 
              parse_thong_decl ();
              break;
 

-           case LEFT:
+           case tok_left:

              parse_assoc_decl (left_assoc);
              break;
 
              parse_assoc_decl (left_assoc);
              break;
 

-           case RIGHT:
+           case tok_right:

              parse_assoc_decl (right_assoc);
              break;
 
              parse_assoc_decl (right_assoc);
              break;
 

-           case NONASSOC:
+           case tok_nonassoc:

              parse_assoc_decl (non_assoc);
              break;
 
              parse_assoc_decl (non_assoc);
              break;
 

-           case SEMANTIC_PARSER:
-             if (!semantic_parser)
-               fguard = xfopen (guardfile, "w");
-             semantic_parser = 1;
-             break;
-
-           case PURE_PARSER:
-             pure_parser = 1;
-             break;
-
-           case NOOP:
+           case tok_noop:

              break;
 
            default:
              break;
 
            default:


@@ -1081,20 +1015,20 @@ copy_action (symbol_list *rule, int stack_offset)
 
            case '\'':
            case '"':
 
            case '\'':
            case '"':

-             copy_string (finput, 0, &action_obstack, c);
+             copy_string (finput, &action_obstack, c);

              break;
 
            case '/':
              break;
 
            case '/':

-             copy_comment (finput, 0, &action_obstack);
+             copy_comment (finput, &action_obstack);

              break;
 
            case '$':
              break;
 
            case '$':

-             copy_dollar (finput, 0, &action_obstack,
+             copy_dollar (finput, &action_obstack,

                           rule, stack_offset);
              break;
 
            case '@':
                           rule, stack_offset);
              break;
 
            case '@':

-             copy_at (finput, 0, &action_obstack,
+             copy_at (finput, &action_obstack,

                       stack_offset);
              break;
 
                       stack_offset);
              break;
 


@@ -1117,8 +1051,7 @@ copy_action (symbol_list *rule, int stack_offset)
        }
     }
 
        }
     }
 

-  obstack_grow_literal_string (&action_obstack,
-                              ";\n    break;}");
+  obstack_sgrow (&action_obstack, ";\n    break;}");

 }
 \f
 /*-------------------------------------------------------------------.
 }
 \f
 /*-------------------------------------------------------------------.


@@ -1141,11 +1074,11 @@ copy_guard (symbol_list *rule, int stack_offset)
   if (semantic_parser)
     stack_offset = 0;
 
   if (semantic_parser)
     stack_offset = 0;
 

-  fprintf (fguard, "\ncase %d:\n", nrules);
+  obstack_fgrow1 (&guard_obstack, "\ncase %d:\n", nrules);

   if (!no_lines_flag)
   if (!no_lines_flag)

-    fprintf (fguard, "#line %d %s\n",
-            lineno, quotearg_style (c_quoting_style, infile));
-  putc ('{', fguard);
+    obstack_fgrow2 (&guard_obstack, "#line %d %s\n",
+                   lineno, quotearg_style (c_quoting_style, infile));
+  obstack_1grow (&guard_obstack, '{');

 
   count = 0;
   c = getc (finput);
 
   count = 0;
   c = getc (finput);


@@ -1155,18 +1088,18 @@ copy_guard (symbol_list *rule, int stack_offset)
       switch (c)
        {
        case '\n':
       switch (c)
        {
        case '\n':

-         putc (c, fguard);
+         obstack_1grow (&guard_obstack, c);

          lineno++;
          break;
 
        case '{':
          lineno++;
          break;
 
        case '{':

-         putc (c, fguard);
+         obstack_1grow (&guard_obstack, c);

          brace_flag = 1;
          count++;
          break;
 
        case '}':
          brace_flag = 1;
          count++;
          break;
 
        case '}':

-         putc (c, fguard);
+         obstack_1grow (&guard_obstack, c);

          if (count > 0)
            count--;
          else
          if (count > 0)
            count--;
          else


@@ -1178,26 +1111,26 @@ copy_guard (symbol_list *rule, int stack_offset)
 
        case '\'':
        case '"':
 
        case '\'':
        case '"':

-         copy_string (finput, fguard, 0, c);
+         copy_string (finput, &guard_obstack, c);

          break;
 
        case '/':
          break;
 
        case '/':

-         copy_comment (finput, fguard, 0);
+         copy_comment (finput, &guard_obstack);

          break;
 
        case '$':
          break;
 
        case '$':

-         copy_dollar (finput, fguard, 0, rule, stack_offset);
+         copy_dollar (finput, &guard_obstack, rule, stack_offset);

          break;
 
        case '@':
          break;
 
        case '@':

-         copy_at (finput, fguard, 0, stack_offset);
+         copy_at (finput, &guard_obstack, stack_offset);

          break;
 
        case EOF:
          fatal ("%s", _("unterminated %guard clause"));
 
        default:
          break;
 
        case EOF:
          fatal ("%s", _("unterminated %guard clause"));
 
        default:

-         putc (c, fguard);
+         obstack_1grow (&guard_obstack, c);

        }
 
       if (c != '}' || count != 0)
        }
 
       if (c != '}' || count != 0)


@@ -1206,7 +1139,7 @@ copy_guard (symbol_list *rule, int stack_offset)
 
   c = skip_white_space ();
 
 
   c = skip_white_space ();
 

-  fprintf (fguard, ";\n    break;}");
+  obstack_sgrow (&guard_obstack, ";\n    break;}");

   if (c == '{')
     copy_action (rule, stack_offset);
   else if (c == '=')
   if (c == '{')
     copy_action (rule, stack_offset);
   else if (c == '=')


@@ -1242,9 +1175,14 @@ record_rule_line (void)
 static bucket *
 gensym (void)
 {
 static bucket *
 gensym (void)
 {

+  /* Incremented for each generated symbol */
+  static int gensym_count = 0;
+  static char buf[256];
+

   bucket *sym;
 
   bucket *sym;
 

-  sprintf (token_buffer, "@%d", ++gensym_count);
+  sprintf (buf, "@%d", ++gensym_count);
+  token_buffer = buf;

   sym = getsym (token_buffer);
   sym->class = nterm_sym;
   sym->value = nvars++;
   sym = getsym (token_buffer);
   sym->class = nterm_sym;
   sym->value = nvars++;


@@ -1262,12 +1200,12 @@ static int
 get_type (void)
 {
   int k;
 get_type (void)
 {
   int k;

-  int t;
+  token_t token;

   char *name;
 
   char *name;
 

-  t = lex ();
+  token = lex ();

 
 

-  if (t != TYPENAME)
+  if (token != tok_typename)

     {
       complain (_("invalid %s declaration"), "%type");
       return t;
     {
       complain (_("invalid %s declaration"), "%type");
       return t;


@@ -1277,17 +1215,17 @@ get_type (void)
 
   for (;;)
     {
 
   for (;;)
     {

-      t = lex ();
+      token = lex ();

 
 

-      switch (t)
+      switch (token)

        {
        {

-       case SEMICOLON:
+       case tok_semicolon:

          return lex ();
 
          return lex ();
 

-       case COMMA:
+       case tok_comma:

          break;
 
          break;
 

-       case IDENTIFIER:
+       case tok_identifier:

          if (symval->type_name == NULL)
            symval->type_name = name;
          else if (strcmp (name, symval->type_name) != 0)
          if (symval->type_name == NULL)
            symval->type_name = name;
          else if (strcmp (name, symval->type_name) != 0)


@@ -1296,7 +1234,7 @@ get_type (void)
          break;
 
        default:
          break;
 
        default:

-         return t;
+         return token;

        }
     }
 }
        }
     }
 }


@@ -1317,7 +1255,7 @@ get_type (void)
 static void
 readgram (void)
 {
 static void
 readgram (void)
 {

-  int t;
+  token_t t;

   bucket *lhs = NULL;
   symbol_list *p;
   symbol_list *p1;
   bucket *lhs = NULL;
   symbol_list *p;
   symbol_list *p1;


@@ -1333,9 +1271,9 @@ readgram (void)
 
   t = lex ();
 
 
   t = lex ();
 

-  while (t != TWO_PERCENTS && t != ENDFILE)
+  while (t != tok_two_percents && t != tok_eof)

     {
     {

-      if (t == IDENTIFIER || t == BAR)
+      if (t == tok_identifier || t == tok_bar)

        {
          int action_flag = 0;
          /* Number of symbols in rhs of this rule so far */
        {
          int action_flag = 0;
          /* Number of symbols in rhs of this rule so far */


@@ -1343,7 +1281,7 @@ readgram (void)
          int xactions = 0;     /* JF for error checking */
          bucket *first_rhs = 0;
 
          int xactions = 0;     /* JF for error checking */
          bucket *first_rhs = 0;
 

-         if (t == IDENTIFIER)
+         if (t == tok_identifier)

            {
              lhs = symval;
 
            {
              lhs = symval;
 


@@ -1354,14 +1292,14 @@ readgram (void)
                }
 
              t = lex ();
                }
 
              t = lex ();

-             if (t != COLON)
+             if (t != tok_colon)

                {
                  complain (_("ill-formed rule: initial symbol not followed by colon"));
                  unlex (t);
                }
            }
 
                {
                  complain (_("ill-formed rule: initial symbol not followed by colon"));
                  unlex (t);
                }
            }
 

-         if (nrules == 0 && t == BAR)
+         if (nrules == 0 && t == tok_bar)

            {
              complain (_("grammar starts with vertical bar"));
              lhs = symval;     /* BOGUS: use a random symval */
            {
              complain (_("grammar starts with vertical bar"));
              lhs = symval;     /* BOGUS: use a random symval */


@@ -1401,28 +1339,28 @@ readgram (void)
          for (;;)
            {
              t = lex ();
          for (;;)
            {
              t = lex ();

-             if (t == PREC)
+             if (t == tok_prec)

                {
                  t = lex ();
                  crule->ruleprec = symval;
                  t = lex ();
                }
 
                {
                  t = lex ();
                  crule->ruleprec = symval;
                  t = lex ();
                }
 

-             if (!(t == IDENTIFIER || t == LEFT_CURLY))
+             if (!(t == tok_identifier || t == tok_left_curly))

                break;
 
              /* If next token is an identifier, see if a colon follows it.
                 If one does, exit this rule now.  */
                break;
 
              /* If next token is an identifier, see if a colon follows it.
                 If one does, exit this rule now.  */

-             if (t == IDENTIFIER)
+             if (t == tok_identifier)

                {
                  bucket *ssave;
                {
                  bucket *ssave;

-                 int t1;
+                 token_t t1;

 
                  ssave = symval;
                  t1 = lex ();
                  unlex (t1);
                  symval = ssave;
 
                  ssave = symval;
                  t1 = lex ();
                  unlex (t1);
                  symval = ssave;

-                 if (t1 == COLON)
+                 if (t1 == tok_colon)

                    break;
 
                  if (!first_rhs)       /* JF */
                    break;
 
                  if (!first_rhs)       /* JF */


@@ -1472,7 +1410,7 @@ readgram (void)
                  action_flag = 0;
                }
 
                  action_flag = 0;
                }
 

-             if (t == IDENTIFIER)
+             if (t == tok_identifier)

                {
                  nitems++;
                  p = XCALLOC (symbol_list, 1);
                {
                  nitems++;
                  p = XCALLOC (symbol_list, 1);


@@ -1494,14 +1432,14 @@ readgram (void)
          p1->next = p;
          p1 = p;
 
          p1->next = p;
          p1 = p;
 

-         if (t == PREC)
+         if (t == tok_prec)

            {
              complain (_("two @prec's in a row"));
              t = lex ();
              crule->ruleprec = symval;
              t = lex ();
            }
            {
              complain (_("two @prec's in a row"));
              t = lex ();
              crule->ruleprec = symval;
              t = lex ();
            }

-         if (t == GUARD)
+         if (t == tok_guard)

            {
              if (!semantic_parser)
                complain (_("%%guard present but %%semantic_parser not specified"));
            {
              if (!semantic_parser)
                complain (_("%%guard present but %%semantic_parser not specified"));


@@ -1509,7 +1447,7 @@ readgram (void)
              copy_guard (crule, rulelength);
              t = lex ();
            }
              copy_guard (crule, rulelength);
              t = lex ();
            }

-         else if (t == LEFT_CURLY)
+         else if (t == tok_left_curly)

            {
              /* This case never occurs -wjh */
              if (action_flag)
            {
              /* This case never occurs -wjh */
              if (action_flag)


@@ -1534,7 +1472,7 @@ readgram (void)
          /* Warn if there is no default for $$ but we need one.  */
          else if (!xactions && !first_rhs && lhs->type_name != 0)
            complain (_("empty rule for typed nonterminal, and no action"));
          /* Warn if there is no default for $$ but we need one.  */
          else if (!xactions && !first_rhs && lhs->type_name != 0)
            complain (_("empty rule for typed nonterminal, and no action"));

-         if (t == SEMICOLON)
+         if (t == tok_semicolon)

            t = lex ();
        }
 #if 0
            t = lex ();
        }
 #if 0


@@ -1544,31 +1482,31 @@ readgram (void)
        b) most of them scan forward until finding a next %
                thus they may swallow lots of intervening rules
 */
        b) most of them scan forward until finding a next %
                thus they may swallow lots of intervening rules
 */

-      else if (t == TOKEN)
+      else if (t == tok_token)

        {
          parse_token_decl (token_sym, nterm_sym);
          t = lex ();
        }
        {
          parse_token_decl (token_sym, nterm_sym);
          t = lex ();
        }

-      else if (t == NTERM)
+      else if (t == tok_nterm)

        {
          parse_token_decl (nterm_sym, token_sym);
          t = lex ();
        }
        {
          parse_token_decl (nterm_sym, token_sym);
          t = lex ();
        }

-      else if (t == TYPE)
+      else if (t == tok_type)

        {
          t = get_type ();
        }
        {
          t = get_type ();
        }

-      else if (t == UNION)
+      else if (t == tok_union)

        {
          parse_union_decl ();
          t = lex ();
        }
        {
          parse_union_decl ();
          t = lex ();
        }

-      else if (t == EXPECT)
+      else if (t == tok_expect)

        {
          parse_expect_decl ();
          t = lex ();
        }
        {
          parse_expect_decl ();
          t = lex ();
        }

-      else if (t == START)
+      else if (t == tok_start)

        {
          parse_start_decl ();
          t = lex ();
        {
          parse_start_decl ();
          t = lex ();


@@ -1597,10 +1535,10 @@ readgram (void)
       /* We used to use `unsigned long' as YYSTYPE on MSDOS,
          but it seems better to be consistent.
          Most programs should declare their own type anyway.  */
       /* We used to use `unsigned long' as YYSTYPE on MSDOS,
          but it seems better to be consistent.
          Most programs should declare their own type anyway.  */

-      obstack_grow_literal_string (&attrs_obstack,
-                           "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
+      obstack_sgrow (&attrs_obstack,
+                          "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");

       if (defines_flag)
       if (defines_flag)

-       obstack_grow_literal_string (&defines_obstack, "\
+       obstack_sgrow (&defines_obstack, "\

 #ifndef YYSTYPE\n\
 # define YYSTYPE int\n\
 #endif\n");
 #ifndef YYSTYPE\n\
 # define YYSTYPE int\n\
 #endif\n");


@@ -1810,8 +1748,8 @@ packsymbols (void)
            obstack_fgrow1 (&defines_obstack, "\nextern YYSTYPE %slval;\n",
                            spec_name_prefix);
          else
            obstack_fgrow1 (&defines_obstack, "\nextern YYSTYPE %slval;\n",
                            spec_name_prefix);
          else

-           obstack_grow_literal_string (&defines_obstack,
-                                        "\nextern YYSTYPE yylval;\n");
+           obstack_sgrow (&defines_obstack,
+                                "\nextern YYSTYPE yylval;\n");

        }
 
       if (semantic_parser)
        }
 
       if (semantic_parser)


@@ -1899,7 +1837,7 @@ packgram (void)
 \f
 /*-------------------------------------------------------------------.
 | Read in the grammar specification and record it in the format      |
 \f
 /*-------------------------------------------------------------------.
 | Read in the grammar specification and record it in the format      |

-| described in gram.h.  All guards are copied into the FGUARD file   |
+| described in gram.h.  All guards are copied into the GUARD_OBSTACK |

 | and all actions into ACTION_OBSTACK, in each case forming the body |
 | of a C function (YYGUARD or YYACTION) which contains a switch      |
 | statement to decide which guard or action to execute.              |
 | and all actions into ACTION_OBSTACK, in each case forming the body |
 | of a C function (YYGUARD or YYACTION) which contains a switch      |
 | statement to decide which guard or action to execute.              |


@@ -1930,8 +1868,6 @@ reader (void)
   typed = 0;
   lastprec = 0;
 
   typed = 0;
   lastprec = 0;
 

-  gensym_count = 0;
-

   semantic_parser = 0;
   pure_parser = 0;
 
   semantic_parser = 0;
   pure_parser = 0;
 


@@ -1963,7 +1899,7 @@ reader (void)
                  no_parser_flag ? "Bison-generated parse tables" : "A Bison parser",
                  infile, VERSION);
 
                  no_parser_flag ? "Bison-generated parse tables" : "A Bison parser",
                  infile, VERSION);
 

-  obstack_grow_literal_string (&table_obstack,
+  obstack_sgrow (&table_obstack,

                       "#define YYBISON 1  /* Identify Bison output.  */\n\n");
   read_declarations ();
   /* Start writing the guard and action files, if they are needed.  */
                       "#define YYBISON 1  /* Identify Bison output.  */\n\n");
   read_declarations ();
   /* Start writing the guard and action files, if they are needed.  */


@@ -1978,7 +1914,7 @@ reader (void)
   /* Write closing delimiters for actions and guards.  */
   output_trailers ();
   if (locations_flag)
   /* Write closing delimiters for actions and guards.  */
   output_trailers ();
   if (locations_flag)

-    obstack_grow_literal_string (&table_obstack, "#define YYLSP_NEEDED 1\n\n");
+    obstack_sgrow (&table_obstack, "#define YYLSP_NEEDED 1\n\n");

   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
   packsymbols ();
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
   packsymbols ();


@@ -1999,7 +1935,7 @@ void
 reader_output_yylsp (struct obstack *oout)
 {
   if (locations_flag)
 reader_output_yylsp (struct obstack *oout)
 {
   if (locations_flag)

-    obstack_grow_literal_string (oout, "\
+    obstack_sgrow (oout, "\

 \n\
 #ifndef YYLTYPE\n\
 typedef struct yyltype\n\
 \n\
 #ifndef YYLTYPE\n\
 typedef struct yyltype\n\