]> git.saurik.com Git - bison.git/blobdiff - src/reader.c
* doc/bison.texinfo (Stack Overflow): xref to Recursion.
[bison.git] / src / reader.c
index 949d74bb26cc657d2b3ebe09e64631c8fff05232..d7527158aca5549dc388a416dad300191056f371 100644 (file)
@@ -26,8 +26,7 @@
 #include "getargs.h"
 #include "files.h"
 #include "symtab.h"
 #include "getargs.h"
 #include "files.h"
 #include "symtab.h"
-#include "options.h"
-#include "lex.h"
+#include "symlist.h"
 #include "gram.h"
 #include "complain.h"
 #include "output.h"
 #include "gram.h"
 #include "complain.h"
 #include "output.h"
 #include "conflicts.h"
 #include "muscle_tab.h"
 
 #include "conflicts.h"
 #include "muscle_tab.h"
 
-typedef struct symbol_list
-{
-  struct symbol_list *next;
-  symbol_t *sym;
-  int line;
-
-  /* The action is attached to the LHS of a rule. */
-  const char *action;
-  int action_line;
-
-  symbol_t *ruleprec;
-} symbol_list;
-
-int lineno;
-static symbol_list *grammar = NULL;
+static symbol_list_t *grammar = NULL;
 static int start_flag = 0;
 static int start_flag = 0;
+merger_list *merge_functions;
 
 /* Nonzero if %union has been seen.  */
 
 /* Nonzero if %union has been seen.  */
-static int typed = 0;
-
-/* Incremented for each %left, %right or %nonassoc seen */
-static int lastprec = 0;
-
-static symbol_list *
-symbol_list_new (symbol_t *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->ruleprec = NULL;
-  return res;
-}
-
-/*===================\
-| Low level lexing.  |
-\===================*/
-
-static void
-skip_to_char (int target)
-{
-  int c;
-  if (target == '\n')
-    complain (_("   Skipping to next \\n"));
-  else
-    complain (_("   Skipping to next %c"), target);
-
-  do
-    c = skip_white_space ();
-  while (c != target && c != EOF);
-  if (c != EOF)
-    ungetc (c, finput);
-}
-
-
-/*---------------------------------------------------------.
-| Read a signed integer from STREAM and return its value.  |
-`---------------------------------------------------------*/
-
-static inline int
-read_signed_integer (FILE *stream)
-{
-  int c = getc (stream);
-  int sign = 1;
-  int n = 0;
-
-  if (c == '-')
-    {
-      c = getc (stream);
-      sign = -1;
-    }
-
-  while (isdigit (c))
-    {
-      n = 10 * n + (c - '0');
-      c = getc (stream);
-    }
-
-  ungetc (c, stream);
-
-  return sign * n;
-}
+int typed = 0;
 \f
 \f
-/*--------------------------------------------------------------.
-| Get the data type (alternative in the union) of the value for |
-| symbol N in rule RULE.                                        |
-`--------------------------------------------------------------*/
-
-static char *
-get_type_name (int n, symbol_list *rule)
-{
-  int i;
-  symbol_list *rp;
-
-  if (n < 0)
-    {
-      complain (_("invalid $ value"));
-      return NULL;
-    }
-
-  rp = rule;
-  i = 0;
-
-  while (i < n)
-    {
-      rp = rp->next;
-      if (rp == NULL || rp->sym == NULL)
-       {
-         complain (_("invalid $ value"));
-         return NULL;
-       }
-      ++i;
-    }
-
-  return rp->sym->type_name;
-}
-\f
-/*------------------------------------------------------------------.
-| Copy the character C to OOUT, and insert quadigraphs when needed. |
-`------------------------------------------------------------------*/
-
-static inline void
-copy_character (struct obstack *oout, int c)
-{
-  switch (c)
-    {
-    case '[':
-      obstack_sgrow (oout, "@<:@");
-      break;
-
-    case ']':
-      obstack_sgrow (oout, "@:>@");
-      break;
-
-    default:
-      obstack_1grow (oout, c);
-    }
-}
-
-/*------------------------------------------------------------.
-| Dump the string from FIN to OOUT if non null.  MATCH is the |
-| delimiter of the string (either ' or ").                    |
-`------------------------------------------------------------*/
-
-static inline void
-copy_string2 (FILE *fin, struct obstack *oout, int match, int store)
-{
-  int c;
-
-  if (store)
-    obstack_1grow (oout, match);
-
-  c = getc (fin);
-
-  while (c != match)
-    {
-      if (c == EOF)
-       fatal (_("unterminated string at end of file"));
-      if (c == '\n')
-       {
-         complain (_("unterminated string"));
-         ungetc (c, fin);
-         c = match;            /* invent terminator */
-         continue;
-       }
-
-      copy_character (oout, c);
-
-      if (c == '\\')
-       {
-         c = getc (fin);
-         if (c == EOF)
-           fatal (_("unterminated string at end of file"));
-         copy_character (oout, c);
-
-         if (c == '\n')
-           ++lineno;
-       }
-
-      c = getc (fin);
-    }
-
-  if (store)
-    obstack_1grow (oout, c);
-}
-
-/* FIXME. */
-
-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_comment (FILE *fin, struct obstack *oout)
-{
-  int cplus_comment;
-  int ended;
-  int c;
-
-  /* We read a `/', output it. */
-  obstack_1grow (oout, '/');
-
-  switch ((c = getc (fin)))
-    {
-    case '/':
-      cplus_comment = 1;
-      break;
-    case '*':
-      cplus_comment = 0;
-      break;
-    default:
-      ungetc (c, fin);
-      return;
-    }
-
-  obstack_1grow (oout, c);
-  c = getc (fin);
+/*-----------------------.
+| Set the start symbol.  |
+`-----------------------*/
 
 
-  ended = 0;
-  while (!ended)
-    {
-      if (!cplus_comment && c == '*')
-       {
-         while (c == '*')
-           {
-             obstack_1grow (oout, c);
-             c = getc (fin);
-           }
-
-         if (c == '/')
-           {
-             obstack_1grow (oout, c);
-             ended = 1;
-           }
-       }
-      else if (c == '\n')
-       {
-         ++lineno;
-         obstack_1grow (oout, c);
-         if (cplus_comment)
-           ended = 1;
-         else
-           c = getc (fin);
-       }
-      else if (c == EOF)
-       fatal (_("unterminated comment"));
-      else
-       {
-         copy_character (oout, c);
-         c = getc (fin);
-       }
-    }
-}
-
-
-/*-------------------------------------------------------------------.
-| FIN is pointing to a location (i.e., a `@').  Output to OOUT a     |
-| reference to this location. RULE_LENGTH 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, struct obstack *oout, int rule_length)
-{
-  int c = getc (fin);
-  locations_flag = 1;
-
-  if (c == '$')
-    {
-      obstack_sgrow (oout, "]b4_lhs_location[");
-    }
-  else if (isdigit (c) || c == '-')
-    {
-      int n;
-
-      ungetc (c, fin);
-      n = read_signed_integer (fin);
-      if (n > rule_length)
-       complain (_("invalid value: %s%d"), "@", n);
-      else
-       obstack_fgrow2 (oout, "]b4_rhs_location([%d], [%d])[",
-                       rule_length, n);
-    }
-  else
-    {
-      char buf[] = "@c";
-      buf[1] = c;
-      complain (_("%s is invalid"), quote (buf));
-    }
-}
-
-
-/*------------------------------------------------------------------.
-| FIN is pointing to a wannabee semantic value (i.e., a `$').       |
-|                                                                   |
-| Possible inputs: $[<TYPENAME>]($|integer)                         |
-|                                                                   |
-| Output to OOUT a reference to this semantic value. RULE_LENGTH 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, struct obstack *oout,
-            symbol_list *rule, int rule_length)
-{
-  int c = getc (fin);
-  const char *type_name = NULL;
-
-  /* Get the type name if explicit. */
-  if (c == '<')
-    {
-      read_type_name (fin);
-      type_name = token_buffer;
-      c = getc (fin);
-    }
-
-  if (c == '$')
-    {
-      if (!type_name)
-       type_name = get_type_name (0, rule);
-      if (!type_name && typed)
-       complain (_("$$ of `%s' has no declared type"),
-                 rule->sym->tag);
-      if (!type_name)
-       type_name = "";
-      obstack_fgrow1 (oout,
-                     "]b4_lhs_value([%s])[", type_name);
-    }
-  else if (isdigit (c) || c == '-')
-    {
-      int n;
-      ungetc (c, fin);
-      n = read_signed_integer (fin);
-
-      if (n > rule_length)
-       complain (_("invalid value: %s%d"), "$", n);
-      else
-       {
-         if (!type_name && n > 0)
-           type_name = get_type_name (n, rule);
-         if (!type_name && typed)
-           complain (_("$%d of `%s' has no declared type"),
-                     n, rule->sym->tag);
-         if (!type_name)
-           type_name = "";
-         obstack_fgrow3 (oout, "]b4_rhs_value([%d], [%d], [%s])[",
-                         rule_length, n, type_name);
-       }
-    }
-  else
-    {
-      char buf[] = "$c";
-      buf[1] = c;
-      complain (_("%s is invalid"), quote (buf));
-    }
-}
-\f
-/*-------------------------------------------------------------------.
-| Copy the contents of a `%{ ... %}' into the definitions file.  The |
-| `%{' has already been read.  Return after reading the `%}'.        |
-`-------------------------------------------------------------------*/
-
-static void
-copy_definition (struct obstack *oout)
-{
-  int c;
-  /* -1 while reading a character if prev char was %. */
-  int after_percent;
-
-  if (!no_lines_flag)
-    {
-      obstack_fgrow2 (oout, muscle_find ("linef"),
-                     lineno, quotearg_style (c_quoting_style,
-                                             muscle_find ("filename")));
-    }
-
-  after_percent = 0;
-
-  c = getc (finput);
-
-  for (;;)
-    {
-      switch (c)
-       {
-       case '\n':
-         obstack_1grow (oout, c);
-         ++lineno;
-         break;
-
-       case '%':
-         after_percent = -1;
-         break;
-
-       case '\'':
-       case '"':
-         copy_string (finput, oout, c);
-         break;
-
-       case '/':
-         copy_comment (finput, oout);
-         break;
-
-       case EOF:
-         fatal ("%s", _("unterminated `%{' definition"));
-
-       default:
-         copy_character (oout, c);
-       }
-
-      c = getc (finput);
-
-      if (after_percent)
-       {
-         if (c == '}')
-           return;
-         obstack_1grow (oout, '%');
-       }
-      after_percent = 0;
-    }
-}
-
-
-/*------------------------------------------.
-| Parse what comes after %token or %nterm.  |
-`------------------------------------------*/
-
-static void
-parse_token_decl (symbol_class class)
-{
-  token_t token = tok_undef;
-  char *typename = NULL;
-
-  /* The symbol being defined.  */
-  symbol_t *symbol = NULL;
-
-  /* After `%token' and `%nterm', any number of symbols maybe be
-     defined.  */
-  for (;;)
-    {
-      int tmp_char = ungetc (skip_white_space (), finput);
-
-      /* `%' (for instance from `%token', or from `%%' etc.) is the
-        only valid means to end this declaration.  */
-      if (tmp_char == '%')
-       return;
-      if (tmp_char == EOF)
-       fatal (_("Premature EOF after %s"), token_buffer);
-
-      token = lex ();
-      switch (token)
-       {
-       case tok_comma:
-         symbol = NULL;
-         break;
-
-       case tok_typename:
-         typename = xstrdup (token_buffer);
-         symbol = NULL;
-         break;
-
-       case tok_identifier:
-         if (*symval->tag == '\"' && symbol)
-           {
-             symbol_make_alias (symbol, symval, typename);
-             symbol = NULL;
-           }
-         else
-           {
-             symbol = symval;
-             symbol_class_set (symbol, class);
-             if (typename)
-               symbol_type_set (symbol, typename);
-           }
-         break;
-
-       case tok_number:
-         symbol_user_token_number_set (symbol, numval);
-         break;
-
-       default:
-         complain (_("`%s' is invalid in %s"),
-                   token_buffer,
-                   (class == token_sym) ? "%token" : "%nterm");
-         skip_to_char ('%');
-       }
-    }
-
-}
-
-
-/*------------------------------.
-| Parse what comes after %start |
-`------------------------------*/
-
-static void
-parse_start_decl (void)
+void
+grammar_start_symbol_set (symbol_t *s, location_t l)
 {
   if (start_flag)
 {
   if (start_flag)
-    complain (_("multiple %s declarations"), "%start");
-  if (lex () != tok_identifier)
-    complain (_("invalid %s declaration"), "%start");
+    complain_at (l, _("multiple %s declarations"), "%start");
   else
     {
       start_flag = 1;
   else
     {
       start_flag = 1;
-      startsymbol = symval;
+      startsymbol = s;
+      startsymbol_location = l;
     }
 }
 
     }
 }
 
-/*-----------------------------------------------------------.
-| read in a %type declaration and record its information for |
-| get_type_name to access                                    |
-`-----------------------------------------------------------*/
-
-static void
-parse_type_decl (void)
-{
-  char *name;
-
-  if (lex () != tok_typename)
-    {
-      complain ("%s", _("%type declaration has no <typename>"));
-      skip_to_char ('%');
-      return;
-    }
-
-  name = xstrdup (token_buffer);
-
-  for (;;)
-    {
-      token_t t;
-      int tmp_char = ungetc (skip_white_space (), finput);
-
-      if (tmp_char == '%')
-       return;
-      if (tmp_char == EOF)
-       fatal (_("Premature EOF after %s"), token_buffer);
-
-      t = lex ();
-
-      switch (t)
-       {
-       case tok_comma:
-       case tok_semicolon:
-         break;
-
-       case tok_identifier:
-         symbol_type_set (symval, name);
-         break;
-
-       default:
-         complain (_("invalid %%type declaration due to item: %s"),
-                   token_buffer);
-         skip_to_char ('%');
-       }
-    }
-}
-
-
 
 /*----------------------------------------------------------------.
 
 /*----------------------------------------------------------------.
-| Read in a %left, %right or %nonassoc declaration and record its |
-| information.                                                    |
+| There are two prologues: one before %union, one after.  Augment |
+| the current one.                                                |
 `----------------------------------------------------------------*/
 
 `----------------------------------------------------------------*/
 
-static void
-parse_assoc_decl (associativity assoc)
-{
-  char *name = NULL;
-  int prev = 0;
-
-  /* Assign a new precedence level, never 0.  */
-  ++lastprec;
-
-  for (;;)
-    {
-      token_t t;
-      int tmp_char = ungetc (skip_white_space (), finput);
-
-      if (tmp_char == '%')
-       return;
-      if (tmp_char == EOF)
-       fatal (_("Premature EOF after %s"), token_buffer);
-
-      t = lex ();
-
-      switch (t)
-       {
-       case tok_typename:
-         name = xstrdup (token_buffer);
-         break;
-
-       case tok_comma:
-         break;
-
-       case tok_identifier:
-         symbol_class_set (symval, token_sym);
-         symbol_precedence_set (symval, lastprec, assoc);
-         if (name)
-           symbol_type_set (symval, name);
-         break;
-
-       case tok_number:
-         if (prev == tok_identifier)
-           {
-             symbol_user_token_number_set (symval, numval);
-           }
-         else
-           {
-             complain
-               (_("invalid text (%s) - number should be after identifier"),
-                token_buffer);
-             skip_to_char ('%');
-           }
-         break;
-
-       case tok_semicolon:
-         return;
-
-       default:
-         complain (_("unexpected item: %s"), token_buffer);
-         skip_to_char ('%');
-       }
-
-      prev = t;
-    }
-}
-
-
-
-/*--------------------------------------------------------------.
-| 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
-parse_union_decl (void)
+void
+prologue_augment (const char *prologue, location_t location)
 {
 {
-  int c;
-  int count = 0;
-  bool done = FALSE;
-  struct obstack union_obstack;
-  if (typed)
-    complain (_("multiple %s declarations"), "%union");
-
-  typed = 1;
-
-  MUSCLE_INSERT_INT ("stype_line", lineno);
-  obstack_init (&union_obstack);
-  obstack_sgrow (&union_obstack, "union");
+  struct obstack *oout =
+    !typed ? &pre_prologue_obstack : &post_prologue_obstack;
 
 
-  while (!done)
+  if (!no_lines_flag)
     {
     {
-      c = xgetc (finput);
-
-      /* If C contains '/', it is output by copy_comment ().  */
-      if (c != '/')
-       obstack_1grow (&union_obstack, c);
-
-      switch (c)
-       {
-       case '\n':
-         ++lineno;
-         break;
-
-       case '/':
-         copy_comment (finput, &union_obstack);
-         break;
-
-       case '{':
-         ++count;
-         break;
-
-       case '}':
-         /* FIXME: Errr.  How could this happen???. --akim */
-         if (count == 0)
-           complain (_("unmatched %s"), "`}'");
-         count--;
-         if (!count)
-           done = TRUE;
-         break;
-       }
+      obstack_fgrow2 (oout, muscle_find ("linef"),
+                     location.first_line,
+                     quotearg_style (c_quoting_style,
+                                     muscle_find ("filename")));
     }
     }
-
-  /* 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));
+  obstack_sgrow (oout, prologue);
 }
 
 
 }
 
 
-/*-------------------------------------------------------.
-| Parse the declaration %expect N which says to expect N |
-| shift-reduce conflicts.                                |
-`-------------------------------------------------------*/
-
-static void
-parse_expect_decl (void)
-{
-  int c = skip_white_space ();
-  ungetc (c, finput);
 
 
-  if (!isdigit (c))
-    complain (_("argument of %%expect is not an integer"));
-  else
-    expected_conflicts = read_signed_integer (finput);
-}
 
 
+/*----------------------.
+| Handle the epilogue.  |
+`----------------------*/
 
 
-static void
-parse_muscle_decl (void)
+void
+epilogue_set (const char *epilogue, location_t location)
 {
 {
-  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 != '"')
+  if (!no_lines_flag)
     {
     {
-      ungetc (ch, finput);
-      if (ch != EOF)
-       {
-         complain (_("invalid %s declaration"), "%define");
-         skip_to_char ('%');
-         return;
-       }
-      else
-       fatal (_("Premature EOF after %s"), "\"");
+      obstack_fgrow2 (&muscle_obstack, muscle_find ("linef"),
+                     location.first_line,
+                     quotearg_style (c_quoting_style,
+                                     muscle_find ("filename")));
     }
     }
-  copy_string2 (finput, &muscle_obstack, '"', 0);
+  obstack_sgrow (&muscle_obstack, epilogue);
   obstack_1grow (&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);
+  muscle_insert ("epilogue", obstack_finish (&muscle_obstack));
 }
 
 
 }
 
 
+\f
 
 
-/*---------------------------------.
-| Parse a double quoted parameter. |
-`---------------------------------*/
+ /*-------------------------------------------------------------------.
+| Return the merger index for a merging function named NAME, whose   |
+| arguments have type TYPE.  Records the function, if new, in        |
+| merger_list.                                                      |
+`-------------------------------------------------------------------*/
 
 
-static const char *
-parse_dquoted_param (const char *from)
+static int
+get_merge_function (const char* name, const char* type,
+                   location_t loc)
 {
 {
-  struct obstack param_obstack;
-  const char *param = NULL;
-  int c;
-
-  obstack_init (&param_obstack);
-  c = skip_white_space ();
+  merger_list *syms;
+  merger_list head;
+  int n;
 
 
-  if (c != '"')
-    {
-      complain (_("invalid %s declaration"), from);
-      ungetc (c, finput);
-      skip_to_char ('%');
-      return NULL;
-    }
-
-  while ((c = literalchar ()) != '"')
-    obstack_1grow (&param_obstack, c);
+  if (! glr_parser)
+    return 0;
 
 
-  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;
-    }
+  if (type == NULL)
+    type = "";
 
 
-  return param;
-}
-
-/*----------------------------------.
-| Parse what comes after %skeleton. |
-`----------------------------------*/
-
-static void
-parse_skel_decl (void)
-{
-  skeleton = parse_dquoted_param ("%skeleton");
+  head.next = merge_functions;
+  for (syms = &head, n = 1; syms->next != NULL; syms = syms->next, n += 1)
+    if (strcmp (name, syms->next->name) == 0)
+      break;
+  if (syms->next == NULL)
+    {
+      syms->next = XMALLOC (merger_list, 1);
+      syms->next->name = xstrdup (name);
+      syms->next->type = xstrdup (type);
+      syms->next->next = NULL;
+      merge_functions = head.next;
+    }
+  else if (strcmp (type, syms->next->type) != 0)
+    warn_at (loc, _("result type clash on merge function %s: `%s' vs. `%s'"),
+            name, type, syms->next->type);
+  return n;
 }
 
 }
 
-/*----------------------------------------------------------------.
-| Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
-| any `%' declarations, and copy the contents of any `%{ ... %}'  |
-| groups to PRE_PROLOGUE_OBSTACK or POST_PROLOGUE_OBSTACK.        |
-`----------------------------------------------------------------*/
-
-static void
-read_declarations (void)
-{
-  for (;;)
-    {
-      int c = skip_white_space ();
+/*--------------------------------------.
+| Free all merge-function definitions. |
+`--------------------------------------*/
 
 
-      if (c == '%')
-       {
-         token_t tok = parse_percent_token ();
-
-         switch (tok)
-           {
-           case tok_two_percents:
-             return;
-
-           case tok_percent_left_curly:
-              if (!typed)
-               copy_definition (&pre_prologue_obstack);
-             else
-               copy_definition (&post_prologue_obstack);
-             break;
-
-           case tok_token:
-             parse_token_decl (token_sym);
-             break;
-
-           case tok_nterm:
-             parse_token_decl (nterm_sym);
-             break;
-
-           case tok_type:
-             parse_type_decl ();
-             break;
-
-           case tok_start:
-             parse_start_decl ();
-             break;
-
-           case tok_union:
-             parse_union_decl ();
-             break;
-
-           case tok_expect:
-             parse_expect_decl ();
-             break;
-
-           case tok_left:
-             parse_assoc_decl (left_assoc);
-             break;
-
-           case tok_right:
-             parse_assoc_decl (right_assoc);
-             break;
-
-           case tok_nonassoc:
-             parse_assoc_decl (non_assoc);
-             break;
-
-           case tok_define:
-             parse_muscle_decl ();
-             break;
-
-           case tok_skel:
-             parse_skel_decl ();
-             break;
-
-           case tok_noop:
-             break;
-
-           case tok_stropt:
-           case tok_intopt:
-           case tok_obsolete:
-             assert (0);
-             break;
-
-           case tok_illegal:
-           default:
-             complain (_("unrecognized: %s"), token_buffer);
-             skip_to_char ('%');
-           }
-       }
-      else if (c == EOF)
-       fatal (_("no input grammar"));
-      else
-       {
-         char buf[] = "c";
-         buf[0] = c;
-         complain (_("unknown character: %s"), quote (buf));
-         skip_to_char ('%');
-       }
-    }
-}
-\f
-/*------------------------------------------------------------------.
-| Assuming that a `{' has just been seen, copy everything up to the |
-| matching `}' into ACTION_OBSTACK.                                 |
-|                                                                   |
-| RULE_LENGTH 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.  It is not the same as the rule->length in the case of mid |
-| rule actions.                                                     |
-|                                                                   |
-| This routine is used for actions.                                 |
-`------------------------------------------------------------------*/
-
-static void
-parse_action (symbol_list *rule, int rule_length)
+void
+free_merger_functions (void)
 {
 {
-  int count = 1;
-  rule->action_line = lineno;
-  while (count > 0)
+  merger_list *L0;
+  if (! glr_parser)
+    return;
+  L0 = merge_functions;
+  while (L0 != NULL)
     {
     {
-      int c;
-      while ((c = getc (finput)) != '}')
-       switch (c)
-         {
-         case '\n':
-           copy_character (&action_obstack, c);
-           ++lineno;
-           break;
-
-         case '{':
-           copy_character (&action_obstack, c);
-           ++count;
-           break;
-
-         case '\'':
-         case '"':
-           copy_string (finput, &action_obstack, c);
-           break;
-
-         case '/':
-           copy_comment (finput, &action_obstack);
-           break;
-
-         case '$':
-           copy_dollar (finput, &action_obstack, rule, rule_length);
-           break;
-
-         case '@':
-           copy_at (finput, &action_obstack, rule_length);
-           break;
-
-         case EOF:
-           fatal (_("unmatched %s"), "`{'");
-
-         default:
-           copy_character (&action_obstack, c);
-         }
-
-      /* Above loop exits when C is '}'.  */
-      if (--count)
-       copy_character (&action_obstack, c);
+      merger_list *L1 = L0->next;
+      free (L0);
+      L0 = L1;
     }
     }
-
-  obstack_1grow (&action_obstack, '\0');
-  rule->action = obstack_finish (&action_obstack);
 }
 
 }
 
-\f
-
-/*-------------------------------------------------------------------.
-| Generate a dummy symbol, a nonterminal, whose name cannot conflict |
-| with the user's names.                                             |
-`-------------------------------------------------------------------*/
-
-static symbol_t *
-gensym (void)
-{
-  /* Incremented for each generated symbol */
-  static int gensym_count = 0;
-  static char buf[256];
-
-  symbol_t *sym;
-
-  sprintf (buf, "@%d", ++gensym_count);
-  token_buffer = buf;
-  sym = getsym (token_buffer);
-  sym->class = nterm_sym;
-  sym->number = nvars++;
-  return sym;
-}
 \f
 /*-------------------------------------------------------------------.
 \f
 /*-------------------------------------------------------------------.
-| Parse the input grammar into a one symbol_list structure.  Each    |
+| Parse the input grammar into a one symbol_list_t 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  |
 | 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  |
@@ -1073,13 +182,13 @@ gensym (void)
 `-------------------------------------------------------------------*/
 
 /* The (currently) last symbol of GRAMMAR. */
 `-------------------------------------------------------------------*/
 
 /* The (currently) last symbol of GRAMMAR. */
-symbol_list *grammar_end = NULL;
+symbol_list_t *grammar_end = NULL;
 
 /* Append S to the GRAMMAR. */
 
 /* Append S to the GRAMMAR. */
-static void
-grammar_symbol_append (symbol_t *s)
+void
+grammar_symbol_append (symbol_t *symbol, location_t location)
 {
 {
-  symbol_list *p = symbol_list_new (s);
+  symbol_list_t *p = symbol_list_new (symbol, location);
 
   if (grammar_end)
     grammar_end->next = p;
 
   if (grammar_end)
     grammar_end->next = p;
@@ -1089,20 +198,24 @@ grammar_symbol_append (symbol_t *s)
   grammar_end = p;
 }
 
   grammar_end = p;
 }
 
-/* The rule currently being defined, and the previous rule.  Point to
-   the first symbol of each list: their lhs.  */
-symbol_list *current_rule = NULL;
-symbol_list *previous_rule = NULL;
+/* The rule currently being defined, and the previous rule.
+   CURRENT_RULE points to the first LHS of the current rule, while
+   PREVIOUS_RULE_END points to the *end* of the previous rule (NULL).  */
+symbol_list_t *current_rule = NULL;
+symbol_list_t *previous_rule_end = NULL;
 
 
 
 
-/* Create a new rule for LHS in to the GRAMMAR. */
+/*----------------------------------------------.
+| Create a new rule for LHS in to the GRAMMAR.  |
+`----------------------------------------------*/
 
 
-static void
-grammar_rule_begin (symbol_t *lhs)
+void
+grammar_rule_begin (symbol_t *lhs, location_t location)
 {
   if (!start_flag)
     {
       startsymbol = lhs;
 {
   if (!start_flag)
     {
       startsymbol = lhs;
+      startsymbol_location = location;
       start_flag = 1;
     }
 
       start_flag = 1;
     }
 
@@ -1110,8 +223,8 @@ grammar_rule_begin (symbol_t *lhs)
   ++nrules;
   ++nritems;
 
   ++nrules;
   ++nritems;
 
-  previous_rule = grammar_end;
-  grammar_symbol_append (lhs);
+  previous_rule_end = grammar_end;
+  grammar_symbol_append (lhs, location);
   current_rule = grammar_end;
 
   /* Mark the rule's lhs as a nonterminal if not already so.  */
   current_rule = grammar_end;
 
   /* Mark the rule's lhs as a nonterminal if not already so.  */
@@ -1123,250 +236,164 @@ grammar_rule_begin (symbol_t *lhs)
       ++nvars;
     }
   else if (lhs->class == token_sym)
       ++nvars;
     }
   else if (lhs->class == token_sym)
-    complain (_("rule given for %s, which is a token"), lhs->tag);
+    complain_at (location, _("rule given for %s, which is a token"), lhs->tag);
 }
 
 }
 
-/* The previous action turns out the be a mid-rule action.  Attach it
-   to the current rule, i.e., create a dummy symbol, attach it this
-   mid-rule action, and append this dummy nonterminal to the current
-   rule.  */
+/* Check that the last rule (CURRENT_RULE) is properly defined.  For
+   instance, there should be no type clash on the default action.  */
 
 static void
 
 static void
+grammar_current_rule_check (void)
+{
+  symbol_t *lhs = current_rule->sym;
+  symbol_t *first_rhs = current_rule->next->sym;
+
+  /* If there is an action, then there is nothing we can do: the user
+     is allowed to shoot in her foot.  */
+  if (current_rule->action)
+    return;
+
+  /* If $$ is being set in default way, report if any type mismatch.
+     */
+  if (first_rhs)
+    {
+      const char *lhs_type = lhs->type_name       ? lhs->type_name       : "";
+      const char *rhs_type = first_rhs->type_name ? first_rhs->type_name : "";
+      if (strcmp (lhs_type, rhs_type))
+       complain_at (current_rule->location,
+                    _("type clash (`%s' `%s') on default action"),
+                    lhs_type, rhs_type);
+    }
+  /* Warn if there is no default for $$ but we need one.  */
+  else
+    {
+      if (lhs->type_name)
+       complain_at (current_rule->location,
+                    _("empty rule for typed nonterminal, and no action"));
+    }
+}
+
+
+/*-------------------------------------.
+| End the currently being grown rule.  |
+`-------------------------------------*/
+
+void
+grammar_rule_end (location_t location)
+{
+  /* Put an empty link in the list to mark the end of this rule  */
+  grammar_symbol_append (NULL, grammar_end->location);
+  current_rule->location = location;
+  grammar_current_rule_check ();
+}
+
+
+/*-------------------------------------------------------------------.
+| The previous action turns out the be a mid-rule action.  Attach it |
+| to the current rule, i.e., create a dummy symbol, attach it this   |
+| mid-rule action, and append this dummy nonterminal to the current  |
+| rule.                                                              |
+`-------------------------------------------------------------------*/
+
+void
 grammar_midrule_action (void)
 {
   /* 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.  */
 
 grammar_midrule_action (void)
 {
   /* 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.  */
-  symbol_t *sdummy = gensym ();
-  symbol_list *midrule_action = symbol_list_new (sdummy);
+  /* Make a DUMMY nonterminal, whose location is that of the midrule
+     action.  Create the MIDRULE.  */
+  location_t dummy_location = current_rule->action_location;
+  symbol_t *dummy = dummy_symbol_get (dummy_location);
+  symbol_list_t *midrule = symbol_list_new (dummy, dummy_location);
 
   /* Make a new rule, whose body is empty, before the current one, so
      that the action just read can belong to it.  */
   ++nrules;
   ++nritems;
 
   /* Make a new rule, whose body is empty, before the current one, so
      that the action just read can belong to it.  */
   ++nrules;
   ++nritems;
-  /* Attach its lineno to that of the host rule.  */
-  midrule_action->line = current_rule->line;
-  /* Move the action from the host rule to this one.  */
-  midrule_action->action = current_rule->action;
-  midrule_action->action_line = current_rule->action_line;
+  /* Attach its location and actions to that of the DUMMY.  */
+  midrule->location = dummy_location;
+  midrule->action = current_rule->action;
+  midrule->action_location = dummy_location;
   current_rule->action = NULL;
 
   current_rule->action = NULL;
 
-  if (previous_rule)
-    previous_rule->next = midrule_action;
+  if (previous_rule_end)
+    previous_rule_end->next = midrule;
   else
   else
-    grammar = midrule_action;
+    grammar = midrule;
 
 
-  /* End of the rule. */
-  previous_rule = symbol_list_new (NULL);
-  previous_rule->next = current_rule;
+  /* End the dummy's rule.  */
+  previous_rule_end = symbol_list_new (NULL, dummy_location);
+  previous_rule_end->next = current_rule;
 
 
-  midrule_action->next = previous_rule;
+  midrule->next = previous_rule_end;
 
 
-  /* Insert the dummy generated by that rule into this rule.  */
-  ++nritems;
-  grammar_symbol_append (sdummy);
+  /* Insert the dummy nonterminal replacing the midrule action into
+     the current rule.  */
+  grammar_current_rule_symbol_append (dummy, dummy_location);
 }
 
 }
 
+/* Set the precedence symbol of the current rule to PRECSYM. */
 
 
-static void
-readgram (void)
+void
+grammar_current_rule_prec_set (symbol_t *precsym, location_t location)
 {
 {
-  token_t t;
-  symbol_t *lhs = NULL;
-
-  t = lex ();
-
-  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 */
-       symbol_t *first_rhs = 0;
-
-       if (t == tok_identifier)
-         {
-           lhs = symval;
-
-           t = lex ();
-           if (t != tok_colon)
-             {
-               complain (_("ill-formed rule: initial symbol not followed by colon"));
-               unlex (t);
-             }
-         }
-       if (nrules == 0 && t == tok_bar)
-         {
-           complain (_("grammar starts with vertical bar"));
-           lhs = symval;       /* BOGUS: use a random symval */
-         }
-
-       grammar_rule_begin (lhs);
-       /* read the rhs of the rule.  */
-
-       for (;;)
-         {
-           t = lex ();
-           if (t == tok_prec)
-             {
-               t = lex ();
-               current_rule->ruleprec = symval;
-               t = lex ();
-             }
-
-           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 == tok_identifier)
-             {
-               symbol_t *ssave;
-               token_t t1;
-
-               ssave = symval;
-               t1 = lex ();
-               unlex (t1);
-               symval = ssave;
-               if (t1 == tok_colon)
-                 {
-                   warn (_("previous rule lacks an ending `;'"));
-                   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)
-             {
-               grammar_midrule_action ();
-               action_flag = 0;
-             }
-
-           if (t == tok_identifier)
-             {
-               ++nritems;
-               grammar_symbol_append (symval);
-             }
-           else                /* handle an action.  */
-             {
-               parse_action (current_rule, 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  */
-       grammar_symbol_append (NULL);
-
-       if (t == tok_prec)
-         {
-           complain (_("two @prec's in a row"));
-           t = lex ();
-           current_rule->ruleprec = symval;
-           t = lex ();
-         }
-
-       if (t == tok_left_curly)
-         {
-           /* This case never occurs -wjh */
-           if (action_flag)
-             complain (_("two actions at end of one rule"));
-           parse_action (current_rule, 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_two_percents || t == tok_eof)
-         warn (_("previous rule lacks an ending `;'"));
-       if (t == tok_semicolon)
-         t = lex ();
-      }
-    else
-      {
-       complain (_("invalid input: %s"), quote (token_buffer));
-       t = lex ();
-      }
-
-  /* grammar has been read.  Do some checking */
-
-  if (nrules == 0)
-    fatal (_("no rules in the input grammar"));
-
-  /* Report any undefined symbols and consider them nonterminals.  */
-  symbols_check_defined ();
+  if (current_rule->ruleprec)
+    complain_at (location, _("two @prec's in a row"));
+  current_rule->ruleprec = precsym;
+}
 
 
-  /* Insert the initial rule, which line is that of the first rule
-     (not that of the start symbol):
+/* Attach dynamic precedence DPREC to the current rule. */
 
 
-     axiom: %start EOF.  */
-  {
-    symbol_list *p = symbol_list_new (axiom);
-    p->line = grammar->line;
-    p->next = symbol_list_new (startsymbol);
-    p->next->next = symbol_list_new (eoftoken);
-    p->next->next->next = symbol_list_new (NULL);
-    p->next->next->next->next = grammar;
-    nrules += 1;
-    nritems += 3;
-    grammar = p;
-  }
+void
+grammar_current_rule_dprec_set (int dprec, location_t location)
+{
+  if (! glr_parser)
+    warn_at (location, _("%%dprec affects only GLR parsers"));
+  if (dprec <= 0)
+    complain_at (location, _("%%dprec must be followed by positive number"));
+  else if (current_rule->dprec != 0)
+    complain_at (location, _("only one %%dprec allowed per rule"));
+  current_rule->dprec = dprec;
+}
 
 
-  if (nsyms > SHRT_MAX)
-    fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
-          SHRT_MAX);
+/* Attach a merge function NAME with argument type TYPE to current
+   rule. */
 
 
-  assert (nsyms == ntokens + nvars);
+void
+grammar_current_rule_merge_set (const char* name, location_t location)
+{
+  if (! glr_parser)
+    warn_at (location, _("%%merge affects only GLR parsers"));
+  if (current_rule->merger != 0)
+    complain_at (location, _("only one %%merge allowed per rule"));
+  current_rule->merger =
+    get_merge_function (name, current_rule->sym->type_name, location);
 }
 
 }
 
-/* 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)
-{
-  int c;
-  struct obstack el_obstack;
-
-  obstack_init (&el_obstack);
+/* Attach a SYMBOL to the current rule.  If needed, move the previous
+   action as a mid-rule action.  */
 
 
-  if (!no_lines_flag)
-    {
-      obstack_fgrow2 (&el_obstack, muscle_find ("linef"),
-                     lineno, quotearg_style (c_quoting_style,
-                                             muscle_find ("filename")));
-    }
+void
+grammar_current_rule_symbol_append (symbol_t *symbol, location_t location)
+{
+  if (current_rule->action)
+    grammar_midrule_action ();
+  ++nritems;
+  grammar_symbol_append (symbol, location);
+}
 
 
-  while ((c = getc (finput)) != EOF)
-    copy_character (&el_obstack, c);
+/* Attach an ACTION to the current rule.  If needed, move the previous
+   action as a mid-rule action.  */
 
 
-  obstack_1grow (&el_obstack, 0);
-  muscle_insert ("epilogue", obstack_finish (&el_obstack));
+void
+grammar_current_rule_action_append (const char *action, location_t location)
+{
+  if (current_rule->action)
+    grammar_midrule_action ();
+  current_rule->action = action;
+  current_rule->action_location = location;
 }
 
 \f
 }
 
 \f
@@ -1378,17 +405,13 @@ read_additionnal_code (void)
 static void
 packgram (void)
 {
 static void
 packgram (void)
 {
-  unsigned int itemno;
-  int ruleno;
-  symbol_list *p;
+  unsigned int itemno = 0;
+  rule_number_t ruleno = 0;
+  symbol_list_t *p = grammar;
 
   ritem = XCALLOC (item_number_t, nritems);
 
   ritem = XCALLOC (item_number_t, nritems);
-  rules = XCALLOC (rule_t, nrules) - 1;
+  rules = XCALLOC (rule_t, nrules);
 
 
-  itemno = 0;
-  ruleno = 1;
-
-  p = grammar;
   while (p)
     {
       symbol_t *ruleprec = p->ruleprec;
   while (p)
     {
       symbol_t *ruleprec = p->ruleprec;
@@ -1396,10 +419,12 @@ packgram (void)
       rules[ruleno].number = ruleno;
       rules[ruleno].lhs = p->sym;
       rules[ruleno].rhs = ritem + itemno;
       rules[ruleno].number = ruleno;
       rules[ruleno].lhs = p->sym;
       rules[ruleno].rhs = ritem + itemno;
-      rules[ruleno].line = p->line;
+      rules[ruleno].location = p->location;
       rules[ruleno].useful = TRUE;
       rules[ruleno].action = p->action;
       rules[ruleno].useful = TRUE;
       rules[ruleno].action = p->action;
-      rules[ruleno].action_line = p->action_line;
+      rules[ruleno].action_location = p->action_location;
+      rules[ruleno].dprec = p->dprec;
+      rules[ruleno].merger = p->merger;
 
       p = p->next;
       while (p && p->sym)
 
       p = p->next;
       while (p && p->sym)
@@ -1422,7 +447,7 @@ packgram (void)
          rules[ruleno].precsym = ruleprec;
          rules[ruleno].prec = ruleprec;
        }
          rules[ruleno].precsym = ruleprec;
          rules[ruleno].prec = ruleprec;
        }
-      ritem[itemno++] = -ruleno;
+      ritem[itemno++] = rule_number_as_item_number (ruleno);
       ++ruleno;
 
       if (p)
       ++ruleno;
 
       if (p)
@@ -1431,7 +456,7 @@ packgram (void)
 
   assert (itemno == nritems);
 
 
   assert (itemno == nritems);
 
-  if (trace_flag)
+  if (trace_flag & trace_sets)
     ritem_print (stderr);
 }
 \f
     ritem_print (stderr);
 }
 \f
@@ -1445,61 +470,83 @@ packgram (void)
 void
 reader (void)
 {
 void
 reader (void)
 {
-  lex_init ();
-  lineno = 1;
-
-  /* Initialize the muscle obstack.  */
-  obstack_init (&muscle_obstack);
+  gram_control_t gram_control;
 
   /* Initialize the symbol table.  */
   symbols_new ();
 
 
   /* Initialize the symbol table.  */
   symbols_new ();
 
-  /* Construct the axiom symbol. */
-  axiom = getsym ("$axiom");
-  axiom->class = nterm_sym;
-  axiom->number = nvars++;
+  /* Construct the accept symbol. */
+  accept = symbol_get ("$accept", empty_location);
+  accept->class = nterm_sym;
+  accept->number = nvars++;
 
   /* Construct the error token */
 
   /* Construct the error token */
-  errtoken = getsym ("error");
+  errtoken = symbol_get ("error", empty_location);
   errtoken->class = token_sym;
   errtoken->number = ntokens++;
 
   /* Construct a token that represents all undefined literal tokens.
      It is always token number 2.  */
   errtoken->class = token_sym;
   errtoken->number = ntokens++;
 
   /* Construct a token that represents all undefined literal tokens.
      It is always token number 2.  */
-  undeftoken = getsym ("$undefined.");
+  undeftoken = symbol_get ("$undefined", empty_location);
   undeftoken->class = token_sym;
   undeftoken->number = ntokens++;
 
   /* Initialize the obstacks. */
   undeftoken->class = token_sym;
   undeftoken->number = ntokens++;
 
   /* Initialize the obstacks. */
-  obstack_init (&action_obstack);
-  obstack_init (&output_obstack);
   obstack_init (&pre_prologue_obstack);
   obstack_init (&post_prologue_obstack);
 
   finput = xfopen (infile, "r");
   obstack_init (&pre_prologue_obstack);
   obstack_init (&post_prologue_obstack);
 
   finput = xfopen (infile, "r");
+  gram_in = finput;
+
+  gram_debug = !!getenv ("parse");
+  gram__flex_debug = !!getenv ("scan");
+  scanner_initialize ();
+  gram_parse (&gram_control);
+
+  /* If something went wrong during the parsing, don't try to
+     continue.  */
+  if (complain_message_count)
+    exit (1);
+
+  /* Grammar has been read.  Do some checking */
+  if (nrules == 0)
+    fatal (_("no rules in the input grammar"));
 
 
-  /* Read the declaration section.  Copy %{ ... %} groups to
-     TABLE_OBSTACK and FDEFINES file.  Also notice any %token, %left,
-     etc. found there.  */
-  read_declarations ();
+  /* Report any undefined symbols and consider them nonterminals.  */
+  symbols_check_defined ();
 
 
-  /* If the user did not define her EOFTOKEN, do it now. */
-  if (!eoftoken)
+  /* If the user did not define her ENDTOKEN, do it now. */
+  if (!endtoken)
     {
     {
-      eoftoken = getsym ("$");
-      eoftoken->class = token_sym;
-      eoftoken->number = 0;
+      endtoken = symbol_get ("$end", empty_location);
+      endtoken->class = token_sym;
+      endtoken->number = 0;
       /* Value specified by POSIX.  */
       /* Value specified by POSIX.  */
-      eoftoken->user_token_number = 0;
+      endtoken->user_token_number = 0;
     }
 
     }
 
-  /* Read in the grammar, build grammar in list form.  Write out
-     actions.  */
-  readgram ();
-  /* Some C code is given at the end of the grammar file. */
-  read_additionnal_code ();
+  /* Insert the initial rule, which line is that of the first rule
+     (not that of the start symbol):
+
+     accept: %start EOF.  */
+  {
+    symbol_list_t *p = symbol_list_new (accept, empty_location);
+    p->location = grammar->location;
+    p->next = symbol_list_new (startsymbol, empty_location);
+    p->next->next = symbol_list_new (endtoken, empty_location);
+    p->next->next->next = symbol_list_new (NULL, empty_location);
+    p->next->next->next->next = grammar;
+    nrules += 1;
+    nritems += 3;
+    grammar = p;
+  }
+
+  if (nsyms > SHRT_MAX)
+    fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
+          SHRT_MAX);
+
+  assert (nsyms == ntokens + nvars);
 
 
-  lex_free ();
   xfclose (finput);
 
   /* Assign the symbols their symbol numbers.  Write #defines for the
   xfclose (finput);
 
   /* Assign the symbols their symbol numbers.  Write #defines for the
@@ -1509,6 +556,6 @@ reader (void)
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();
 
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();
 
-  /* The grammar as a symbol_list is no longer needed. */
-  LIST_FREE (symbol_list, grammar);
+  /* The grammar as a symbol_list_t is no longer needed. */
+  LIST_FREE (symbol_list_t, grammar);
 }
 }