]> git.saurik.com Git - bison.git/blobdiff - src/reader.c
* tests/reduce.at (Useless Terminals, Useless Nonterminals): New.
[bison.git] / src / reader.c
index 3ef59350cfc8bcf229515d444a50a9085991c25f..ac160aed449b93d59814299a2e1eee7a009374f2 100644 (file)
@@ -1,5 +1,5 @@
 /* Input parser for bison
-   Copyright 1984, 1986, 1989, 1992, 1998, 2000
+   Copyright 1984, 1986, 1989, 1992, 1998, 2000, 2001
    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
 #include "system.h"
 #include "obstack.h"
+#include "quotearg.h"
+#include "quote.h"
 #include "getargs.h"
 #include "files.h"
-#include "xalloc.h"
 #include "symtab.h"
+#include "options.h"
 #include "lex.h"
 #include "gram.h"
 #include "complain.h"
 #include "output.h"
 #include "reader.h"
 #include "conflicts.h"
-#include "quote.h"
-
-/* Number of slots allocated (but not necessarily used yet) in `rline'  */
-static int rline_allocated;
+#include "muscle_tab.h"
 
 typedef struct symbol_list
 {
   struct symbol_list *next;
   bucket *sym;
+  int line;
   bucket *ruleprec;
 }
 symbol_list;
@@ -62,11 +62,21 @@ static int typed;
 /* 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;
+
+
+static symbol_list *
+symbol_list_new (bucket *sym)
+{
+  symbol_list *res = XMALLOC (symbol_list, 1);
+  res->next = NULL;
+  res->sym = sym;
+  res->line = lineno;
+  res->ruleprec = NULL;
+  return res;
+}
+
 \f
 
 /*===================\
@@ -124,7 +134,7 @@ read_signed_integer (FILE *stream)
 `--------------------------------------------------------------*/
 
 static char *
-get_type_name (int n, symbol_list * rule)
+get_type_name (int n, symbol_list *rule)
 {
   int i;
   symbol_list *rp;
@@ -152,19 +162,17 @@ get_type_name (int n, symbol_list * rule)
   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
-copy_string (FILE *fin, FILE *fout, struct obstack *oout, int match)
+copy_string2 (FILE *fin, struct obstack *oout, int match, int store)
 {
   int c;
 
-  if (fout)
-    putc (match, fout);
-  if (oout)
+  if (store)
     obstack_1grow (oout, match);
 
   c = getc (fin);
@@ -181,20 +189,14 @@ copy_string (FILE *fin, FILE *fout, struct obstack *oout, int match)
          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 (fout)
-           putc (c, fout);
-         if (oout)
-           obstack_1grow (oout, c);
+         obstack_1grow (oout, c);
 
          if (c == '\n')
            lineno++;
@@ -203,34 +205,48 @@ copy_string (FILE *fin, FILE *fout, struct obstack *oout, int match)
       c = getc (fin);
     }
 
-  if (fout)
-    putc (c, fout);
-  if (oout)
+  if (store)
     obstack_1grow (oout, c);
 }
 
+/* FIXME. */
 
-/*----------------------------------------------------------------.
-| 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.                                             |
-`----------------------------------------------------------------*/
+static inline void
+copy_string (FILE *fin, struct obstack *oout, int match)
+{
+  copy_string2 (fin, oout, match, 1);
+}
+
+/* FIXME. */
 
 static inline void
-copy_comment2 (FILE *fin, FILE *out1,
-              struct obstack *oout2, struct obstack *oout)
+copy_identifier (FILE *fin, struct obstack *oout)
+{
+  int c;
+
+  while (isalnum (c = getc (fin)) || c == '_')
+    obstack_1grow (oout, c);
+
+  ungetc (c, fin);
+}
+
+/*-----------------------------------------------------------------.
+| 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
+copy_comment2 (FILE *fin, struct obstack *oout1, struct obstack *oout2)
 {
   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, '/');
 
@@ -247,10 +263,7 @@ copy_comment2 (FILE *fin, FILE *out1,
       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);
@@ -262,10 +275,7 @@ copy_comment2 (FILE *fin, FILE *out1,
        {
          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);
@@ -273,10 +283,7 @@ copy_comment2 (FILE *fin, FILE *out1,
 
          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;
@@ -285,10 +292,7 @@ copy_comment2 (FILE *fin, FILE *out1,
       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)
@@ -300,10 +304,7 @@ copy_comment2 (FILE *fin, FILE *out1,
        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);
@@ -314,50 +315,42 @@ copy_comment2 (FILE *fin, FILE *out1,
 
 /*-------------------------------------------------------------------.
 | Dump the comment (actually the current string starting with a `/') |
-| from FIN to FOUT.                                                  |
+| from FIN to OOUT.                                                  |
 `-------------------------------------------------------------------*/
 
 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
-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 == '$')
     {
-      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 == '-')
     {
       int n;
-      char buf[4096];
 
       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
@@ -374,17 +367,17 @@ copy_at (FILE *fin, FILE *fout, struct obstack *oout, int stack_offset)
 |                                                                    |
 | 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
-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);
-  char *type_name = NULL;
+  const char *type_name = NULL;
 
   /* Get the type name if explicit. */
   if (c == '<')
@@ -397,20 +390,12 @@ copy_dollar (FILE *fin, FILE *fout, struct obstack *oout,
 
   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 (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);
@@ -424,18 +409,10 @@ copy_dollar (FILE *fin, FILE *fout, struct obstack *oout,
       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 (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);
@@ -460,8 +437,14 @@ copy_definition (void)
   /* -1 while reading a character if prev char was %. */
   int after_percent;
 
+#if 0
   if (!no_lines_flag)
-    obstack_fgrow2 (&attrs_obstack, "#line %d \"%s\"\n", lineno, infile);
+    {
+      obstack_fgrow2 (&attrs_obstack, muscle_find ("linef"),
+                     lineno, quotearg_style (c_quoting_style,
+                                             muscle_find("filename")));
+    }
+#endif
 
   after_percent = 0;
 
@@ -482,11 +465,11 @@ copy_definition (void)
 
        case '\'':
        case '"':
-         copy_string (finput, 0, &attrs_obstack, c);
+         copy_string (finput, &attrs_obstack, c);
          break;
 
        case '/':
-         copy_comment (finput, 0, &attrs_obstack);
+         copy_comment (finput, &attrs_obstack);
          break;
 
        case EOF:
@@ -518,8 +501,8 @@ copy_definition (void)
 static void
 parse_token_decl (symbol_class what_is, symbol_class what_is_not)
 {
-  int token = 0;
-  char *typename = 0;
+  token_t token = tok_undef;
+  char *typename = NULL;
 
   /* The symbol being defined.  */
   struct bucket *symbol = NULL;
@@ -538,18 +521,18 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
        fatal (_("Premature EOF after %s"), token_buffer);
 
       token = lex ();
-      if (token == COMMA)
+      if (token == tok_comma)
        {
          symbol = NULL;
          continue;
        }
-      if (token == TYPENAME)
+      if (token == tok_typename)
        {
          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"),
@@ -568,10 +551,9 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
              /* symbol and symval combined are only one symbol */
              nsyms--;
            }
-         translations = 1;
          symbol = NULL;
        }
-      else if (token == IDENTIFIER)
+      else if (token == tok_identifier)
        {
          int oldclass = symval->class;
          symbol = symval;
@@ -590,15 +572,15 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not)
                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;
        }
       else
        {
          complain (_("`%s' is invalid in %s"),
-                   token_buffer, (what_is == token_sym) ? "%token" : "%nterm");
+                   token_buffer,
+                   (what_is == token_sym) ? "%token" : "%nterm");
          skip_to_char ('%');
        }
     }
@@ -615,7 +597,7 @@ parse_start_decl (void)
 {
   if (start_flag)
     complain (_("multiple %s declarations"), "%start");
-  if (lex () != IDENTIFIER)
+  if (lex () != tok_identifier)
     complain (_("invalid %s declaration"), "%start");
   else
     {
@@ -634,7 +616,7 @@ parse_type_decl (void)
 {
   char *name;
 
-  if (lex () != TYPENAME)
+  if (lex () != tok_typename)
     {
       complain ("%s", _("%type declaration has no <typename>"));
       skip_to_char ('%');
@@ -645,7 +627,7 @@ parse_type_decl (void)
 
   for (;;)
     {
-      int t;
+      token_t t;
       int tmp_char = ungetc (skip_white_space (), finput);
 
       if (tmp_char == '%')
@@ -658,11 +640,11 @@ parse_type_decl (void)
       switch (t)
        {
 
-       case COMMA:
-       case SEMICOLON:
+       case tok_comma:
+       case tok_semicolon:
          break;
 
-       case IDENTIFIER:
+       case tok_identifier:
          if (symval->type_name == NULL)
            symval->type_name = name;
          else if (strcmp (name, symval->type_name) != 0)
@@ -695,7 +677,7 @@ parse_assoc_decl (associativity assoc)
 
   for (;;)
     {
-      int t;
+      token_t t;
       int tmp_char = ungetc (skip_white_space (), finput);
 
       if (tmp_char == '%')
@@ -707,14 +689,14 @@ parse_assoc_decl (associativity assoc)
 
       switch (t)
        {
-       case TYPENAME:
+       case tok_typename:
          name = xstrdup (token_buffer);
          break;
 
-       case COMMA:
+       case tok_comma:
          break;
 
-       case IDENTIFIER:
+       case tok_identifier:
          if (symval->prec != 0)
            complain (_("redefining precedence of %s"), symval->tag);
          symval->prec = lastprec;
@@ -731,11 +713,10 @@ parse_assoc_decl (associativity assoc)
            }
          break;
 
-       case NUMBER:
-         if (prev == IDENTIFIER)
+       case tok_number:
+         if (prev == tok_identifier)
            {
              symval->user_token_number = numval;
-             translations = 1;
            }
          else
            {
@@ -746,7 +727,7 @@ token_buffer);
            }
          break;
 
-       case SEMICOLON:
+       case tok_semicolon:
          return;
 
        default:
@@ -755,16 +736,15 @@ token_buffer);
        }
 
       prev = t;
-
     }
 }
 
 
 
 /*--------------------------------------------------------------.
-| Copy the union declaration into ATTRS_OBSTACK (and fdefines), |
-| where it is made into the definition of YYSTYPE, the type of  |
-| elements of the parser value stack.                           |
+| Copy the union declaration into the stype muscle             |
+| (and fdefines),  where it is made into the definition of     |
+| YYSTYPE, the type of elements of the parser value stack.     |
 `--------------------------------------------------------------*/
 
 static void
@@ -772,28 +752,43 @@ parse_union_decl (void)
 {
   int c;
   int count = 0;
+  struct obstack union_obstack;
+  const char *prologue = "\
+#ifndef YYSTYPE\n\
+typedef union";
+  const char *epilogue = "\
+ yystype;\n\
+# define YYSTYPE yystype\n\
+#endif\n";
 
   if (typed)
     complain (_("multiple %s declarations"), "%union");
 
   typed = 1;
 
-  if (!no_lines_flag)
-    obstack_fgrow2 (&attrs_obstack, "\n#line %d \"%s\"\n", lineno, infile);
-  else
+  /* FIXME: I'm worried: are you sure attrs_obstack is properly
+     filled?  */
+  /* I don't see any reasons to keep this line, because we should
+     create a special skeleton for this option.  */
+  if (no_lines_flag)
     obstack_1grow (&attrs_obstack, '\n');
 
-  obstack_grow_literal_string (&attrs_obstack, "typedef union");
+  obstack_init (&union_obstack);
+  obstack_sgrow (&union_obstack, "union");
   if (defines_flag)
-    obstack_grow_literal_string (&defines_obstack, "typedef union");
+    obstack_sgrow (&defines_obstack, prologue);
 
   c = getc (finput);
 
   while (c != EOF)
     {
-      obstack_1grow (&attrs_obstack, c);
-      if (defines_flag)
-       obstack_grow_literal_string (&defines_obstack, c);
+      /* If C contains '/', it is output by copy_comment ().  */
+      if (c != '/')
+       {
+         obstack_1grow (&union_obstack, c);
+         if (defines_flag)
+           obstack_1grow (&defines_obstack, c);
+       }
 
       switch (c)
        {
@@ -802,7 +797,7 @@ parse_union_decl (void)
          break;
 
        case '/':
-         copy_comment2 (finput, 0, &defines_obstack, &attrs_obstack);
+         copy_comment2 (finput, &defines_obstack, &union_obstack);
          break;
 
        case '{':
@@ -815,19 +810,21 @@ parse_union_decl (void)
          count--;
          if (count <= 0)
            {
-             obstack_grow_literal_string (&attrs_obstack, " YYSTYPE;\n");
              if (defines_flag)
-               obstack_grow_literal_string (&defines_obstack, " YYSTYPE;\n");
+               obstack_sgrow (&defines_obstack, epilogue);
              /* JF don't choke on trailing semi */
              c = skip_white_space ();
              if (c != ';')
                ungetc (c, finput);
+             obstack_1grow (&union_obstack, 0);
+             muscle_insert ("stype", obstack_finish (&union_obstack));
              return;
            }
        }
 
       c = getc (finput);
     }
+
 }
 
 
@@ -872,14 +869,13 @@ parse_expect_decl (void)
 static void
 parse_thong_decl (void)
 {
-  int token;
+  token_t token;
   struct bucket *symbol;
   char *typename = 0;
-  int usrtoknum;
+  int usrtoknum = SUNDEF;
 
-  translations = 1;
   token = lex ();              /* fetch typename or first token */
-  if (token == TYPENAME)
+  if (token == tok_typename)
     {
       typename = xstrdup (token_buffer);
       value_components_used = 1;
@@ -888,7 +884,7 @@ parse_thong_decl (void)
 
   /* process first token */
 
-  if (token != IDENTIFIER)
+  if (token != tok_identifier)
     {
       complain (_("unrecognized item %s, expected an identifier"),
                token_buffer);
@@ -902,17 +898,15 @@ parse_thong_decl (void)
 
   token = lex ();              /* get number or literal string */
 
-  if (token == NUMBER)
+  if (token == tok_number)
     {
       usrtoknum = numval;
       token = lex ();          /* okay, did number, now get literal */
     }
-  else
-    usrtoknum = 0;
 
   /* 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 ('%');
@@ -929,6 +923,66 @@ parse_thong_decl (void)
   nsyms--;
 }
 
+static void
+parse_muscle_decl (void)
+{
+  int ch = ungetc (skip_white_space (), finput);
+  char* muscle_key;
+  char* muscle_value;
+
+  /* Read key. */
+  if (!isalpha (ch) && ch != '_')
+    {
+      complain (_("invalid %s declaration"), "%define");
+      skip_to_char ('%');
+      return;
+    }
+  copy_identifier (finput, &muscle_obstack);
+  obstack_1grow (&muscle_obstack, 0);
+  muscle_key = obstack_finish (&muscle_obstack);
+
+  /* Read value. */
+  ch = skip_white_space ();
+  if (ch != '"')
+    {
+      ungetc (ch, finput);
+      if (ch != EOF)
+       {
+         complain (_("invalid %s declaration"), "%define");
+         skip_to_char ('%');
+         return;
+       }
+      else
+       fatal (_("Premature EOF after %s"), "\"");
+    }
+  copy_string2 (finput, &muscle_obstack, '"', 0);
+  obstack_1grow (&muscle_obstack, 0);
+  muscle_value = obstack_finish (&muscle_obstack);
+
+  /* Store the (key, value) pair in the environment. */
+  muscle_insert (muscle_key, muscle_value);
+}
+
+
+/*----------------------------------.
+| Parse what comes after %skeleton. |
+`----------------------------------*/
+
+void
+parse_skel_decl (void)
+{
+  /* Complete with parse_dquoted_param () on the CVS branch 1.29.  */
+}
+
+/*---------------------------------------.
+| Parse what comes after %skeleton_path. |
+`---------------------------------------*/
+
+void
+parse_include_decl (void)
+{
+  /* Complete with parse_dquoted_param () on the CVS branch 1.29.  */
+}
 
 /*----------------------------------------------------------------.
 | Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
@@ -939,80 +993,85 @@ parse_thong_decl (void)
 static void
 read_declarations (void)
 {
-  int c;
-  int tok;
-
   for (;;)
     {
-      c = skip_white_space ();
+      int c = skip_white_space ();
 
       if (c == '%')
        {
-         tok = parse_percent_token ();
+         token_t tok = parse_percent_token ();
 
          switch (tok)
            {
-           case TWO_PERCENTS:
+           case tok_two_percents:
              return;
 
-           case PERCENT_LEFT_CURLY:
+           case tok_percent_left_curly:
              copy_definition ();
              break;
 
-           case TOKEN:
+           case tok_token:
              parse_token_decl (token_sym, nterm_sym);
              break;
 
-           case NTERM:
+           case tok_nterm:
              parse_token_decl (nterm_sym, token_sym);
              break;
 
-           case TYPE:
+           case tok_type:
              parse_type_decl ();
              break;
 
-           case START:
+           case tok_start:
              parse_start_decl ();
              break;
 
-           case UNION:
+           case tok_union:
              parse_union_decl ();
              break;
 
-           case EXPECT:
+           case tok_expect:
              parse_expect_decl ();
              break;
-           case THONG:
+
+           case tok_thong:
              parse_thong_decl ();
              break;
 
-           case LEFT:
+           case tok_left:
              parse_assoc_decl (left_assoc);
              break;
 
-           case RIGHT:
+           case tok_right:
              parse_assoc_decl (right_assoc);
              break;
 
-           case NONASSOC:
+           case tok_nonassoc:
              parse_assoc_decl (non_assoc);
              break;
 
-           case SEMANTIC_PARSER:
-             if (semantic_parser == 0)
-               {
-                 semantic_parser = 1;
-                 open_extra_files ();
-               }
+           case tok_define:
+             parse_muscle_decl ();
+             break;
+
+           case tok_skel:
+             parse_skel_decl ();
              break;
 
-           case PURE_PARSER:
-             pure_parser = 1;
+           case tok_include:
+             parse_include_decl ();
+             break;
+             
+           case tok_noop:
              break;
 
-           case NOOP:
+           case tok_stropt:
+           case tok_intopt:
+           case tok_obsolete:
+             abort ();
              break;
 
+           case tok_illegal:
            default:
              complain (_("unrecognized: %s"), token_buffer);
              skip_to_char ('%');
@@ -1048,13 +1107,13 @@ copy_action (symbol_list *rule, int stack_offset)
   if (semantic_parser)
     stack_offset = 0;
 
-  sprintf (buf, "\ncase %d:\n", nrules);
-  obstack_grow (&action_obstack, buf, strlen (buf));
+  obstack_fgrow1 (&action_obstack, "\ncase %d:\n", nrules);
 
   if (!no_lines_flag)
     {
-      sprintf (buf, "#line %d \"%s\"\n", lineno, infile);
-      obstack_grow (&action_obstack, buf, strlen (buf));
+      obstack_fgrow2 (&action_obstack, muscle_find ("linef"),
+                     lineno, quotearg_style (c_quoting_style,
+                                             muscle_find ("filename")));
     }
   obstack_1grow (&action_obstack, '{');
 
@@ -1079,20 +1138,20 @@ copy_action (symbol_list *rule, int stack_offset)
 
            case '\'':
            case '"':
-             copy_string (finput, 0, &action_obstack, c);
+             copy_string (finput, &action_obstack, c);
              break;
 
            case '/':
-             copy_comment (finput, 0, &action_obstack);
+             copy_comment (finput, &action_obstack);
              break;
 
            case '$':
-             copy_dollar (finput, 0, &action_obstack,
+             copy_dollar (finput, &action_obstack,
                           rule, stack_offset);
              break;
 
            case '@':
-             copy_at (finput, 0, &action_obstack,
+             copy_at (finput, &action_obstack,
                       stack_offset);
              break;
 
@@ -1115,8 +1174,7 @@ copy_action (symbol_list *rule, int stack_offset)
        }
     }
 
-  obstack_grow_literal_string (&action_obstack,
-                              ";\n    break;}");
+  obstack_sgrow (&action_obstack, ";\n    break;}");
 }
 \f
 /*-------------------------------------------------------------------.
@@ -1139,10 +1197,12 @@ copy_guard (symbol_list *rule, int stack_offset)
   if (semantic_parser)
     stack_offset = 0;
 
-  fprintf (fguard, "\ncase %d:\n", nrules);
+  obstack_fgrow1 (&guard_obstack, "\ncase %d:\n", nrules);
   if (!no_lines_flag)
-    fprintf (fguard, "#line %d \"%s\"\n", lineno, infile);
-  putc ('{', fguard);
+    obstack_fgrow2 (&guard_obstack, muscle_find ("linef"),
+                   lineno, quotearg_style (c_quoting_style,
+                                           muscle_find ("filename")));
+  obstack_1grow (&guard_obstack, '{');
 
   count = 0;
   c = getc (finput);
@@ -1152,18 +1212,18 @@ copy_guard (symbol_list *rule, int stack_offset)
       switch (c)
        {
        case '\n':
-         putc (c, fguard);
+         obstack_1grow (&guard_obstack, c);
          lineno++;
          break;
 
        case '{':
-         putc (c, fguard);
+         obstack_1grow (&guard_obstack, c);
          brace_flag = 1;
          count++;
          break;
 
        case '}':
-         putc (c, fguard);
+         obstack_1grow (&guard_obstack, c);
          if (count > 0)
            count--;
          else
@@ -1175,26 +1235,26 @@ copy_guard (symbol_list *rule, int stack_offset)
 
        case '\'':
        case '"':
-         copy_string (finput, fguard, 0, c);
+         copy_string (finput, &guard_obstack, c);
          break;
 
        case '/':
-         copy_comment (finput, fguard, 0);
+         copy_comment (finput, &guard_obstack);
          break;
 
        case '$':
-         copy_dollar (finput, fguard, 0, rule, stack_offset);
+         copy_dollar (finput, &guard_obstack, rule, stack_offset);
          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:
-         putc (c, fguard);
+         obstack_1grow (&guard_obstack, c);
        }
 
       if (c != '}' || count != 0)
@@ -1203,7 +1263,7 @@ copy_guard (symbol_list *rule, int stack_offset)
 
   c = skip_white_space ();
 
-  fprintf (fguard, ";\n    break;}");
+  obstack_sgrow (&guard_obstack, ";\n    break;}");
   if (c == '{')
     copy_action (rule, stack_offset);
   else if (c == '=')
@@ -1217,20 +1277,6 @@ copy_guard (symbol_list *rule, int stack_offset)
 }
 \f
 
-static void
-record_rule_line (void)
-{
-  /* Record each rule's source line number in rline table.  */
-
-  if (nrules >= rline_allocated)
-    {
-      rline_allocated = nrules * 2;
-      rline = XREALLOC (rline, short, rline_allocated);
-    }
-  rline[nrules] = lineno;
-}
-
-
 /*-------------------------------------------------------------------.
 | Generate a dummy symbol, a nonterminal, whose name cannot conflict |
 | with the user's names.                                             |
@@ -1239,9 +1285,14 @@ record_rule_line (void)
 static bucket *
 gensym (void)
 {
+  /* Incremented for each generated symbol */
+  static int gensym_count = 0;
+  static char buf[256];
+
   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++;
@@ -1259,12 +1310,12 @@ static int
 get_type (void)
 {
   int k;
-  int t;
+  token_t token;
   char *name;
 
-  t = lex ();
+  token = lex ();
 
-  if (t != TYPENAME)
+  if (token != tok_typename)
     {
       complain (_("invalid %s declaration"), "%type");
       return t;
@@ -1274,17 +1325,17 @@ get_type (void)
 
   for (;;)
     {
-      t = lex ();
+      token = lex ();
 
-      switch (t)
+      switch (token)
        {
-       case SEMICOLON:
+       case tok_semicolon:
          return lex ();
 
-       case COMMA:
+       case tok_comma:
          break;
 
-       case IDENTIFIER:
+       case tok_identifier:
          if (symval->type_name == NULL)
            symval->type_name = name;
          else if (strcmp (name, symval->type_name) != 0)
@@ -1293,7 +1344,7 @@ get_type (void)
          break;
 
        default:
-         return t;
+         return token;
        }
     }
 }
@@ -1314,7 +1365,7 @@ get_type (void)
 static void
 readgram (void)
 {
-  int t;
+  token_t t;
   bucket *lhs = NULL;
   symbol_list *p;
   symbol_list *p1;
@@ -1330,9 +1381,9 @@ readgram (void)
 
   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 */
@@ -1340,7 +1391,7 @@ readgram (void)
          int xactions = 0;     /* JF for error checking */
          bucket *first_rhs = 0;
 
-         if (t == IDENTIFIER)
+         if (t == tok_identifier)
            {
              lhs = symval;
 
@@ -1351,14 +1402,14 @@ readgram (void)
                }
 
              t = lex ();
-             if (t != COLON)
+             if (t != tok_colon)
                {
                  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 */
@@ -1368,10 +1419,7 @@ readgram (void)
          nrules++;
          nitems++;
 
-         record_rule_line ();
-
-         p = XCALLOC (symbol_list, 1);
-         p->sym = lhs;
+         p = symbol_list_new (lhs);
 
          crule1 = p1;
          if (p1)
@@ -1398,28 +1446,28 @@ readgram (void)
          for (;;)
            {
              t = lex ();
-             if (t == PREC)
+             if (t == tok_prec)
                {
                  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.  */
-             if (t == IDENTIFIER)
+             if (t == tok_identifier)
                {
                  bucket *ssave;
-                 int t1;
+                 token_t t1;
 
                  ssave = symval;
                  t1 = lex ();
                  unlex (t1);
                  symval = ssave;
-                 if (t1 == COLON)
+                 if (t1 == tok_colon)
                    break;
 
                  if (!first_rhs)       /* JF */
@@ -1433,47 +1481,45 @@ readgram (void)
                 non-terminal.  */
              if (action_flag)
                {
-                 bucket *sdummy;
-
                  /* Since the action was written out with this rule's
                     number, we must give the new rule this number by
                     inserting the new rule before it.  */
 
                  /* Make a dummy nonterminal, a gensym.  */
-                 sdummy = gensym ();
+                 bucket *sdummy = gensym ();
 
-                 /* Make a new rule, whose body is empty,
-                    before the current one, so that the action
-                    just read can belong to it.  */
+                 /* Make a new rule, whose body is empty, before the
+                    current one, so that the action just read can
+                    belong to it.  */
                  nrules++;
                  nitems++;
-                 record_rule_line ();
-                 p = XCALLOC (symbol_list, 1);
+                 p = symbol_list_new (sdummy);
+                 /* Attach its lineno to that of the host rule. */
+                 p->line = crule->line;
                  if (crule1)
                    crule1->next = p;
                  else
                    grammar = p;
-                 p->sym = sdummy;
-                 crule1 = XCALLOC (symbol_list, 1);
-                 p->next = crule1;
+                 /* End of the rule. */
+                 crule1 = symbol_list_new (NULL);
                  crule1->next = crule;
 
+                 p->next = crule1;
+
                  /* Insert the dummy generated by that rule into this
                     rule.  */
                  nitems++;
-                 p = XCALLOC (symbol_list, 1);
-                 p->sym = sdummy;
+                 p = symbol_list_new (sdummy);
                  p1->next = p;
                  p1 = p;
 
                  action_flag = 0;
                }
 
-             if (t == IDENTIFIER)
+             if (t == tok_identifier)
                {
                  nitems++;
-                 p = XCALLOC (symbol_list, 1);
-                 p->sym = symval;
+                 p = symbol_list_new (symval);
                  p1->next = p;
                  p1 = p;
                }
@@ -1487,18 +1533,18 @@ readgram (void)
            }                   /* end of  read rhs of rule */
 
          /* Put an empty link in the list to mark the end of this rule  */
-         p = XCALLOC (symbol_list, 1);
+         p = symbol_list_new (NULL);
          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 ();
            }
-         if (t == GUARD)
+         if (t == tok_guard)
            {
              if (!semantic_parser)
                complain (_("%%guard present but %%semantic_parser not specified"));
@@ -1506,7 +1552,7 @@ readgram (void)
              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)
@@ -1531,7 +1577,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"));
-         if (t == SEMICOLON)
+         if (t == tok_semicolon)
            t = lex ();
        }
 #if 0
@@ -1541,31 +1587,31 @@ readgram (void)
        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 ();
        }
-      else if (t == NTERM)
+      else if (t == tok_nterm)
        {
          parse_token_decl (nterm_sym, token_sym);
          t = lex ();
        }
-      else if (t == TYPE)
+      else if (t == tok_type)
        {
          t = get_type ();
        }
-      else if (t == UNION)
+      else if (t == tok_union)
        {
          parse_union_decl ();
          t = lex ();
        }
-      else if (t == EXPECT)
+      else if (t == tok_expect)
        {
          parse_expect_decl ();
          t = lex ();
        }
-      else if (t == START)
+      else if (t == tok_start)
        {
          parse_start_decl ();
          t = lex ();
@@ -1574,7 +1620,7 @@ readgram (void)
 
       else
        {
-         complain (_("invalid input: %s"), token_buffer);
+         complain (_("invalid input: %s"), quote (token_buffer));
          t = lex ();
        }
     }
@@ -1587,22 +1633,6 @@ readgram (void)
   if (nrules == 0)
     fatal (_("no rules in the input grammar"));
 
-  /* JF put out same default YYSTYPE as YACC does */
-  if (typed == 0
-      && !value_components_used)
-    {
-      /* 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");
-      if (defines_flag)
-       obstack_grow_literal_string (&defines_obstack, "\
-#ifndef YYSTYPE\n\
-# define YYSTYPE int\n\
-#endif\n");
-    }
-
   /* Report any undefined symbols and consider them nonterminals.  */
 
   for (bp = firstsymbol; bp; bp = bp->next)
@@ -1617,6 +1647,25 @@ readgram (void)
 
   ntokens = nsyms - nvars;
 }
+
+/* At the end of the grammar file, some C source code must
+   be stored. It is going to be associated to the epilogue
+   directive.  */
+static void
+read_additionnal_code (void)
+{
+  char c;
+  struct obstack el_obstack;
+
+  obstack_init (&el_obstack);
+
+  while ((c = getc (finput)) != EOF)
+    obstack_1grow (&el_obstack, c);
+
+  obstack_1grow (&el_obstack, 0);
+  muscle_insert ("epilogue", obstack_finish (&el_obstack));
+}
+
 \f
 /*--------------------------------------------------------------.
 | For named tokens, but not literal ones, define the name.  The |
@@ -1657,15 +1706,53 @@ output_token_defines (struct obstack *oout)
       if (c != '\0')
        continue;
 
-      obstack_fgrow2 (oout, "#define\t%s\t%d\n",
-                     symbol,
-                     ((translations && !raw_flag)
-                      ? bp->user_token_number : bp->value));
+      obstack_fgrow2 (oout, "# define\t%s\t%d\n",
+                     symbol, bp->user_token_number);
       if (semantic_parser)
-       obstack_fgrow2 (oout, "#define\tT%s\t%d\n", symbol, bp->value);
+       /* FIXME: This is certainly dead wrong, and should be just as
+          above. --akim.  */
+       obstack_fgrow2 (oout, "# define\tT%s\t%d\n", symbol, bp->value);
     }
+}
+
+
+/*------------------------------------------------------------------.
+| Set TOKEN_TRANSLATIONS.  Check that no two symbols share the same |
+| number.                                                           |
+`------------------------------------------------------------------*/
 
-  obstack_1grow (oout, '\n');
+static void
+token_translations_init (void)
+{
+  bucket *bp = NULL;
+  int i;
+
+  token_translations = XCALLOC (short, max_user_token_number + 1);
+
+  /* Initialize all entries for literal tokens to 2, the internal
+     token number for $undefined., which represents all invalid
+     inputs.  */
+  for (i = 0; i <= max_user_token_number; i++)
+    token_translations[i] = 2;
+
+  for (bp = firstsymbol; bp; bp = bp->next)
+    {
+      /* Non-terminal? */
+      if (bp->value >= ntokens)
+       continue;
+      /* A token string alias? */
+      if (bp->user_token_number == SALIAS)
+       continue;
+
+      assert (bp->user_token_number != SUNDEF);
+
+      /* A token which translation has already been set? */
+      if (token_translations[bp->user_token_number] != 2)
+       complain (_("tokens %s and %s both assigned number %d"),
+                 tags[token_translations[bp->user_token_number]],
+                 bp->tag, bp->user_token_number);
+      token_translations[bp->user_token_number] = bp->value;
+    }
 }
 
 
@@ -1678,22 +1765,21 @@ output_token_defines (struct obstack *oout)
 static void
 packsymbols (void)
 {
-  bucket *bp;
+  bucket *bp = NULL;
   int tokno = 1;
-  int i;
   int last_user_token_number;
   static char DOLLAR[] = "$";
 
-  /* int lossage = 0; JF set but not used */
-
   tags = XCALLOC (char *, nsyms + 1);
-  tags[0] = DOLLAR;
   user_toknums = XCALLOC (short, nsyms + 1);
-  user_toknums[0] = 0;
 
   sprec = XCALLOC (short, nsyms);
   sassoc = XCALLOC (short, nsyms);
 
+  /* The EOF token. */
+  tags[0] = DOLLAR;
+  user_toknums[0] = 0;
+
   max_user_token_number = 256;
   last_user_token_number = 256;
 
@@ -1746,7 +1832,7 @@ packsymbols (void)
 
       if (bp->class == token_sym)
        {
-         if (translations && !(bp->user_token_number))
+         if (bp->user_token_number == SUNDEF)
            bp->user_token_number = ++last_user_token_number;
          if (bp->user_token_number > max_user_token_number)
            max_user_token_number = bp->user_token_number;
@@ -1756,46 +1842,41 @@ packsymbols (void)
       user_toknums[bp->value] = bp->user_token_number;
       sprec[bp->value] = bp->prec;
       sassoc[bp->value] = bp->assoc;
-
     }
 
-  if (translations)
-    {
-      int j;
-
-      token_translations = XCALLOC (short, max_user_token_number + 1);
-
-      /* initialize all entries for literal tokens to 2, the internal
-         token number for $undefined., which represents all invalid
-         inputs.  */
-      for (j = 0; j <= max_user_token_number; j++)
-       token_translations[j] = 2;
-
-      for (bp = firstsymbol; bp; bp = bp->next)
-       {
-         if (bp->value >= ntokens)
-           continue;           /* non-terminal */
-         if (bp->user_token_number == SALIAS)
-           continue;
-         if (token_translations[bp->user_token_number] != 2)
-           complain (_("tokens %s and %s both assigned number %d"),
-                     tags[token_translations[bp->user_token_number]],
-                     bp->tag, bp->user_token_number);
-         token_translations[bp->user_token_number] = bp->value;
-       }
-    }
+  token_translations_init ();
 
   error_token_number = errtoken->value;
 
-  if (!no_parser_flag)
-    output_token_defines (&table_obstack);
-
   if (startval->class == unknown_sym)
     fatal (_("the start symbol %s is undefined"), startval->tag);
   else if (startval->class == token_sym)
     fatal (_("the start symbol %s is a token"), startval->tag);
 
   start_symbol = startval->value;
+}
+
+
+/*-----------------------------------.
+| Output definition of token names.  |
+`-----------------------------------*/
+
+static void
+symbols_output (void)
+{
+  {
+    struct obstack tokendefs;
+    obstack_init (&tokendefs);
+    output_token_defines (&tokendefs);
+    obstack_1grow (&tokendefs, 0);
+    muscle_insert ("tokendef", xstrdup (obstack_finish (&tokendefs)));
+    obstack_free (&tokendefs, NULL);
+  }
+
+#if 0
+  if (!no_parser_flag)
+    output_token_defines (&table_obstack);
+#endif
 
   if (defines_flag)
     {
@@ -1807,24 +1888,28 @@ packsymbols (void)
            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)
-       for (i = ntokens; i < nsyms; i++)
-         {
-           /* don't make these for dummy nonterminals made by gensym.  */
-           if (*tags[i] != '@')
-              obstack_fgrow2 (&defines_obstack,
-                              "#define\tNT%s\t%d\n", tags[i], i);
-         }
+       {
+         int i;
+
+         for (i = ntokens; i < nsyms; i++)
+           {
+             /* don't make these for dummy nonterminals made by gensym.  */
+             if (*tags[i] != '@')
+               obstack_fgrow2 (&defines_obstack,
+                               "# define\tNT%s\t%d\n", tags[i], i);
+           }
 #if 0
-      /* `fdefines' is now a temporary file, so we need to copy its
-         contents in `done', so we can't close it here.  */
-      fclose (fdefines);
-      fdefines = NULL;
+         /* `fdefines' is now a temporary file, so we need to copy its
+            contents in `done', so we can't close it here.  */
+         fclose (fdefines);
+         fdefines = NULL;
 #endif
+       }
     }
 }
 
@@ -1841,14 +1926,8 @@ packgram (void)
   int ruleno;
   symbol_list *p;
 
-  bucket *ruleprec;
-
   ritem = XCALLOC (short, nitems + 1);
-  rlhs = XCALLOC (short, nrules) - 1;
-  rrhs = XCALLOC (short, nrules) - 1;
-  rprec = XCALLOC (short, nrules) - 1;
-  rprecsym = XCALLOC (short, nrules) - 1;
-  rassoc = XCALLOC (short, nrules) - 1;
+  rule_table = XCALLOC (rule_t, nrules) - 1;
 
   itemno = 0;
   ruleno = 1;
@@ -1856,9 +1935,10 @@ packgram (void)
   p = grammar;
   while (p)
     {
-      rlhs[ruleno] = p->sym->value;
-      rrhs[ruleno] = itemno;
-      ruleprec = p->ruleprec;
+      bucket *ruleprec = p->ruleprec;
+      rule_table[ruleno].lhs = p->sym->value;
+      rule_table[ruleno].rhs = itemno;
+      rule_table[ruleno].line = p->line;
 
       p = p->next;
       while (p && p->sym)
@@ -1868,8 +1948,8 @@ packgram (void)
             of the last token in it.  */
          if (p->sym->class == token_sym)
            {
-             rprec[ruleno] = p->sym->prec;
-             rassoc[ruleno] = p->sym->assoc;
+             rule_table[ruleno].prec = p->sym->prec;
+             rule_table[ruleno].assoc = p->sym->assoc;
            }
          if (p)
            p = p->next;
@@ -1879,9 +1959,9 @@ packgram (void)
          the specified symbol's precedence replaces the default.  */
       if (ruleprec)
        {
-         rprec[ruleno] = ruleprec->prec;
-         rassoc[ruleno] = ruleprec->assoc;
-         rprecsym[ruleno] = ruleprec->value;
+         rule_table[ruleno].prec = ruleprec->prec;
+         rule_table[ruleno].assoc = ruleprec->assoc;
+         rule_table[ruleno].precsym = ruleprec->value;
        }
 
       ritem[itemno++] = -ruleno;
@@ -1896,7 +1976,7 @@ packgram (void)
 \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.              |
@@ -1908,41 +1988,33 @@ reader (void)
   start_flag = 0;
   startval = NULL;             /* start symbol not specified yet. */
 
-#if 0
-  /* initially assume token number translation not needed.  */
-  translations = 0;
-#endif
-  /* Nowadays translations is always set to 1, since we give `error' a
-     user-token-number to satisfy the Posix demand for YYERRCODE==256.
-   */
-  translations = 1;
-
   nsyms = 1;
   nvars = 0;
   nrules = 0;
   nitems = 0;
-  rline_allocated = 10;
-  rline = XCALLOC (short, rline_allocated);
 
   typed = 0;
   lastprec = 0;
 
-  gensym_count = 0;
-
   semantic_parser = 0;
   pure_parser = 0;
 
   grammar = NULL;
 
-  init_lex ();
+  lex_init ();
   lineno = 1;
 
+  /* Initialize the muscle obstack.  */
+  obstack_init (&muscle_obstack);
+
   /* Initialize the symbol table.  */
   tabinit ();
+
   /* Construct the error token */
   errtoken = getsym ("error");
   errtoken->class = token_sym;
   errtoken->user_token_number = 256;   /* Value specified by POSIX.  */
+
   /* Construct a token that represents all undefined literal tokens.
      It is always token number 2.  */
   undeftoken = getsym ("$undefined.");
@@ -1952,60 +2024,23 @@ reader (void)
   /* Read the declaration section.  Copy %{ ... %} groups to
      TABLE_OBSTACK and FDEFINES file.  Also notice any %token, %left,
      etc. found there.  */
-  obstack_1grow (&table_obstack, '\n');
-  obstack_fgrow3 (&table_obstack, "\
-/* %s, made from %s\n\
-   by GNU bison %s.  */\n\
-\n",
-                 no_parser_flag ? "Bison-generated parse tables" : "A Bison parser",
-                 infile, VERSION);
-
-  obstack_grow_literal_string (&table_obstack,
-                      "#define YYBISON 1  /* Identify Bison output.  */\n\n");
   read_declarations ();
-  /* Start writing the guard and action files, if they are needed.  */
-  output_headers ();
   /* Read in the grammar, build grammar in list form.  Write out
      guards and actions.  */
   readgram ();
+  /* Some C code is given at the end of the grammar file. */
+  read_additionnal_code ();
+
   /* Now we know whether we need the line-number stack.  If we do,
-     write its type into the .tab.h file.  */
-  if (defines_flag)
-    reader_output_yylsp (&defines_obstack);
-  /* Write closing delimiters for actions and guards.  */
-  output_trailers ();
-  if (locations_flag)
-    obstack_grow_literal_string (&table_obstack, "#define YYLSP_NEEDED\n\n");
+     write its type into the .tab.h file.
+     This is no longer need with header skeleton.  */
+
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
   packsymbols ();
+  symbols_output ();
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();
-  /* Free the symbol table data structure since symbols are now all
-     referred to by symbol number.  */
-  free_symtab ();
-}
-
-
-void
-reader_output_yylsp (struct obstack *oout)
-{
-  if (locations_flag)
-    obstack_grow_literal_string (oout, "\
-\n\
-#ifndef YYLTYPE\n\
-typedef struct yyltype\n\
-{\n\
-  int timestamp;\n\
-  int first_line;\n\
-  int first_column;\
-\n\
-  int last_line;\n\
-  int last_column;\n\
-  char *text;\n\
-} yyltype;\n\
-\n\
-# define YYLTYPE yyltype\n\
-#endif\n\
-\n");
+  /* Output the headers. */
+  symbols_output ();
 }