X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ff4423cc2856ccc63b0fc72430fdc095208e0b14..e7b8bef1b1fa6eae346c4a3ee00e897a4d6f9058:/src/reader.c

diff --git a/src/reader.c b/src/reader.c
index 4f62e759..bebbc153 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -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.
@@ -21,30 +21,35 @@
 
 
 #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"
-
-/* 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;
+
+  /* The action is attached to the LHS of a rule. */
+  const char *action;
+  int action_line;
+
+  /* The guard is attached to the LHS of a rule. */
+  const char *guard;
+  int guard_line;
   bucket *ruleprec;
-}
-symbol_list;
+} symbol_list;
 
 int lineno;
 char **tags;
@@ -63,11 +68,26 @@ 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 = NULL;
+static bucket *undeftoken = NULL;
+static bucket *eoftoken = NULL;
+static bucket *axiom = NULL;
+
+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->action = NULL;
+  res->action_line = 0;
+  res->guard = NULL;
+  res->guard_line = 0;
+  res->ruleprec = NULL;
+  return res;
+}
 
-static bucket *errtoken;
-static bucket *undeftoken;
 
 
 /*===================\
@@ -125,7 +145,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;
@@ -159,11 +179,12 @@ get_type_name (int n, symbol_list * rule)
 `------------------------------------------------------------*/
 
 static inline void
-copy_string (FILE *fin, struct obstack *oout, int match)
+copy_string2 (FILE *fin, struct obstack *oout, int match, int store)
 {
   int c;
 
-  obstack_1grow (oout, match);
+  if (store)
+    obstack_1grow (oout, match);
 
   c = getc (fin);
 
@@ -195,29 +216,47 @@ copy_string (FILE *fin, struct obstack *oout, int match)
       c = getc (fin);
     }
 
-  obstack_1grow (oout, c);
+  if (store)
+    obstack_1grow (oout, c);
 }
 
+/* FIXME. */
 
-/*-----------------------------------------------------------------.
-| 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_string (FILE *fin, struct obstack *oout, int match)
+{
+  copy_string2 (fin, oout, match, 1);
+}
+
+/* FIXME. */
+
+static inline void
+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 OOUT.  In fact we just saw a |
+| `/', which might or might not be a comment.  In any case, copy    |
+| what we saw.                                                      |
+`------------------------------------------------------------------*/
 
 static inline void
-copy_comment2 (FILE *fin, struct obstack *oout1, struct obstack *oout2)
+copy_comment (FILE *fin, struct obstack *oout)
 {
   int cplus_comment;
   int ended;
   int c;
 
   /* We read a `/', output it. */
-  obstack_1grow (oout1, '/');
-  if (oout2)
-    obstack_1grow (oout2, '/');
+  obstack_1grow (oout, '/');
 
   switch ((c = getc (fin)))
     {
@@ -232,9 +271,7 @@ copy_comment2 (FILE *fin, struct obstack *oout1, struct obstack *oout2)
       return;
     }
 
-  obstack_1grow (oout1, c);
-  if (oout2)
-    obstack_1grow (oout2, c);
+  obstack_1grow (oout, c);
   c = getc (fin);
 
   ended = 0;
@@ -244,26 +281,20 @@ copy_comment2 (FILE *fin, struct obstack *oout1, struct obstack *oout2)
 	{
 	  while (c == '*')
 	    {
-	      obstack_1grow (oout1, c);
-	      if (oout2)
-		obstack_1grow (oout2, c);
+	      obstack_1grow (oout, c);
 	      c = getc (fin);
 	    }
 
 	  if (c == '/')
 	    {
-	      obstack_1grow (oout1, c);
-	      if (oout2)
-		obstack_1grow (oout2, c);
+	      obstack_1grow (oout, c);
 	      ended = 1;
 	    }
 	}
       else if (c == '\n')
 	{
 	  lineno++;
-	  obstack_1grow (oout1, c);
-	  if (oout2)
-	    obstack_1grow (oout2, c);
+	  obstack_1grow (oout, c);
 	  if (cplus_comment)
 	    ended = 1;
 	  else
@@ -273,27 +304,13 @@ copy_comment2 (FILE *fin, struct obstack *oout1, struct obstack *oout2)
 	fatal (_("unterminated comment"));
       else
 	{
-	  obstack_1grow (oout1, c);
-	  if (oout2)
-	    obstack_1grow (oout2, c);
+	  obstack_1grow (oout, c);
 	  c = getc (fin);
 	}
     }
 }
 
 
-/*-------------------------------------------------------------------.
-| Dump the comment (actually the current string starting with a `/') |
-| from FIN to OOUT.                                                  |
-`-------------------------------------------------------------------*/
-
-static inline void
-copy_comment (FILE *fin, struct obstack *oout)
-{
-  copy_comment2 (fin, oout, NULL);
-}
-
-
 /*-----------------------------------------------------------------.
 | FIN is pointing to a location (i.e., a `@').  Output to OOUT a   |
 | reference to this location. STACK_OFFSET is the number of values |
@@ -315,13 +332,19 @@ copy_at (FILE *fin, struct obstack *oout, int stack_offset)
   else if (isdigit (c) || c == '-')
     {
       int n;
-      char buf[4096];
 
       ungetc (c, fin);
       n = read_signed_integer (fin);
-
-      obstack_fgrow1 (oout, "yylsp[%d]", n - stack_offset);
-      locations_flag = 1;
+      if (n > stack_offset)
+	complain (_("invalid value: %s%d"), "@", n);
+      else
+	{
+	  /* Offset is always 0 if parser has already popped the stack
+	     pointer.  */
+	  obstack_fgrow1 (oout, "yylsp[%d]",
+			  n - (semantic_parser ? 0 : stack_offset));
+	  locations_flag = 1;
+	}
     }
   else
     {
@@ -347,7 +370,7 @@ 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 == '<')
@@ -376,16 +399,24 @@ copy_dollar (FILE *fin, struct obstack *oout,
       ungetc (c, fin);
       n = read_signed_integer (fin);
 
-      if (!type_name && n > 0)
-	type_name = get_type_name (n, rule);
-
-      obstack_fgrow1 (oout, "yyvsp[%d]", n - stack_offset);
-
-      if (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 (n > stack_offset)
+	complain (_("invalid value: %s%d"), "$", n);
+      else
+	{
+	  if (!type_name && n > 0)
+	    type_name = get_type_name (n, rule);
+
+	  /* Offset is always 0 if parser has already popped the stack
+	     pointer.  */
+	  obstack_fgrow1 (oout, "yyvsp[%d]",
+			  n - (semantic_parser ? 0 : stack_offset));
+
+	  if (type_name)
+	    obstack_fgrow1 (oout, ".%s", type_name);
+	  if (!type_name && typed)
+	    complain (_("$%d of `%s' has no declared type"),
+		      n, rule->sym->tag);
+	}
     }
   else
     {
@@ -408,8 +439,11 @@ copy_definition (void)
   int after_percent;
 
   if (!no_lines_flag)
-    obstack_fgrow2 (&attrs_obstack, "#line %d %s\n",
-		    lineno, quotearg_style (c_quoting_style, infile));
+    {
+      obstack_fgrow2 (&attrs_obstack, muscle_find ("linef"),
+		      lineno, quotearg_style (c_quoting_style,
+					      muscle_find ("filename")));
+    }
 
   after_percent = 0;
 
@@ -466,8 +500,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;
@@ -486,18 +520,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"),
@@ -516,10 +550,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;
@@ -538,15 +571,18 @@ 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;
+	  /* User defined EOF token? */
+	  if (numval == 0)
+	    eoftoken = symbol;
 	}
       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 ('%');
 	}
     }
@@ -563,7 +599,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
     {
@@ -582,7 +618,7 @@ parse_type_decl (void)
 {
   char *name;
 
-  if (lex () != TYPENAME)
+  if (lex () != tok_typename)
     {
       complain ("%s", _("%type declaration has no <typename>"));
       skip_to_char ('%');
@@ -593,7 +629,7 @@ parse_type_decl (void)
 
   for (;;)
     {
-      int t;
+      token_t t;
       int tmp_char = ungetc (skip_white_space (), finput);
 
       if (tmp_char == '%')
@@ -606,11 +642,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)
@@ -643,7 +679,7 @@ parse_assoc_decl (associativity assoc)
 
   for (;;)
     {
-      int t;
+      token_t t;
       int tmp_char = ungetc (skip_white_space (), finput);
 
       if (tmp_char == '%')
@@ -655,14 +691,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;
@@ -679,11 +715,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
 	    {
@@ -694,7 +729,7 @@ token_buffer);
 	    }
 	  break;
 
-	case SEMICOLON:
+	case tok_semicolon:
 	  return;
 
 	default:
@@ -703,16 +738,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
@@ -720,29 +754,23 @@ parse_union_decl (void)
 {
   int c;
   int count = 0;
-
+  bool done = FALSE;
+  struct obstack union_obstack;
   if (typed)
     complain (_("multiple %s declarations"), "%union");
 
   typed = 1;
 
-  if (!no_lines_flag)
-    obstack_fgrow2 (&attrs_obstack, "\n#line %d %s\n",
-		    lineno, quotearg_style (c_quoting_style, infile));
-  else
-    obstack_1grow (&attrs_obstack, '\n');
-
-  obstack_sgrow (&attrs_obstack, "typedef union");
-  if (defines_flag)
-    obstack_sgrow (&defines_obstack, "typedef union");
-
-  c = getc (finput);
+  obstack_init (&union_obstack);
+  obstack_sgrow (&union_obstack, "union");
 
-  while (c != EOF)
+  while (!done)
     {
-      obstack_1grow (&attrs_obstack, c);
-      if (defines_flag)
-	obstack_1grow (&defines_obstack, c);
+      c = xgetc (finput);
+
+      /* If C contains '/', it is output by copy_comment ().  */
+      if (c != '/')
+	obstack_1grow (&union_obstack, c);
 
       switch (c)
 	{
@@ -751,7 +779,7 @@ parse_union_decl (void)
 	  break;
 
 	case '/':
-	  copy_comment2 (finput, &defines_obstack, &attrs_obstack);
+	  copy_comment (finput, &union_obstack);
 	  break;
 
 	case '{':
@@ -759,24 +787,22 @@ parse_union_decl (void)
 	  break;
 
 	case '}':
+	  /* FIXME: Errr.  How could this happen???. --akim */
 	  if (count == 0)
 	    complain (_("unmatched %s"), "`}'");
 	  count--;
-	  if (count <= 0)
-	    {
-	      obstack_sgrow (&attrs_obstack, " YYSTYPE;\n");
-	      if (defines_flag)
-		obstack_sgrow (&defines_obstack, " YYSTYPE;\n");
-	      /* JF don't choke on trailing semi */
-	      c = skip_white_space ();
-	      if (c != ';')
-		ungetc (c, finput);
-	      return;
-	    }
+	  if (!count)
+	    done = TRUE;
+	  break;
 	}
-
-      c = getc (finput);
     }
+
+  /* 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));
 }
 
 
@@ -821,14 +847,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;
@@ -837,7 +862,7 @@ parse_thong_decl (void)
 
   /* process first token */
 
-  if (token != IDENTIFIER)
+  if (token != tok_identifier)
     {
       complain (_("unrecognized item %s, expected an identifier"),
 		token_buffer);
@@ -851,17 +876,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 ('%');
@@ -879,6 +902,98 @@ parse_thong_decl (void)
 }
 
 
+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 a double quoted parameter. |
+`---------------------------------*/
+
+static const char *
+parse_dquoted_param (const char *from)
+{
+  struct obstack param_obstack;
+  const char *param = NULL;
+  int c;
+
+  obstack_init (&param_obstack);
+  c = skip_white_space ();
+
+  if (c != '"')
+    {
+      complain (_("invalid %s declaration"), from);
+      ungetc (c, finput);
+      skip_to_char ('%');
+      return NULL;
+    }
+
+  while ((c = literalchar ()) != '"')
+    obstack_1grow (&param_obstack, c);
+
+  obstack_1grow (&param_obstack, '\0');
+  param = obstack_finish (&param_obstack);
+
+  if (c != '"' || strlen (param) == 0)
+    {
+      complain (_("invalid %s declaration"), from);
+      if (c != '"')
+	ungetc (c, finput);
+      skip_to_char ('%');
+      return NULL;
+    }
+
+  return param;
+}
+
+/*----------------------------------.
+| Parse what comes after %skeleton. |
+`----------------------------------*/
+
+static void
+parse_skel_decl (void)
+{
+  skeleton = parse_dquoted_param ("%skeleton");
+}
+
 /*----------------------------------------------------------------.
 | Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
 | any `%' declarations, and copy the contents of any `%{ ... %}'  |
@@ -888,76 +1003,81 @@ 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:
-	      semantic_parser = 1;
+	    case tok_define:
+	      parse_muscle_decl ();
 	      break;
 
-	    case PURE_PARSER:
-	      pure_parser = 1;
+	    case tok_skel:
+	      parse_skel_decl ();
 	      break;
 
-	    case NOOP:
+	    case tok_noop:
 	      break;
 
+	    case tok_stropt:
+	    case tok_intopt:
+	    case tok_obsolete:
+	      abort ();
+	      break;
+
+	    case tok_illegal:
 	    default:
 	      complain (_("unrecognized: %s"), token_buffer);
 	      skip_to_char ('%');
@@ -980,80 +1100,61 @@ read_declarations (void)
 | matching `}' into the actions file.  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.                              |
+|                                                                    |
+| This routine is used both for actions and guards.  Only            |
+| ACTION_OBSTACK is used, but this is fine, since we use only        |
+| pointers to relevant portions inside this obstack.                 |
 `-------------------------------------------------------------------*/
 
 static void
-copy_action (symbol_list *rule, int stack_offset)
+parse_braces (symbol_list *rule, int stack_offset)
 {
   int c;
   int count;
-  char buf[4096];
-
-  /* offset is always 0 if parser has already popped the stack pointer */
-  if (semantic_parser)
-    stack_offset = 0;
-
-  sprintf (buf, "\ncase %d:\n", nrules);
-  obstack_grow (&action_obstack, buf, strlen (buf));
-
-  if (!no_lines_flag)
-    {
-      sprintf (buf, "#line %d %s\n",
-	       lineno, quotearg_style (c_quoting_style, infile));
-      obstack_grow (&action_obstack, buf, strlen (buf));
-    }
-  obstack_1grow (&action_obstack, '{');
 
   count = 1;
-  c = getc (finput);
-
   while (count > 0)
     {
-      while (c != '}')
-	{
-	  switch (c)
-	    {
-	    case '\n':
-	      obstack_1grow (&action_obstack, c);
-	      lineno++;
-	      break;
-
-	    case '{':
-	      obstack_1grow (&action_obstack, c);
-	      count++;
-	      break;
-
-	    case '\'':
-	    case '"':
-	      copy_string (finput, &action_obstack, c);
-	      break;
+      while ((c = getc (finput)) != '}')
+	switch (c)
+	  {
+	  case '\n':
+	    obstack_1grow (&action_obstack, c);
+	    lineno++;
+	    break;
 
-	    case '/':
-	      copy_comment (finput, &action_obstack);
-	      break;
+	  case '{':
+	    obstack_1grow (&action_obstack, c);
+	    count++;
+	    break;
 
-	    case '$':
-	      copy_dollar (finput, &action_obstack,
-			   rule, stack_offset);
-	      break;
+	  case '\'':
+	  case '"':
+	    copy_string (finput, &action_obstack, c);
+	    break;
 
-	    case '@':
-	      copy_at (finput, &action_obstack,
-		       stack_offset);
-	      break;
+	  case '/':
+	    copy_comment (finput, &action_obstack);
+	    break;
 
-	    case EOF:
-	      fatal (_("unmatched %s"), "`{'");
+	  case '$':
+	    copy_dollar (finput, &action_obstack,
+			 rule, stack_offset);
+	    break;
 
-	    default:
-	      obstack_1grow (&action_obstack, c);
-	    }
+	  case '@':
+	    copy_at (finput, &action_obstack,
+		     stack_offset);
+	    break;
 
-	  c = getc (finput);
-	}
+	  case EOF:
+	    fatal (_("unmatched %s"), "`{'");
 
-      /* above loop exits when c is '}' */
+	  default:
+	    obstack_1grow (&action_obstack, c);
+	  }
 
+      /* Above loop exits when C is '}'.  */
       if (--count)
 	{
 	  obstack_1grow (&action_obstack, c);
@@ -1061,121 +1162,31 @@ copy_action (symbol_list *rule, int stack_offset)
 	}
     }
 
-  obstack_sgrow (&action_obstack, ";\n    break;}");
+  obstack_1grow (&action_obstack, '\0');
 }
-
-/*-------------------------------------------------------------------.
-| After `%guard' is seen in the input file, copy the actual guard    |
-| into the guards file.  If the guard is followed by an action, copy |
-| that into the actions file.  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, for the simple parser in which    |
-| the stack is not popped until after the guard is run.              |
-`-------------------------------------------------------------------*/
+
 
 static void
-copy_guard (symbol_list *rule, int stack_offset)
+parse_action (symbol_list *rule, int stack_offset)
 {
-  int c;
-  int count;
-  int brace_flag = 0;
-
-  /* offset is always 0 if parser has already popped the stack pointer */
-  if (semantic_parser)
-    stack_offset = 0;
-
-  obstack_fgrow1 (&guard_obstack, "\ncase %d:\n", nrules);
-  if (!no_lines_flag)
-    obstack_fgrow2 (&guard_obstack, "#line %d %s\n",
-		    lineno, quotearg_style (c_quoting_style, infile));
-  obstack_1grow (&guard_obstack, '{');
-
-  count = 0;
-  c = getc (finput);
-
-  while (brace_flag ? (count > 0) : (c != ';'))
-    {
-      switch (c)
-	{
-	case '\n':
-	  obstack_1grow (&guard_obstack, c);
-	  lineno++;
-	  break;
-
-	case '{':
-	  obstack_1grow (&guard_obstack, c);
-	  brace_flag = 1;
-	  count++;
-	  break;
-
-	case '}':
-	  obstack_1grow (&guard_obstack, c);
-	  if (count > 0)
-	    count--;
-	  else
-	    {
-	      complain (_("unmatched %s"), "`}'");
-	      c = getc (finput);	/* skip it */
-	    }
-	  break;
-
-	case '\'':
-	case '"':
-	  copy_string (finput, &guard_obstack, c);
-	  break;
-
-	case '/':
-	  copy_comment (finput, &guard_obstack);
-	  break;
-
-	case '$':
-	  copy_dollar (finput, &guard_obstack, rule, stack_offset);
-	  break;
-
-	case '@':
-	  copy_at (finput, &guard_obstack, stack_offset);
-	  break;
-
-	case EOF:
-	  fatal ("%s", _("unterminated %guard clause"));
-
-	default:
-	  obstack_1grow (&guard_obstack, c);
-	}
-
-      if (c != '}' || count != 0)
-	c = getc (finput);
-    }
-
-  c = skip_white_space ();
-
-  obstack_sgrow (&guard_obstack, ";\n    break;}");
-  if (c == '{')
-    copy_action (rule, stack_offset);
-  else if (c == '=')
-    {
-      c = getc (finput);	/* why not skip_white_space -wjh */
-      if (c == '{')
-	copy_action (rule, stack_offset);
-    }
-  else
-    ungetc (c, finput);
+  rule->action_line = lineno;
+  parse_braces (rule, stack_offset);
+  rule->action = obstack_finish (&action_obstack);
 }
-
+
 
 static void
-record_rule_line (void)
+parse_guard (symbol_list *rule, int stack_offset)
 {
-  /* 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;
+  token_t t = lex ();
+  if (t != tok_left_curly)
+    complain (_("invalid %s declaration"), "%guard");
+  rule->guard_line = lineno;
+  parse_braces (rule, stack_offset);
+  rule->guard = obstack_finish (&action_obstack);
 }
 
+
 
 /*-------------------------------------------------------------------.
 | Generate a dummy symbol, a nonterminal, whose name cannot conflict |
@@ -1185,370 +1196,266 @@ 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++;
   return sym;
 }
-
-#if 0
-/*------------------------------------------------------------------.
-| read in a %type declaration and record its information for        |
-| get_type_name to access.  This is unused.  It is only called from |
-| the #if 0 part of readgram                                        |
-`------------------------------------------------------------------*/
-
-static int
-get_type (void)
-{
-  int k;
-  int t;
-  char *name;
-
-  t = lex ();
-
-  if (t != TYPENAME)
-    {
-      complain (_("invalid %s declaration"), "%type");
-      return t;
-    }
-
-  name = xstrdup (token_buffer);
-
-  for (;;)
-    {
-      t = lex ();
-
-      switch (t)
-	{
-	case SEMICOLON:
-	  return lex ();
-
-	case COMMA:
-	  break;
-
-	case IDENTIFIER:
-	  if (symval->type_name == NULL)
-	    symval->type_name = name;
-	  else if (strcmp (name, symval->type_name) != 0)
-	    complain (_("type redeclaration for %s"), symval->tag);
-
-	  break;
-
-	default:
-	  return t;
-	}
-    }
-}
-
-#endif
 
-/*------------------------------------------------------------------.
-| Parse the input grammar into a one symbol_list structure.  Each   |
-| rule is represented by a sequence of symbols: the left hand side  |
-| followed by the contents of the right hand side, followed by a    |
-| null pointer instead of a symbol to terminate the rule.  The next |
-| symbol is the lhs of the following rule.                          |
-|                                                                   |
-| All guards and actions are copied out to the appropriate files,   |
-| labelled by the rule number they apply to.                        |
-`------------------------------------------------------------------*/
+/*-------------------------------------------------------------------.
+| Parse the input grammar into a one symbol_list structure.  Each    |
+| rule is represented by a sequence of symbols: the left hand side   |
+| followed by the contents of the right hand side, followed by a     |
+| null pointer instead of a symbol to terminate the rule.  The next  |
+| symbol is the lhs of the following rule.                           |
+|                                                                    |
+| All guards and actions are copied out to the appropriate files,    |
+| labelled by the rule number they apply to.                         |
+|                                                                    |
+| Bison used to allow some %directives in the rules sections, but    |
+| this is no longer consider appropriate: (i) the documented grammar |
+| doesn't claim it, (ii), it would promote bad style, (iii), error   |
+| recovery for %directives consists in skipping the junk until a `%' |
+| is seen and helrp synchronizing.  This scheme is definitely wrong  |
+| in the rules section.                                              |
+`-------------------------------------------------------------------*/
 
 static void
 readgram (void)
 {
-  int t;
+  token_t t;
   bucket *lhs = NULL;
-  symbol_list *p;
-  symbol_list *p1;
+  symbol_list *p = NULL;
+  symbol_list *p1 = NULL;
   bucket *bp;
 
   /* Points to first symbol_list of current rule. its symbol is the
      lhs of the rule.  */
-  symbol_list *crule;
+  symbol_list *crule = NULL;
   /* Points to the symbol_list preceding crule.  */
-  symbol_list *crule1;
-
-  p1 = NULL;
+  symbol_list *crule1 = NULL;
 
   t = lex ();
 
-  while (t != TWO_PERCENTS && t != ENDFILE)
-    {
-      if (t == IDENTIFIER || t == BAR)
-	{
-	  int action_flag = 0;
-	  /* Number of symbols in rhs of this rule so far */
-	  int rulelength = 0;
-	  int xactions = 0;	/* JF for error checking */
-	  bucket *first_rhs = 0;
-
-	  if (t == IDENTIFIER)
-	    {
-	      lhs = symval;
-
-	      if (!start_flag)
-		{
-		  startval = lhs;
-		  start_flag = 1;
-		}
-
-	      t = lex ();
-	      if (t != COLON)
-		{
-		  complain (_("ill-formed rule: initial symbol not followed by colon"));
-		  unlex (t);
-		}
-	    }
-
-	  if (nrules == 0 && t == BAR)
-	    {
-	      complain (_("grammar starts with vertical bar"));
-	      lhs = symval;	/* BOGUS: use a random symval */
-	    }
-	  /* start a new rule and record its lhs.  */
-
-	  nrules++;
-	  nitems++;
+  while (t != tok_two_percents && t != tok_eof)
+    if (t == tok_identifier || t == tok_bar)
+      {
+	int action_flag = 0;
+	/* Number of symbols in rhs of this rule so far */
+	int rulelength = 0;
+	int xactions = 0;	/* JF for error checking */
+	bucket *first_rhs = 0;
 
-	  record_rule_line ();
+	if (t == tok_identifier)
+	  {
+	    lhs = symval;
 
-	  p = XCALLOC (symbol_list, 1);
-	  p->sym = lhs;
+	    if (!start_flag)
+	      {
+		startval = lhs;
+		start_flag = 1;
+	      }
 
-	  crule1 = p1;
-	  if (p1)
-	    p1->next = p;
-	  else
-	    grammar = p;
+	    t = lex ();
+	    if (t != tok_colon)
+	      {
+		complain (_("ill-formed rule: initial symbol not followed by colon"));
+		unlex (t);
+	      }
+	  }
 
-	  p1 = p;
-	  crule = p;
+	if (nrules == 0 && t == tok_bar)
+	  {
+	    complain (_("grammar starts with vertical bar"));
+	    lhs = symval;	/* BOGUS: use a random symval */
+	  }
+	/* start a new rule and record its lhs.  */
 
-	  /* mark the rule's lhs as a nonterminal if not already so.  */
+	nrules++;
+	nitems++;
 
-	  if (lhs->class == unknown_sym)
-	    {
-	      lhs->class = nterm_sym;
-	      lhs->value = nvars;
-	      nvars++;
-	    }
-	  else if (lhs->class == token_sym)
-	    complain (_("rule given for %s, which is a token"), lhs->tag);
+	p = symbol_list_new (lhs);
 
-	  /* read the rhs of the rule.  */
+	crule1 = p1;
+	if (p1)
+	  p1->next = p;
+	else
+	  grammar = p;
 
-	  for (;;)
-	    {
-	      t = lex ();
-	      if (t == PREC)
-		{
-		  t = lex ();
-		  crule->ruleprec = symval;
-		  t = lex ();
-		}
+	p1 = p;
+	crule = p;
 
-	      if (!(t == IDENTIFIER || t == LEFT_CURLY))
-		break;
+	/* mark the rule's lhs as a nonterminal if not already so.  */
 
-	      /* If next token is an identifier, see if a colon follows it.
-	         If one does, exit this rule now.  */
-	      if (t == IDENTIFIER)
-		{
-		  bucket *ssave;
-		  int t1;
-
-		  ssave = symval;
-		  t1 = lex ();
-		  unlex (t1);
-		  symval = ssave;
-		  if (t1 == COLON)
-		    break;
-
-		  if (!first_rhs)	/* JF */
-		    first_rhs = symval;
-		  /* Not followed by colon =>
-		     process as part of this rule's rhs.  */
-		}
+	if (lhs->class == unknown_sym)
+	  {
+	    lhs->class = nterm_sym;
+	    lhs->value = nvars;
+	    nvars++;
+	  }
+	else if (lhs->class == token_sym)
+	  complain (_("rule given for %s, which is a token"), lhs->tag);
 
-	      /* If we just passed an action, that action was in the middle
-	         of a rule, so make a dummy rule to reduce it to a
-	         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 ();
-
-		  /* 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);
-		  if (crule1)
-		    crule1->next = p;
-		  else
-		    grammar = p;
-		  p->sym = sdummy;
-		  crule1 = XCALLOC (symbol_list, 1);
-		  p->next = crule1;
-		  crule1->next = crule;
-
-		  /* Insert the dummy generated by that rule into this
-		     rule.  */
-		  nitems++;
-		  p = XCALLOC (symbol_list, 1);
-		  p->sym = sdummy;
-		  p1->next = p;
-		  p1 = p;
-
-		  action_flag = 0;
-		}
+	/* read the rhs of the rule.  */
 
-	      if (t == IDENTIFIER)
-		{
-		  nitems++;
-		  p = XCALLOC (symbol_list, 1);
-		  p->sym = symval;
-		  p1->next = p;
-		  p1 = p;
-		}
-	      else		/* handle an action.  */
-		{
-		  copy_action (crule, rulelength);
-		  action_flag = 1;
-		  xactions++;	/* JF */
-		}
-	      rulelength++;
-	    }			/* end of  read rhs of rule */
+	for (;;)
+	  {
+	    t = lex ();
+	    if (t == tok_prec)
+	      {
+		t = lex ();
+		crule->ruleprec = symval;
+		t = lex ();
+	      }
+
+	    if (!(t == tok_identifier || t == tok_left_curly))
+	      break;
 
-	  /* Put an empty link in the list to mark the end of this rule  */
-	  p = XCALLOC (symbol_list, 1);
-	  p1->next = p;
-	  p1 = p;
+	    /* If next token is an identifier, see if a colon follows it.
+	       If one does, exit this rule now.  */
+	    if (t == tok_identifier)
+	      {
+		bucket *ssave;
+		token_t t1;
+
+		ssave = symval;
+		t1 = lex ();
+		unlex (t1);
+		symval = ssave;
+		if (t1 == tok_colon)
+		  break;
+
+		if (!first_rhs)	/* JF */
+		  first_rhs = symval;
+		/* Not followed by colon =>
+		   process as part of this rule's rhs.  */
+	      }
+
+	    /* If we just passed an action, that action was in the middle
+	       of a rule, so make a dummy rule to reduce it to a
+	       non-terminal.  */
+	    if (action_flag)
+	      {
+		/* 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.  */
+		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.  */
+		nrules++;
+		nitems++;
+		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;
+		/* 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 = symbol_list_new (sdummy);
+		p1->next = p;
+		p1 = p;
+
+		action_flag = 0;
+	      }
+
+	    if (t == tok_identifier)
+	      {
+		nitems++;
+		p = symbol_list_new (symval);
+		p1->next = p;
+		p1 = p;
+	      }
+	    else		/* handle an action.  */
+	      {
+		parse_action (crule, rulelength);
+		action_flag = 1;
+		xactions++;	/* JF */
+	      }
+	    rulelength++;
+	  }			/* end of  read rhs of rule */
+
+	/* Put an empty link in the list to mark the end of this rule  */
+	p = symbol_list_new (NULL);
+	p1->next = p;
+	p1 = p;
+
+	if (t == tok_prec)
+	  {
+	    complain (_("two @prec's in a row"));
+	    t = lex ();
+	    crule->ruleprec = symval;
+	    t = lex ();
+	  }
 
-	  if (t == PREC)
-	    {
-	      complain (_("two @prec's in a row"));
-	      t = lex ();
-	      crule->ruleprec = symval;
-	      t = lex ();
-	    }
-	  if (t == GUARD)
-	    {
-	      if (!semantic_parser)
-		complain (_("%%guard present but %%semantic_parser not specified"));
+	if (t == tok_guard)
+	  {
+	    if (!semantic_parser)
+	      complain (_("%%guard present but %%semantic_parser not specified"));
 
-	      copy_guard (crule, rulelength);
-	      t = lex ();
-	    }
-	  else if (t == LEFT_CURLY)
-	    {
-	      /* This case never occurs -wjh */
-	      if (action_flag)
-		complain (_("two actions at end of one rule"));
-	      copy_action (crule, rulelength);
-	      action_flag = 1;
-	      xactions++;	/* -wjh */
-	      t = lex ();
-	    }
-	  /* If $$ is being set in default way, report if any type
-	     mismatch.  */
-	  else if (!xactions
-		   && first_rhs && lhs->type_name != first_rhs->type_name)
-	    {
-	      if (lhs->type_name == 0
-		  || first_rhs->type_name == 0
-		  || strcmp (lhs->type_name, first_rhs->type_name))
-		complain (_("type clash (`%s' `%s') on default action"),
-			  lhs->type_name ? lhs->type_name : "",
-			  first_rhs->type_name ? first_rhs->type_name : "");
-	    }
-	  /* 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)
+	    parse_guard (crule, rulelength);
 	    t = lex ();
-	}
-#if 0
-      /* these things can appear as alternatives to rules.  */
-/* NO, they cannot.
-	a) none of the documentation allows them
-	b) most of them scan forward until finding a next %
-		thus they may swallow lots of intervening rules
-*/
-      else if (t == TOKEN)
-	{
-	  parse_token_decl (token_sym, nterm_sym);
-	  t = lex ();
-	}
-      else if (t == NTERM)
-	{
-	  parse_token_decl (nterm_sym, token_sym);
-	  t = lex ();
-	}
-      else if (t == TYPE)
-	{
-	  t = get_type ();
-	}
-      else if (t == UNION)
-	{
-	  parse_union_decl ();
-	  t = lex ();
-	}
-      else if (t == EXPECT)
-	{
-	  parse_expect_decl ();
-	  t = lex ();
-	}
-      else if (t == START)
-	{
-	  parse_start_decl ();
-	  t = lex ();
-	}
-#endif
+	  }
 
-      else
-	{
-	  complain (_("invalid input: %s"), token_buffer);
+	if (t == tok_left_curly)
+	  {
+	    /* This case never occurs -wjh */
+	    if (action_flag)
+	      complain (_("two actions at end of one rule"));
+	    parse_action (crule, rulelength);
+	    action_flag = 1;
+	    xactions++;	/* -wjh */
+	    t = lex ();
+	  }
+	/* If $$ is being set in default way, report if any type
+	   mismatch.  */
+	else if (!xactions
+		 && first_rhs && lhs->type_name != first_rhs->type_name)
+	  {
+	    if (lhs->type_name == 0
+		|| first_rhs->type_name == 0
+		|| strcmp (lhs->type_name, first_rhs->type_name))
+	      complain (_("type clash (`%s' `%s') on default action"),
+			lhs->type_name ? lhs->type_name : "",
+			first_rhs->type_name ? first_rhs->type_name : "");
+	  }
+	/* 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 == tok_semicolon)
 	  t = lex ();
-	}
-    }
+      }
+    else
+      {
+	complain (_("invalid input: %s"), quote (token_buffer));
+	t = lex ();
+      }
 
   /* grammar has been read.  Do some checking */
 
-  if (nsyms > MAXSHORT)
-    fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
-	   MAXSHORT);
   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_sgrow (&attrs_obstack,
-			   "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
-      if (defines_flag)
-	obstack_sgrow (&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)
@@ -1561,57 +1468,91 @@ readgram (void)
 	bp->value = nvars++;
       }
 
+  /* Insert the initial rule, which line is that of the first rule
+     (not that of the start symbol):
+
+     axiom: %start EOF.  */
+  p = symbol_list_new (axiom);
+  p->line = grammar->line;
+  p->next = symbol_list_new (startval);
+  p->next->next = symbol_list_new (eoftoken);
+  p->next->next->next = symbol_list_new (NULL);
+  p->next->next->next->next = grammar;
+  nrules += 1;
+  nitems += 3;
+  grammar = p;
+  startval = axiom;
+
+  if (nsyms > MAXSHORT)
+    fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
+	   MAXSHORT);
+
   ntokens = nsyms - nvars;
 }
-
-/*--------------------------------------------------------------.
-| For named tokens, but not literal ones, define the name.  The |
-| value is the user token number.                               |
-`--------------------------------------------------------------*/
 
+/* 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
-output_token_defines (struct obstack *oout)
+read_additionnal_code (void)
 {
-  bucket *bp;
-  char *cp, *symbol;
   char c;
+  struct obstack el_obstack;
 
-  for (bp = firstsymbol; bp; bp = bp->next)
+  obstack_init (&el_obstack);
+
+  if (!no_lines_flag)
     {
-      symbol = bp->tag;		/* get symbol */
+      obstack_fgrow2 (&el_obstack, muscle_find ("linef"),
+		      lineno, quotearg_style (c_quoting_style,
+					      muscle_find ("filename")));
+    }
+
+  while ((c = getc (finput)) != EOF)
+    obstack_1grow (&el_obstack, c);
 
+  obstack_1grow (&el_obstack, 0);
+  muscle_insert ("epilogue", obstack_finish (&el_obstack));
+}
+
+
+/*------------------------------------------------------------------.
+| Set TOKEN_TRANSLATIONS.  Check that no two symbols share the same |
+| number.                                                           |
+`------------------------------------------------------------------*/
+
+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;
-      if ('\'' == *symbol)
-	continue;		/* skip literal character */
-      if (bp == errtoken)
-	continue;		/* skip error token */
-      if ('\"' == *symbol)
-	{
-	  /* use literal string only if given a symbol with an alias */
-	  if (bp->alias)
-	    symbol = bp->alias->tag;
-	  else
-	    continue;
-	}
 
-      /* Don't #define nonliteral tokens whose names contain periods.  */
-      cp = symbol;
-      while ((c = *cp++) && c != '.');
-      if (c != '\0')
-	continue;
+      assert (bp->user_token_number != SUNDEF);
 
-      obstack_fgrow2 (oout, "#define\t%s\t%d\n",
-		      symbol,
-		      ((translations && !raw_flag)
-		       ? bp->user_token_number : bp->value));
-      if (semantic_parser)
-	obstack_fgrow2 (oout, "#define\tT%s\t%d\n", symbol, bp->value);
+      /* 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;
     }
-
-  obstack_1grow (oout, '\n');
 }
 
 
@@ -1624,18 +1565,12 @@ 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);
@@ -1651,11 +1586,18 @@ packsymbols (void)
 	}
       else if (bp->alias)
 	{
-	  /* this symbol and its alias are a single token defn.
-	     allocate a tokno, and assign to both check agreement of
-	     ->prec and ->assoc fields and make both the same */
-	  if (bp->value == 0)
-	    bp->value = bp->alias->value = tokno++;
+	  /* This symbol and its alias are a single token defn.
+	     Allocate a tokno, and assign to both check agreement of
+	     prec and assoc fields and make both the same */
+	  if (bp->value == -1)
+	    {
+	      if (bp == eoftoken || bp->alias == eoftoken)
+		bp->value = bp->alias->value = 0;
+	      else
+		{
+		  bp->value = bp->alias->value = tokno++;
+		}
+	    }
 
 	  if (bp->prec != bp->alias->prec)
 	    {
@@ -1681,18 +1623,22 @@ packsymbols (void)
 		bp->assoc = bp->alias->assoc;
 	    }
 
+	  /* Do not do processing below for SALIASs.  */
 	  if (bp->user_token_number == SALIAS)
-	    continue;		/* do not do processing below for SALIASs */
+	    continue;
 
 	}
-      else			/* bp->class == token_sym */
+      else /* bp->class == token_sym */
 	{
-	  bp->value = tokno++;
+	  if (bp == eoftoken)
+	    bp->value = 0;
+	  else
+	    bp->value = tokno++;
 	}
 
       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;
@@ -1702,76 +1648,68 @@ 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;
+}
 
-  if (defines_flag)
+
+/*---------------------------------------------------------------.
+| Save the definition of token names in the `TOKENDEFS' muscle.  |
+`---------------------------------------------------------------*/
+
+static void
+symbols_save (void)
+{
+  struct obstack tokendefs;
+  bucket *bp;
+  obstack_init (&tokendefs);
+
+  for (bp = firstsymbol; bp; bp = bp->next)
     {
-      output_token_defines (&defines_obstack);
+      char *symbol = bp->tag;                /* get symbol */
 
-      if (!pure_parser)
+      if (bp->value >= ntokens)
+	continue;
+      if (bp->user_token_number == SALIAS)
+	continue;
+      if ('\'' == *symbol)
+	continue;               /* skip literal character */
+      if (bp == errtoken)
+	continue;               /* skip error token */
+      if ('\"' == *symbol)
 	{
-	  if (spec_name_prefix)
-	    obstack_fgrow1 (&defines_obstack, "\nextern YYSTYPE %slval;\n",
-			    spec_name_prefix);
+	  /* use literal string only if given a symbol with an alias */
+	  if (bp->alias)
+	    symbol = bp->alias->tag;
 	  else
-	    obstack_sgrow (&defines_obstack,
-				 "\nextern YYSTYPE yylval;\n");
+	    continue;
 	}
 
+      /* Don't #define nonliteral tokens whose names contain periods.  */
+      if (strchr (symbol, '.'))
+	continue;
+
+      obstack_fgrow2 (&tokendefs, "# define %s\t%d\n",
+		      symbol, bp->user_token_number);
       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);
-	  }
-#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;
-#endif
+	/* FIXME: This is probably wrong, and should be just as
+	   above. --akim.  */
+	obstack_fgrow2 (&tokendefs, "# define T%s\t%d\n", symbol, bp->value);
     }
+
+  obstack_1grow (&tokendefs, 0);
+  muscle_insert ("tokendef", xstrdup (obstack_finish (&tokendefs)));
+  obstack_free (&tokendefs, NULL);
 }
 
 
@@ -1787,14 +1725,12 @@ packgram (void)
   int ruleno;
   symbol_list *p;
 
-  bucket *ruleprec;
+  /* We use short to index items.  */
+  if (nitems >= MAXSHORT)
+    fatal (_("too many items (max %d)"), MAXSHORT);
 
   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;
@@ -1802,9 +1738,15 @@ 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;
+      rule_table[ruleno].useful = TRUE;
+      rule_table[ruleno].action = p->action;
+      rule_table[ruleno].action_line = p->action_line;
+      rule_table[ruleno].guard = p->guard;
+      rule_table[ruleno].guard_line = p->guard_line;
 
       p = p->next;
       while (p && p->sym)
@@ -1814,8 +1756,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;
@@ -1825,9 +1767,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;
@@ -1838,6 +1780,11 @@ packgram (void)
     }
 
   ritem[itemno] = 0;
+  nritems = itemno;
+  assert (nritems == nitems);
+
+  if (trace_flag)
+    ritem_print (stderr);
 }
 
 /*-------------------------------------------------------------------.
@@ -1854,107 +1801,80 @@ 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;
+  nsyms = 0;
   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 axiom symbol. */
+  axiom = getsym ("$axiom");
+  axiom->class = nterm_sym;
+  axiom->value = nvars++;
+
   /* 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.");
   undeftoken->class = token_sym;
   undeftoken->user_token_number = 2;
 
+  /* Initialize the obstacks. */
+  obstack_init (&action_obstack);
+  obstack_init (&attrs_obstack);
+  obstack_init (&output_obstack);
+
+  finput = xfopen (infile, "r");
+
   /* 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_sgrow (&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 ();
+
+  /* If the user did not define her EOFTOKEN, do it now. */
+  if (!eoftoken)
+    {
+      eoftoken = getsym ("$");
+      eoftoken->class = token_sym;
+      /* Value specified by POSIX.  */
+      eoftoken->user_token_number = 0;
+    }
+
   /* Read in the grammar, build grammar in list form.  Write out
      guards and actions.  */
   readgram ();
-  /* 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_sgrow (&table_obstack, "#define YYLSP_NEEDED 1\n\n");
+  /* Some C code is given at the end of the grammar file. */
+  read_additionnal_code ();
+
+  lex_free ();
+  xfclose (finput);
+
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
   packsymbols ();
+  /* Save them. */
+  symbols_save ();
+
   /* 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 ();
-}
-
-
-/*------------------------------------------------------------------.
-| Define YYLTYPE.  Cannot be in the skeleton since we might have to |
-| output it in the headers if --defines is used.                    |
-`------------------------------------------------------------------*/
-
-void
-reader_output_yylsp (struct obstack *oout)
-{
-  if (locations_flag)
-    obstack_sgrow (oout, "\
-\n\
-#ifndef YYLTYPE\n\
-typedef struct yyltype\n\
-{\n\
-  int first_line;\n\
-  int first_column;\n\
-\n\
-  int last_line;\n\
-  int last_column;\n\
-} yyltype;\n\
-\n\
-# define YYLTYPE yyltype\n\
-#endif\n\
-\n");
 }