]> git.saurik.com Git - bison.git/blobdiff - src/reader.c
maint: make update-b4-copyright easier to use
[bison.git] / src / reader.c
index cdacc071cc722fe857a9626ea728bdc2e007e64d..3f224bf5c02ee07ae93d603a5709ec75045f060b 100644 (file)
-/* Input parser for bison
-   Copyright (C) 1984, 1986, 1989, 1992, 1998, 2000
-   Free Software Foundation, Inc.
+/* Input parser for Bison
+
+   Copyright (C) 1984, 1986, 1989, 1992, 1998, 2000, 2001, 2002, 2003,
+   2005, 2006, 2007, 2009 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 
-   Bison is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
 
 
-   Bison is distributed in the hope that it will be useful,
+   This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with Bison; see the file COPYING.  If not, write to
-   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
+#include <config.h>
 #include "system.h"
 #include "system.h"
-#include "getargs.h"
+
+#include <quote.h>
+#include <quotearg.h>
+
+#include "complain.h"
+#include "conflicts.h"
 #include "files.h"
 #include "files.h"
-#include "xalloc.h"
-#include "symtab.h"
-#include "lex.h"
+#include "getargs.h"
 #include "gram.h"
 #include "gram.h"
-#include "complain.h"
-#include "output.h"
+#include "muscle-tab.h"
 #include "reader.h"
 #include "reader.h"
-#include "conflicts.h"
-#include "quote.h"
-
-/* Number of slots allocated (but not necessarily used yet) in `rline'  */
-static int rline_allocated;
-
-typedef struct symbol_list
-{
-  struct symbol_list *next;
-  bucket *sym;
-  bucket *ruleprec;
-}
-symbol_list;
-
-int lineno;
-char **tags;
-short *user_toknums;
-static symbol_list *grammar;
-static int start_flag;
-static bucket *startval;
+#include "symlist.h"
+#include "symtab.h"
+#include "scan-gram.h"
+#include "scan-code.h"
 
 
-/* Nonzero if components of semantic values are used, implying
-   they must be unions.  */
-static int value_components_used;
+static void check_and_convert_grammar (void);
 
 
-/* Nonzero if %union has been seen.  */
-static int typed;
+static symbol_list *grammar = NULL;
+static bool start_flag = false;
+merger_list *merge_functions;
 
 
-/* Incremented for each %left, %right or %nonassoc seen */
-static int lastprec;
+/* Was %union seen?  */
+bool union_seen = false;
 
 
-/* Incremented for each generated symbol */
-static int gensym_count;
+/* Was a tag seen?  */
+bool tag_seen = false;
 
 
-static bucket *errtoken;
-static bucket *undeftoken;
+/* Should rules have a default precedence?  */
+bool default_prec = true;
 \f
 \f
+/*-----------------------.
+| Set the start symbol.  |
+`-----------------------*/
 
 
-/*===================\
-| Low level lexing.  |
-\===================*/
-
-static void
-skip_to_char (int target)
+void
+grammar_start_symbol_set (symbol *sym, location loc)
 {
 {
-  int c;
-  if (target == '\n')
-    complain (_("   Skipping to next \\n"));
+  if (start_flag)
+    complain_at (loc, _("multiple %s declarations"), "%start");
   else
   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;
+      start_flag = true;
+      startsymbol = sym;
+      startsymbol_location = loc;
     }
     }
-
-  while (isdigit (c))
-    {
-      n = 10 * n + (c - '0');
-      c = getc (stream);
-    }
-
-  ungetc (c, stream);
-
-  return sign * n;
 }
 }
-\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
 \f
-/*-------------------------------------------------------------------.
-| Dump the string from FINPUT to FOUTPUT.  MATCH is the delimiter of |
-| the string (either ' or ").                                        |
-`-------------------------------------------------------------------*/
-
-static inline void
-copy_string (FILE *fin, FILE *fout, int match)
-{
-  int c;
 
 
-  putc (match, fout);
-  c = getc (fin);
+/*------------------------------------------------------------------------.
+| Return the merger index for a merging function named NAME.  Records the |
+| function, if new, in MERGER_LIST.                                       |
+`------------------------------------------------------------------------*/
 
 
-  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;
-       }
-
-      putc (c, fout);
-
-      if (c == '\\')
-       {
-         c = getc (fin);
-         if (c == EOF)
-           fatal (_("unterminated string at end of file"));
-         putc (c, fout);
-         if (c == '\n')
-           lineno++;
-       }
-
-      c = getc (fin);
-    }
-
-  putc (c, fout);
-}
-
-
-/*---------------------------------------------------------------.
-| Dump the comment from IN to OUT1 and OUT2.  C is either `*' or |
-| `/', depending upon the type of comments used.  OUT2 might be  |
-| NULL.                                                          |
-`---------------------------------------------------------------*/
-
-static inline void
-copy_comment2 (FILE *in, FILE *out1, FILE *out2, int c)
+static int
+get_merge_function (uniqstr name)
 {
 {
-  int cplus_comment;
-  int ended;
-
-  cplus_comment = (c == '/');
-  putc (c, out1);
-  if (out2)
-    putc (c, out2);
-  c = getc (in);
-
-  ended = 0;
-  while (!ended)
-    {
-      if (!cplus_comment && c == '*')
-       {
-         while (c == '*')
-           {
-             putc (c, out1);
-             if (out2)
-               putc (c, out2);
-             c = getc (in);
-           }
-
-         if (c == '/')
-           {
-             putc (c, out1);
-             if (out2)
-               putc (c, out2);
-             ended = 1;
-           }
-       }
-      else if (c == '\n')
-       {
-         lineno++;
-         putc (c, out1);
-         if (out2)
-           putc (c, out2);
-         if (cplus_comment)
-           ended = 1;
-         else
-           c = getc (in);
-       }
-      else if (c == EOF)
-       fatal (_("unterminated comment"));
-      else
-       {
-         putc (c, out1);
-         if (out2)
-           putc (c, out2);
-         c = getc (in);
-       }
-    }
+  merger_list *syms;
+  merger_list head;
+  int n;
+
+  if (! glr_parser)
+    return 0;
+
+  head.next = merge_functions;
+  for (syms = &head, n = 1; syms->next; syms = syms->next, n += 1)
+    if (UNIQSTR_EQ (name, syms->next->name))
+      break;
+  if (syms->next == NULL)
+    {
+      syms->next = xmalloc (sizeof syms->next[0]);
+      syms->next->name = uniqstr_new (name);
+      /* After all symbol type declarations have been parsed, packgram invokes
+        record_merge_function_type to set the type.  */
+      syms->next->type = NULL;
+      syms->next->next = NULL;
+      merge_functions = head.next;
+    }
+  return n;
 }
 
 }
 
+/*-------------------------------------------------------------------------.
+| For the existing merging function with index MERGER, record the result   |
+| type as TYPE as required by the lhs of the rule whose %merge declaration |
+| is at DECLARATION_LOC.                                                   |
+`-------------------------------------------------------------------------*/
 
 
-/*------------------------------------------------------------.
-| Dump the comment from FIN to FOUT.  C is either `*' or `/', |
-| depending upon the type of comments used.                   |
-`------------------------------------------------------------*/
-
-static inline void
-copy_comment (FILE *fin, FILE *fout, int c)
+static void
+record_merge_function_type (int merger, uniqstr type, location declaration_loc)
 {
 {
-  copy_comment2 (fin, fout, NULL, c);
+  int merger_find;
+  merger_list *merge_function;
+
+  if (merger <= 0)
+    return;
+
+  if (type == NULL)
+    type = uniqstr_new ("");
+
+  merger_find = 1;
+  for (merge_function = merge_functions;
+       merge_function != NULL && merger_find != merger;
+       merge_function = merge_function->next)
+    merger_find += 1;
+  aver (merge_function != NULL && merger_find == merger);
+  if (merge_function->type != NULL && !UNIQSTR_EQ (merge_function->type, type))
+    {
+      complain_at (declaration_loc,
+                  _("result type clash on merge function `%s': <%s> != <%s>"),
+                  merge_function->name, type, merge_function->type);
+      complain_at (merge_function->type_declaration_location,
+                  _("previous declaration"));
+    }
+  merge_function->type = uniqstr_new (type);
+  merge_function->type_declaration_location = declaration_loc;
 }
 
 }
 
+/*--------------------------------------.
+| Free all merge-function definitions. |
+`--------------------------------------*/
 
 
-/*-----------------------------------------------------------------.
-| FIN is pointing to a location (i.e., a `@').  Output to FOUT a   |
-| reference to this location. STACK_OFFSET is the number of values |
-| in the current rule so far, which says where to find `$0' with   |
-| respect to the top of the stack.                                 |
-`-----------------------------------------------------------------*/
-
-static inline void
-copy_at (FILE *fin, FILE *fout, int stack_offset)
+void
+free_merger_functions (void)
 {
 {
-  int c;
-
-  c = getc (fin);
-  if (c == '$')
+  merger_list *L0 = merge_functions;
+  while (L0)
     {
     {
-      fprintf (fout, "yyloc");
-      locations_flag = 1;
-    }
-  else if (isdigit (c) || c == '-')
-    {
-      int n;
-
-      ungetc (c, fin);
-      n = read_signed_integer (fin);
-
-      fprintf (fout, "yylsp[%d]", n - stack_offset);
-      locations_flag = 1;
-    }
-  else
-    {
-      char buf[] = "@c";
-      buf[1] = c;
-      complain (_("%s is invalid"), quote (buf));
+      merger_list *L1 = L0->next;
+      free (L0);
+      L0 = L1;
     }
 }
 
     }
 }
 
-
+\f
 /*-------------------------------------------------------------------.
 /*-------------------------------------------------------------------.
-| FIN is pointing to a wannabee semantic value (i.e., a `$').        |
+| 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.                           |
 |                                                                    |
 |                                                                    |
-| Possible inputs: $[<TYPENAME>]($|integer)                          |
-|                                                                    |
-| Output to FOUT a reference to this semantic value. STACK_OFFSET is |
-| the number of values in the current rule so far, which says where  |
-| to find `$0' with respect to the top of the stack.                 |
+| All actions are copied out, labelled by the rule number they apply |
+| to.                                                                |
 `-------------------------------------------------------------------*/
 
 `-------------------------------------------------------------------*/
 
-static inline void
-copy_dollar (FILE *fin, FILE *fout,
-            symbol_list *rule, int stack_offset)
-{
-  int c = getc (fin);
-  char *type_name = NULL;
-
-  /* Get the typename if explicit. */
-  if (c == '<')
-    {
-      char *cp = token_buffer;
-
-      while ((c = getc (fin)) != '>' && c > 0)
-       {
-         if (cp == token_buffer + maxtoken)
-           cp = grow_token_buffer (cp);
-
-         *cp++ = c;
-       }
-      *cp = 0;
-      type_name = token_buffer;
-      value_components_used = 1;
-
-      c = getc (fin);
-    }
-
-  if (c == '$')
-    {
-      fprintf (fout, "yyval");
-      if (!type_name)
-       type_name = get_type_name (0, rule);
-      if (type_name)
-       fprintf (fout, ".%s", type_name);
-      if (!type_name && typed)
-       complain (_("$$ of `%s' has no declared type"),
-                 rule->sym->tag);
-    }
-  else if (isdigit (c) || c == '-')
-    {
-      int n;
-      ungetc (c, fin);
-      n = read_signed_integer (fin);
-
-      if (!type_name && n > 0)
-       type_name = get_type_name (n, rule);
-
-      fprintf (fout, "yyvsp[%d]", n - stack_offset);
-      if (type_name)
-       fprintf (fout, ".%s", type_name);
-      if (!type_name && typed)
-       complain (_("$%d of `%s' has no declared type"),
-                 n, rule->sym->tag);
-    }
-  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 `%}'.        |
-`-------------------------------------------------------------------*/
+/* The (currently) last symbol of GRAMMAR. */
+static symbol_list *grammar_end = NULL;
 
 
-static void
-copy_definition (void)
+/* Append SYM to the grammar.  */
+static symbol_list *
+grammar_symbol_append (symbol *sym, location loc)
 {
 {
-  int c;
-  /* -1 while reading a character if prev char was %. */
-  int after_percent;
-
-  if (!no_lines_flag)
-    fprintf (fattrs, "#line %d \"%s\"\n", lineno, infile);
-
-  after_percent = 0;
+  symbol_list *p = symbol_list_sym_new (sym, loc);
 
 
-  c = getc (finput);
-
-  for (;;)
-    {
-      switch (c)
-       {
-       case '\n':
-         putc (c, fattrs);
-         lineno++;
-         break;
-
-       case '%':
-         after_percent = -1;
-         break;
-
-       case '\'':
-       case '"':
-         copy_string (finput, fattrs, c);
-         break;
-
-       case '/':
-         putc (c, fattrs);
-         c = getc (finput);
-         if (c != '*' && c != '/')
-           continue;
-         copy_comment (finput, fattrs, c);
-         break;
-
-       case EOF:
-         fatal ("%s", _("unterminated `%{' definition"));
-
-       default:
-         putc (c, fattrs);
-       }
-
-      c = getc (finput);
+  if (grammar_end)
+    grammar_end->next = p;
+  else
+    grammar = p;
 
 
-      if (after_percent)
-       {
-         if (c == '}')
-           return;
-         putc ('%', fattrs);
-       }
-      after_percent = 0;
+  grammar_end = p;
 
 
-    }
+  /* A null SYM stands for an end of rule; it is not an actual
+     part of it.  */
+  if (sym)
+    ++nritems;
 
 
+  return p;
 }
 
 }
 
-
-/*-------------------------------------------------------------------.
-| Parse what comes after %token or %nterm.  For %token, WHAT_IS is   |
-| token_sym and WHAT_IS_NOT is nterm_sym.  For %nterm, the arguments |
-| are reversed.                                                      |
-`-------------------------------------------------------------------*/
-
 static void
 static void
-parse_token_decl (symbol_class what_is, symbol_class what_is_not)
+assign_named_ref (symbol_list *p, named_ref *name)
 {
 {
-  int token = 0;
-  char *typename = 0;
-  struct bucket *symbol = NULL;        /* pts to symbol being defined */
+  symbol *sym = p->content.sym;
 
 
-  for (;;)
+  if (name->id == sym->tag)
     {
     {
-      int tmp_char = ungetc (skip_white_space (), finput);
-
-      if (tmp_char == '%')
-       return;
-      if (tmp_char == EOF)
-       fatal (_("Premature EOF after %s"), token_buffer);
-
-      token = lex ();
-      if (token == COMMA)
-       {
-         symbol = NULL;
-         continue;
-       }
-      if (token == TYPENAME)
-       {
-         typename = xstrdup (token_buffer);
-         value_components_used = 1;
-         symbol = NULL;
-       }
-      else if (token == IDENTIFIER && *symval->tag == '\"' && symbol)
-       {
-         if (symval->alias)
-           warn (_("symbol `%s' used more than once as a literal string"),
-                 symval->tag);
-         else if (symbol->alias)
-           warn (_("symbol `%s' given more than one literal string"),
-                 symbol->tag);
-         else
-           {
-             symval->class = token_sym;
-             symval->type_name = typename;
-             symval->user_token_number = symbol->user_token_number;
-             symbol->user_token_number = SALIAS;
-             symval->alias = symbol;
-             symbol->alias = symval;
-             /* symbol and symval combined are only one symbol */
-             nsyms--;
-           }
-         translations = 1;
-         symbol = NULL;
-       }
-      else if (token == IDENTIFIER)
-       {
-         int oldclass = symval->class;
-         symbol = symval;
-
-         if (symbol->class == what_is_not)
-           complain (_("symbol %s redefined"), symbol->tag);
-         symbol->class = what_is;
-         if (what_is == nterm_sym && oldclass != nterm_sym)
-           symbol->value = nvars++;
-
-         if (typename)
-           {
-             if (symbol->type_name == NULL)
-               symbol->type_name = typename;
-             else if (strcmp (typename, symbol->type_name) != 0)
-               complain (_("type redeclaration for %s"), symbol->tag);
-           }
-       }
-      else if (symbol && token == NUMBER)
-       {
-         symbol->user_token_number = numval;
-         translations = 1;
-       }
-      else
-       {
-         complain (_("`%s' is invalid in %s"),
-                   token_buffer, (what_is == token_sym) ? "%token" : "%nterm");
-         skip_to_char ('%');
-       }
+      warn_at (name->loc,
+              _("duplicated symbol name for %s ignored"),
+              quote (sym->tag));
+      named_ref_free (name);
     }
     }
-
-}
-
-
-/*------------------------------.
-| Parse what comes after %start |
-`------------------------------*/
-
-static void
-parse_start_decl (void)
-{
-  if (start_flag)
-    complain (_("multiple %s declarations"), "%start");
-  if (lex () != IDENTIFIER)
-    complain (_("invalid %s declaration"), "%start");
   else
   else
-    {
-      start_flag = 1;
-      startval = symval;
-    }
+    p->named_ref = name;
 }
 
 }
 
-/*-----------------------------------------------------------.
-| 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 () != TYPENAME)
-    {
-      complain ("%s", _("%type declaration has no <typename>"));
-      skip_to_char ('%');
-      return;
-    }
 
 
-  name = xstrdup (token_buffer);
+/* 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).  */
+static symbol_list *current_rule = NULL;
+static symbol_list *previous_rule_end = NULL;
 
 
-  for (;;)
-    {
-      int 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)
-       {
+/*----------------------------------------------.
+| Create a new rule for LHS in to the GRAMMAR.  |
+`----------------------------------------------*/
 
 
-       case COMMA:
-       case SEMICOLON:
-         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:
-         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.                                                    |
-`----------------------------------------------------------------*/
-
-static void
-parse_assoc_decl (associativity assoc)
-{
-  char *name = NULL;
-  int prev = 0;
-
-  lastprec++;                  /* Assign a new precedence level, never 0.  */
-
-  for (;;)
-    {
-      int 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 TYPENAME:
-         name = xstrdup (token_buffer);
-         break;
-
-       case COMMA:
-         break;
-
-       case IDENTIFIER:
-         if (symval->prec != 0)
-           complain (_("redefining precedence of %s"), symval->tag);
-         symval->prec = lastprec;
-         symval->assoc = assoc;
-         if (symval->class == nterm_sym)
-           complain (_("symbol %s redefined"), symval->tag);
-         symval->class = token_sym;
-         if (name)
-           {                   /* record the type, if one is specified */
-             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;
-
-       case NUMBER:
-         if (prev == IDENTIFIER)
-           {
-             symval->user_token_number = numval;
-             translations = 1;
-           }
-         else
-           {
-             complain (_
-                       ("invalid text (%s) - number should be after identifier"),
-token_buffer);
-             skip_to_char ('%');
-           }
-         break;
-
-       case SEMICOLON:
-         return;
-
-       default:
-         complain (_("unexpected item: %s"), token_buffer);
-         skip_to_char ('%');
-       }
-
-      prev = t;
-
-    }
-}
-
-
-
-/*-------------------------------------------------------------------.
-| Copy the union declaration into fattrs (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
+grammar_current_rule_begin (symbol *lhs, location loc,
+                           named_ref *lhs_name)
 {
 {
-  int c;
-  int count = 0;
+  symbol_list* p;
 
 
-  if (typed)
-    complain (_("multiple %s declarations"), "%union");
+  /* Start a new rule and record its lhs.  */
+  ++nrules;
+  previous_rule_end = grammar_end;
 
 
-  typed = 1;
+  p = grammar_symbol_append (lhs, loc);
+  if (lhs_name)
+    assign_named_ref(p, lhs_name);
 
 
-  if (!no_lines_flag)
-    fprintf (fattrs, "\n#line %d \"%s\"\n", lineno, infile);
-  else
-    fprintf (fattrs, "\n");
-
-  fprintf (fattrs, "typedef union");
-  if (fdefines)
-    fprintf (fdefines, "typedef union");
+  current_rule = grammar_end;
 
 
-  c = getc (finput);
-
-  while (c != EOF)
+  /* Mark the rule's lhs as a nonterminal if not already so.  */
+  if (lhs->class == unknown_sym)
     {
     {
-      putc (c, fattrs);
-      if (fdefines)
-       putc (c, fdefines);
-
-      switch (c)
-       {
-       case '\n':
-         lineno++;
-         break;
-
-       case '/':
-         c = getc (finput);
-         if (c != '*' && c != '/')
-           continue;
-         copy_comment2 (finput, fattrs, fdefines, c);
-         break;
-
-
-       case '{':
-         count++;
-         break;
-
-       case '}':
-         if (count == 0)
-           complain (_("unmatched %s"), "`}'");
-         count--;
-         if (count <= 0)
-           {
-             fprintf (fattrs, " YYSTYPE;\n");
-             if (fdefines)
-               fprintf (fdefines, " YYSTYPE;\n");
-             /* JF don't choke on trailing semi */
-             c = skip_white_space ();
-             if (c != ';')
-               ungetc (c, finput);
-             return;
-           }
-       }
-
-      c = getc (finput);
+      lhs->class = nterm_sym;
+      lhs->number = nvars;
+      ++nvars;
     }
     }
+  else if (lhs->class == token_sym)
+    complain_at (loc, _("rule given for %s, which is a token"), lhs->tag);
 }
 
 
 }
 
 
-/*-------------------------------------------------------.
-| Parse the declaration %expect N which says to expect N |
-| shift-reduce conflicts.                                |
-`-------------------------------------------------------*/
+/*----------------------------------------------------------------------.
+| A symbol should be used if either:                                    |
+|   1. It has a destructor.                                             |
+|   2. --warnings=midrule-values and the symbol is a mid-rule symbol    |
+|      (i.e., the generated LHS replacing a mid-rule action) that was   |
+|      assigned to or used, as in "exp: { $$ = 1; } { $$ = $1; }".      |
+`----------------------------------------------------------------------*/
 
 
-static void
-parse_expect_decl (void)
+static bool
+symbol_should_be_used (symbol_list const *s)
 {
 {
-  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);
+  if (symbol_destructor_get (s->content.sym)->code)
+    return true;
+  if (warnings_flag & warnings_midrule_values)
+    return ((s->midrule && s->midrule->action_props.is_value_used)
+           || (s->midrule_parent_rule
+               && symbol_list_n_get (s->midrule_parent_rule,
+                                     s->midrule_parent_rhs_index)
+                     ->action_props.is_value_used));
+  return false;
 }
 
 }
 
-
-/*-------------------------------------------------------------------.
-| Parse what comes after %thong.  the full syntax is                 |
-|                                                                    |
-|                %thong <type> token number literal                  |
-|                                                                    |
-| the <type> or number may be omitted.  The number specifies the     |
-| user_token_number.                                                 |
-|                                                                    |
-| Two symbols are entered in the table, one for the token symbol and |
-| one for the literal.  Both are given the <type>, if any, from the  |
-| declaration.  The ->user_token_number of the first is SALIAS and   |
-| the ->user_token_number of the second is set to the number, if     |
-| any, from the declaration.  The two symbols are linked via         |
-| pointers in their ->alias fields.                                  |
-|                                                                    |
-| During OUTPUT_DEFINES_TABLE, the symbol is reported thereafter,    |
-| only the literal string is retained it is the literal string that  |
-| is output to yytname                                               |
-`-------------------------------------------------------------------*/
-
-static void
-parse_thong_decl (void)
-{
-  int token;
-  struct bucket *symbol;
-  char *typename = 0;
-  int usrtoknum;
-
-  translations = 1;
-  token = lex ();              /* fetch typename or first token */
-  if (token == TYPENAME)
-    {
-      typename = xstrdup (token_buffer);
-      value_components_used = 1;
-      token = lex ();          /* fetch first token */
-    }
-
-  /* process first token */
-
-  if (token != IDENTIFIER)
-    {
-      complain (_("unrecognized item %s, expected an identifier"),
-               token_buffer);
-      skip_to_char ('%');
-      return;
-    }
-  symval->class = token_sym;
-  symval->type_name = typename;
-  symval->user_token_number = SALIAS;
-  symbol = symval;
-
-  token = lex ();              /* get number or literal string */
-
-  if (token == NUMBER)
-    {
-      usrtoknum = numval;
-      token = lex ();          /* okay, did number, now get literal */
-    }
-  else
-    usrtoknum = 0;
-
-  /* process literal string token */
-
-  if (token != IDENTIFIER || *symval->tag != '\"')
-    {
-      complain (_("expected string constant instead of %s"), token_buffer);
-      skip_to_char ('%');
-      return;
-    }
-  symval->class = token_sym;
-  symval->type_name = typename;
-  symval->user_token_number = usrtoknum;
-
-  symval->alias = symbol;
-  symbol->alias = symval;
-
-  /* symbol and symval combined are only one symbol.  */
-  nsyms--;
-}
-
-
 /*----------------------------------------------------------------.
 /*----------------------------------------------------------------.
-| Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
-| any `%' declarations, and copy the contents of any `%{ ... %}'  |
-| groups to fattrs.                                               |
+| Check that the rule R is properly defined.  For instance, there |
+| should be no type clash on the default action.                  |
 `----------------------------------------------------------------*/
 
 static void
 `----------------------------------------------------------------*/
 
 static void
-read_declarations (void)
+grammar_rule_check (const symbol_list *r)
 {
 {
-  int c;
-  int tok;
+  /* Type check.
 
 
-  for (;;)
-    {
-      c = skip_white_space ();
+     If there is an action, then there is nothing we can do: the user
+     is allowed to shoot herself in the foot.
 
 
-      if (c == '%')
+     Don't worry about the default action if $$ is untyped, since $$'s
+     value can't be used.  */
+  if (!r->action_props.code && r->content.sym->type_name)
+    {
+      symbol *first_rhs = r->next->content.sym;
+      /* If $$ is being set in default way, report if any type mismatch.  */
+      if (first_rhs)
        {
        {
-         tok = parse_percent_token ();
-
-         switch (tok)
-           {
-           case TWO_PERCENTS:
-             return;
-
-           case PERCENT_LEFT_CURLY:
-             copy_definition ();
-             break;
-
-           case TOKEN:
-             parse_token_decl (token_sym, nterm_sym);
-             break;
-
-           case NTERM:
-             parse_token_decl (nterm_sym, token_sym);
-             break;
-
-           case TYPE:
-             parse_type_decl ();
-             break;
-
-           case START:
-             parse_start_decl ();
-             break;
-
-           case UNION:
-             parse_union_decl ();
-             break;
-
-           case EXPECT:
-             parse_expect_decl ();
-             break;
-           case THONG:
-             parse_thong_decl ();
-             break;
-
-           case LEFT:
-             parse_assoc_decl (left_assoc);
-             break;
-
-           case RIGHT:
-             parse_assoc_decl (right_assoc);
-             break;
-
-           case NONASSOC:
-             parse_assoc_decl (non_assoc);
-             break;
-
-           case SEMANTIC_PARSER:
-             if (semantic_parser == 0)
-               {
-                 semantic_parser = 1;
-                 open_extra_files ();
-               }
-             break;
-
-           case PURE_PARSER:
-             pure_parser = 1;
-             break;
-
-           case NOOP:
-             break;
-
-           default:
-             complain (_("unrecognized: %s"), token_buffer);
-             skip_to_char ('%');
-           }
+         char const *lhs_type = r->content.sym->type_name;
+         const char *rhs_type =
+           first_rhs->type_name ? first_rhs->type_name : "";
+         if (!UNIQSTR_EQ (lhs_type, rhs_type))
+           warn_at (r->location,
+                    _("type clash on default action: <%s> != <%s>"),
+                    lhs_type, rhs_type);
        }
        }
-      else if (c == EOF)
-       fatal (_("no input grammar"));
+      /* Warn if there is no default for $$ but we need one.  */
       else
       else
-       {
-         char buf[] = "c";
-         buf[0] = c;
-         complain (_("unknown character: %s"), quote (buf));
-         skip_to_char ('%');
+       warn_at (r->location,
+                _("empty rule for typed nonterminal, and no action"));
+    }
+
+  /* Check that symbol values that should be used are in fact used.  */
+  {
+    symbol_list const *l = r;
+    int n = 0;
+    for (; l && l->content.sym; l = l->next, ++n)
+      if (! (l->action_props.is_value_used
+            || !symbol_should_be_used (l)
+            /* The default action, $$ = $1, `uses' both.  */
+            || (!r->action_props.code && (n == 0 || n == 1))))
+       {
+         if (n)
+           warn_at (r->location, _("unused value: $%d"), n);
+         else
+           warn_at (r->location, _("unset value: $$"));
        }
        }
-    }
+  }
 }
 }
-\f
-/*-------------------------------------------------------------------.
-| Assuming that a `{' has just been seen, copy everything up to the  |
-| 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.                              |
-`-------------------------------------------------------------------*/
 
 
-static void
-copy_action (symbol_list *rule, int stack_offset)
-{
-  int c;
-  int count;
-
-  /* offset is always 0 if parser has already popped the stack pointer */
-  if (semantic_parser)
-    stack_offset = 0;
-
-  fprintf (faction, "\ncase %d:\n", nrules);
-  if (!no_lines_flag)
-    fprintf (faction, "#line %d \"%s\"\n", lineno, infile);
-  putc ('{', faction);
 
 
-  count = 1;
-  c = getc (finput);
-
-  while (count > 0)
-    {
-      while (c != '}')
-       {
-         switch (c)
-           {
-           case '\n':
-             putc (c, faction);
-             lineno++;
-             break;
-
-           case '{':
-             putc (c, faction);
-             count++;
-             break;
-
-           case '\'':
-           case '"':
-             copy_string (finput, faction, c);
-             break;
-
-           case '/':
-             putc (c, faction);
-             c = getc (finput);
-             if (c != '*' && c != '/')
-               continue;
-             copy_comment (finput, faction, c);
-             break;
-
-           case '$':
-             copy_dollar (finput, faction, rule, stack_offset);
-             break;
-
-           case '@':
-             copy_at (finput, faction, stack_offset);
-             break;
-
-           case EOF:
-             fatal (_("unmatched %s"), "`{'");
-
-           default:
-             putc (c, faction);
-           }
-
-         c = getc (finput);
-       }
+/*-------------------------------------.
+| End the currently being grown rule.  |
+`-------------------------------------*/
 
 
-      /* above loop exits when c is '}' */
+void
+grammar_current_rule_end (location loc)
+{
+  /* Put an empty link in the list to mark the end of this rule  */
+  grammar_symbol_append (NULL, grammar_end->location);
+  current_rule->location = loc;
+}
 
 
-      if (--count)
-       {
-         putc (c, faction);
-         c = getc (finput);
-       }
-    }
 
 
-  fprintf (faction, ";\n    break;}");
-}
-\f
 /*-------------------------------------------------------------------.
 /*-------------------------------------------------------------------.
-| 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.              |
+| 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.                                                              |
 `-------------------------------------------------------------------*/
 
 `-------------------------------------------------------------------*/
 
-static void
-copy_guard (symbol_list *rule, int stack_offset)
+void
+grammar_midrule_action (void)
 {
 {
-  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;
-
-  fprintf (fguard, "\ncase %d:\n", nrules);
-  if (!no_lines_flag)
-    fprintf (fguard, "#line %d \"%s\"\n", lineno, infile);
-  putc ('{', fguard);
-
-  count = 0;
-  c = getc (finput);
-
-  while (brace_flag ? (count > 0) : (c != ';'))
-    {
-      switch (c)
-       {
-       case '\n':
-         putc (c, fguard);
-         lineno++;
-         break;
-
-       case '{':
-         putc (c, fguard);
-         brace_flag = 1;
-         count++;
-         break;
-
-       case '}':
-         putc (c, fguard);
-         if (count > 0)
-           count--;
-         else
-           {
-             complain (_("unmatched %s"), "`}'");
-             c = getc (finput);        /* skip it */
-           }
-         break;
-
-       case '\'':
-       case '"':
-         copy_string (finput, fguard, c);
-         break;
-
-       case '/':
-         putc (c, fguard);
-         c = getc (finput);
-         if (c != '*' && c != '/')
-           continue;
-         copy_comment (finput, fguard, c);
-         break;
-
-       case '$':
-         copy_dollar (finput, fguard, rule, stack_offset);
-         break;
-
-       case '@':
-         copy_at (finput, fguard, stack_offset);
-         break;
-
-       case EOF:
-         fatal ("%s", _("unterminated %guard clause"));
-
-       default:
-         putc (c, fguard);
-       }
+  /* 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, whose location is that of the midrule
+     action.  Create the MIDRULE.  */
+  location dummy_location = current_rule->action_props.location;
+  symbol *dummy = dummy_symbol_get (dummy_location);
+  symbol_list *midrule = symbol_list_sym_new (dummy, dummy_location);
+
+  /* Remember named_ref of previous action. */
+  named_ref *action_name = current_rule->action_props.named_ref;
+
+  /* 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 location and actions to that of the DUMMY.  */
+  midrule->location = dummy_location;
+  code_props_rule_action_init (&midrule->action_props,
+                               current_rule->action_props.code,
+                               current_rule->action_props.location,
+                               midrule, 0);
+  code_props_none_init (&current_rule->action_props);
+
+  if (previous_rule_end)
+    previous_rule_end->next = midrule;
+  else
+    grammar = midrule;
 
 
-      if (c != '}' || count != 0)
-       c = getc (finput);
-    }
+  /* End the dummy's rule.  */
+  midrule->next = symbol_list_sym_new (NULL, dummy_location);
+  midrule->next->next = current_rule;
 
 
-  c = skip_white_space ();
+  previous_rule_end = midrule->next;
 
 
-  fprintf (fguard, ";\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);
+  /* Insert the dummy nonterminal replacing the midrule action into
+     the current rule.  Bind it to its dedicated rule.  */
+  grammar_current_rule_symbol_append (dummy, dummy_location,
+                                      action_name);
+  grammar_end->midrule = midrule;
+  midrule->midrule_parent_rule = current_rule;
+  midrule->midrule_parent_rhs_index = symbol_list_length (current_rule->next);
 }
 }
-\f
 
 
-static void
-record_rule_line (void)
-{
-  /* Record each rule's source line number in rline table.  */
+/* Set the precedence symbol of the current rule to PRECSYM. */
 
 
-  if (nrules >= rline_allocated)
-    {
-      rline_allocated = nrules * 2;
-      rline = XREALLOC (rline, short, rline_allocated);
-    }
-  rline[nrules] = lineno;
+void
+grammar_current_rule_prec_set (symbol *precsym, location loc)
+{
+  symbol_class_set (precsym, token_sym, loc, false);
+  if (current_rule->ruleprec)
+    complain_at (loc, _("only one %s allowed per rule"), "%prec");
+  current_rule->ruleprec = precsym;
 }
 
 }
 
+/* Attach dynamic precedence DPREC to the current rule. */
 
 
-/*-------------------------------------------------------------------.
-| Generate a dummy symbol, a nonterminal, whose name cannot conflict |
-| with the user's names.                                             |
-`-------------------------------------------------------------------*/
-
-static bucket *
-gensym (void)
+void
+grammar_current_rule_dprec_set (int dprec, location loc)
 {
 {
-  bucket *sym;
-
-  sprintf (token_buffer, "@%d", ++gensym_count);
-  sym = getsym (token_buffer);
-  sym->class = nterm_sym;
-  sym->value = nvars++;
-  return sym;
+  if (! glr_parser)
+    warn_at (loc, _("%s affects only GLR parsers"), "%dprec");
+  if (dprec <= 0)
+    complain_at (loc, _("%s must be followed by positive number"), "%dprec");
+  else if (current_rule->dprec != 0)
+    complain_at (loc, _("only one %s allowed per rule"), "%dprec");
+  current_rule->dprec = dprec;
 }
 
 }
 
-#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                                        |
-`------------------------------------------------------------------*/
+/* Attach a merge function NAME with argument type TYPE to current
+   rule. */
 
 
-static int
-get_type (void)
+void
+grammar_current_rule_merge_set (uniqstr name, location loc)
 {
 {
-  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;
-       }
-    }
+  if (! glr_parser)
+    warn_at (loc, _("%s affects only GLR parsers"), "%merge");
+  if (current_rule->merger != 0)
+    complain_at (loc, _("only one %s allowed per rule"), "%merge");
+  current_rule->merger = get_merge_function (name);
+  current_rule->merger_declaration_location = loc;
 }
 
 }
 
-#endif
-\f
-/*------------------------------------------------------------------.
-| 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.                        |
-`------------------------------------------------------------------*/
+/* Attach SYM to the current rule.  If needed, move the previous
+   action as a mid-rule action.  */
 
 
-static void
-readgram (void)
+void
+grammar_current_rule_symbol_append (symbol *sym, location loc,
+                                   named_ref *name)
 {
 {
-  int t;
-  bucket *lhs = NULL;
   symbol_list *p;
   symbol_list *p;
-  symbol_list *p1;
-  bucket *bp;
-
-  /* Points to first symbol_list of current rule. its symbol is the
-     lhs of the rule.  */
-  symbol_list *crule;
-  /* Points to the symbol_list preceding crule.  */
-  symbol_list *crule1;
-
-  p1 = 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++;
-
-         record_rule_line ();
-
-         p = XCALLOC (symbol_list, 1);
-         p->sym = lhs;
-
-         crule1 = p1;
-         if (p1)
-           p1->next = p;
-         else
-           grammar = p;
-
-         p1 = p;
-         crule = p;
-
-         /* mark the rule's lhs as a nonterminal if not already so.  */
-
-         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);
-
-         /* read the rhs of the rule.  */
-
-         for (;;)
-           {
-             t = lex ();
-             if (t == PREC)
-               {
-                 t = lex ();
-                 crule->ruleprec = symval;
-                 t = lex ();
-               }
-
-             if (!(t == IDENTIFIER || t == LEFT_CURLY))
-               break;
-
-             /* If next token is an identifier, see if a colon follows it.
-                If one does, exit this rule now.  */
-             if (t == IDENTIFIER)
-               {
-                 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 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;
-               }
-
-             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 */
-
-         /* 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 (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"));
-
-             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)
-           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);
-         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.  */
-      fprintf (fattrs, "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
-      if (fdefines)
-       fprintf (fdefines, "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
-    }
-
-  /* Report any undefined symbols and consider them nonterminals.  */
-
-  for (bp = firstsymbol; bp; bp = bp->next)
-    if (bp->class == unknown_sym)
-      {
-       complain (_
-                 ("symbol %s is used, but is not defined as a token and has no rules"),
-                 bp->tag);
-       bp->class = nterm_sym;
-       bp->value = nvars++;
-      }
-
-  ntokens = nsyms - nvars;
+  if (current_rule->action_props.code)
+    grammar_midrule_action ();
+  p = grammar_symbol_append (sym, loc);
+  if (name)
+    assign_named_ref(p, name);
 }
 }
-\f
-/*--------------------------------------------------------------.
-| For named tokens, but not literal ones, define the name.  The |
-| value is the user token number.                               |
-`--------------------------------------------------------------*/
-
-static void
-output_token_defines (FILE *file)
-{
-  bucket *bp;
-  char *cp, *symbol;
-  char c;
 
 
-  for (bp = firstsymbol; bp; bp = bp->next)
-    {
-      symbol = bp->tag;                /* get symbol */
-
-      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)
-       {
-         /* use literal string only if given a symbol with an alias */
-         if (bp->alias)
-           symbol = bp->alias->tag;
-         else
-           continue;
-       }
+/* Attach an ACTION to the current rule.  */
 
 
-      /* Don't #define nonliteral tokens whose names contain periods.  */
-      cp = symbol;
-      while ((c = *cp++) && c != '.');
-      if (c != '\0')
-       continue;
-
-      fprintf (file, "#define\t%s\t%d\n", symbol,
-              ((translations && !raw_flag)
-               ? bp->user_token_number : bp->value));
-      if (semantic_parser)
-       fprintf (file, "#define\tT%s\t%d\n", symbol, bp->value);
-    }
-
-  putc ('\n', file);
-}
-
-
-/*------------------------------------------------------------------.
-| Assign symbol numbers, and write definition of token names into   |
-| FDEFINES.  Set up vectors TAGS and SPREC of names and precedences |
-| of symbols.                                                       |
-`------------------------------------------------------------------*/
-
-static void
-packsymbols (void)
+void
+grammar_current_rule_action_append (const char *action, location loc,
+                                   named_ref *name)
 {
 {
-  bucket *bp;
-  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);
-
-  max_user_token_number = 256;
-  last_user_token_number = 256;
-
-  for (bp = firstsymbol; bp; bp = bp->next)
-    {
-      if (bp->class == nterm_sym)
-       {
-         bp->value += ntokens;
-       }
-      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++;
-
-         if (bp->prec != bp->alias->prec)
-           {
-             if (bp->prec != 0 && bp->alias->prec != 0
-                 && bp->user_token_number == SALIAS)
-               complain (_("conflicting precedences for %s and %s"),
-                         bp->tag, bp->alias->tag);
-             if (bp->prec != 0)
-               bp->alias->prec = bp->prec;
-             else
-               bp->prec = bp->alias->prec;
-           }
-
-         if (bp->assoc != bp->alias->assoc)
-           {
-             if (bp->assoc != 0 && bp->alias->assoc != 0
-                 && bp->user_token_number == SALIAS)
-               complain (_("conflicting assoc values for %s and %s"),
-                         bp->tag, bp->alias->tag);
-             if (bp->assoc != 0)
-               bp->alias->assoc = bp->assoc;
-             else
-               bp->assoc = bp->alias->assoc;
-           }
-
-         if (bp->user_token_number == SALIAS)
-           continue;           /* do not do processing below for SALIASs */
-
-       }
-      else                     /* bp->class == token_sym */
-       {
-         bp->value = tokno++;
-       }
-
-      if (bp->class == token_sym)
-       {
-         if (translations && !(bp->user_token_number))
-           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;
-       }
-
-      tags[bp->value] = bp->tag;
-      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;
-       }
-    }
-
-  error_token_number = errtoken->value;
-
-  if (!no_parser_flag)
-    output_token_defines (ftable);
-
-  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)
-    {
-      output_token_defines (fdefines);
-
-      if (!pure_parser)
-       {
-         if (spec_name_prefix)
-           fprintf (fdefines, "\nextern YYSTYPE %slval;\n",
-                    spec_name_prefix);
-         else
-           fprintf (fdefines, "\nextern YYSTYPE yylval;\n");
-       }
-
-      if (semantic_parser)
-       for (i = ntokens; i < nsyms; i++)
-         {
-           /* don't make these for dummy nonterminals made by gensym.  */
-           if (*tags[i] != '@')
-             fprintf (fdefines, "#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
-    }
+  if (current_rule->action_props.code)
+    grammar_midrule_action ();
+  /* After all symbol declarations have been parsed, packgram invokes
+     code_props_translate_code.  */
+  code_props_rule_action_init (&current_rule->action_props, action, loc,
+                               current_rule, name);
 }
 
 }
 
-
+\f
 /*---------------------------------------------------------------.
 | Convert the rules into the representation using RRHS, RLHS and |
 /*---------------------------------------------------------------.
 | Convert the rules into the representation using RRHS, RLHS and |
-| RITEMS.                                                        |
+| RITEM                                                        |
 `---------------------------------------------------------------*/
 
 static void
 packgram (void)
 {
 `---------------------------------------------------------------*/
 
 static void
 packgram (void)
 {
-  int itemno;
-  int ruleno;
-  symbol_list *p;
+  unsigned int itemno = 0;
+  rule_number ruleno = 0;
+  symbol_list *p = grammar;
 
 
-  bucket *ruleprec;
+  ritem = xnmalloc (nritems + 1, sizeof *ritem);
 
 
-  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;
+  /* This sentinel is used by build_relations in gram.c.  */
+  *ritem++ = 0;
 
 
-  itemno = 0;
-  ruleno = 1;
+  rules = xnmalloc (nrules, sizeof *rules);
 
 
-  p = grammar;
   while (p)
     {
   while (p)
     {
-      rlhs[ruleno] = p->sym->value;
-      rrhs[ruleno] = itemno;
-      ruleprec = p->ruleprec;
-
-      p = p->next;
-      while (p && p->sym)
-       {
-         ritem[itemno++] = p->sym->value;
+      int rule_length = 0;
+      symbol *ruleprec = p->ruleprec;
+      record_merge_function_type (p->merger, p->content.sym->type_name,
+                                 p->merger_declaration_location);
+      rules[ruleno].user_number = ruleno;
+      rules[ruleno].number = ruleno;
+      rules[ruleno].lhs = p->content.sym;
+      rules[ruleno].rhs = ritem + itemno;
+      rules[ruleno].prec = NULL;
+      rules[ruleno].dprec = p->dprec;
+      rules[ruleno].merger = p->merger;
+      rules[ruleno].precsym = NULL;
+      rules[ruleno].location = p->location;
+      rules[ruleno].useful = true;
+      rules[ruleno].action = p->action_props.code;
+      rules[ruleno].action_location = p->action_props.location;
+
+      /* If the midrule's $$ is set or its $n is used, remove the `$' from the
+        symbol name so that it's a user-defined symbol so that the default
+        %destructor and %printer apply.  */
+      if (p->midrule_parent_rule
+          && (p->action_props.is_value_used
+             || symbol_list_n_get (p->midrule_parent_rule,
+                                   p->midrule_parent_rhs_index)
+                   ->action_props.is_value_used))
+       p->content.sym->tag += 1;
+
+      /* Don't check the generated rule 0.  It has no action, so some rhs
+        symbols may appear unused, but the parsing algorithm ensures that
+        %destructor's are invoked appropriately.  */
+      if (p != grammar)
+       grammar_rule_check (p);
+
+      for (p = p->next; p && p->content.sym; p = p->next)
+       {
+         ++rule_length;
+
+         /* Don't allow rule_length == INT_MAX, since that might
+            cause confusion with strtol if INT_MAX == LONG_MAX.  */
+         if (rule_length == INT_MAX)
+             fatal_at (rules[ruleno].location, _("rule is too long"));
+
+         /* item_number = symbol_number.
+            But the former needs to contain more: negative rule numbers. */
+         ritem[itemno++] =
+            symbol_number_as_item_number (p->content.sym->number);
          /* A rule gets by default the precedence and associativity
          /* A rule gets by default the precedence and associativity
-            of the last token in it.  */
-         if (p->sym->class == token_sym)
-           {
-             rprec[ruleno] = p->sym->prec;
-             rassoc[ruleno] = p->sym->assoc;
-           }
-         if (p)
-           p = p->next;
+            of its last token.  */
+         if (p->content.sym->class == token_sym && default_prec)
+           rules[ruleno].prec = p->content.sym;
        }
 
       /* If this rule has a %prec,
          the specified symbol's precedence replaces the default.  */
       if (ruleprec)
        {
        }
 
       /* If this rule has a %prec,
          the specified symbol's precedence replaces the default.  */
       if (ruleprec)
        {
-         rprec[ruleno] = ruleprec->prec;
-         rassoc[ruleno] = ruleprec->assoc;
-         rprecsym[ruleno] = ruleprec->value;
+         rules[ruleno].precsym = ruleprec;
+         rules[ruleno].prec = ruleprec;
        }
        }
-
-      ritem[itemno++] = -ruleno;
-      ruleno++;
+      /* An item ends by the rule number (negated).  */
+      ritem[itemno++] = rule_number_as_item_number (ruleno);
+      aver (itemno < ITEM_NUMBER_MAX);
+      ++ruleno;
+      aver (ruleno < RULE_NUMBER_MAX);
 
       if (p)
        p = p->next;
     }
 
 
       if (p)
        p = p->next;
     }
 
-  ritem[itemno] = 0;
+  aver (itemno == nritems);
+
+  if (trace_flag & trace_sets)
+    ritem_print (stderr);
 }
 \f
 }
 \f
-/*-------------------------------------------------------------------.
-| Read in the grammar specification and record it in the format      |
-| described in gram.h.  All guards are copied into the FGUARD file   |
-| and all actions into FACTION, in each case forming the body of a C |
-| function (YYGUARD or YYACTION) which contains a switch statement   |
-| to decide which guard or action to execute.                        |
-`-------------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| Read in the grammar specification and record it in the format     |
+| described in gram.h.  All actions are copied into ACTION_OBSTACK, |
+| in each case forming the body of a C function (YYACTION) which    |
+| contains a switch statement to decide which action to execute.    |
+`------------------------------------------------------------------*/
 
 void
 reader (void)
 {
 
 void
 reader (void)
 {
-  start_flag = 0;
-  startval = NULL;             /* start symbol not specified yet. */
+  /* Initialize the symbol table.  */
+  symbols_new ();
 
 
-#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;
+  /* Construct the accept symbol. */
+  accept = symbol_get ("$accept", empty_location);
+  accept->class = nterm_sym;
+  accept->number = nvars++;
 
 
-  nsyms = 1;
-  nvars = 0;
-  nrules = 0;
-  nitems = 0;
-  rline_allocated = 10;
-  rline = XCALLOC (short, rline_allocated);
+  /* Construct the error token */
+  errtoken = symbol_get ("error", empty_location);
+  errtoken->class = token_sym;
+  errtoken->number = ntokens++;
 
 
-  typed = 0;
-  lastprec = 0;
+  /* Construct a token that represents all undefined literal tokens.
+     It is always token number 2.  */
+  undeftoken = symbol_get ("$undefined", empty_location);
+  undeftoken->class = token_sym;
+  undeftoken->number = ntokens++;
+
+  gram_in = xfopen (grammar_file, "r");
+
+  gram__flex_debug = trace_flag & trace_scan;
+  gram_debug = trace_flag & trace_parse;
+  gram_scanner_initialize ();
+  gram_parse ();
+
+  /* Set front-end %define variable defaults.  */
+  muscle_percent_define_default ("lr.keep-unreachable-states", "false");
+  {
+    char *lr_type;
+    /* IELR would be a better default, but LALR is historically the
+       default.  */
+    muscle_percent_define_default ("lr.type", "LALR");
+    lr_type = muscle_percent_define_get ("lr.type");
+    if (0 != strcmp (lr_type, "canonical LR"))
+      muscle_percent_define_default ("lr.default-reductions", "all");
+    else
+      muscle_percent_define_default ("lr.default-reductions", "accepting");
+    free (lr_type);
+  }
+
+  /* Check front-end %define variables.  */
+  {
+    static char const * const values[] = {
+      "lr.type", "LALR", "IELR", "canonical LR", NULL,
+      "lr.default-reductions", "all", "consistent", "accepting", NULL,
+      NULL
+    };
+    muscle_percent_define_check_values (values);
+  }
+
+  if (! complaint_issued)
+    check_and_convert_grammar ();
+
+  xfclose (gram_in);
+}
 
 
-  gensym_count = 0;
 
 
-  semantic_parser = 0;
-  pure_parser = 0;
+/*-------------------------------------------------------------.
+| Check the grammar that has just been read, and convert it to |
+| internal form.                                              |
+`-------------------------------------------------------------*/
 
 
-  grammar = NULL;
+static void
+check_and_convert_grammar (void)
+{
+  /* Grammar has been read.  Do some checking.  */
+  if (nrules == 0)
+    fatal (_("no rules in the input grammar"));
 
 
-  init_lex ();
-  lineno = 1;
+  /* Report any undefined symbols and consider them nonterminals.  */
+  symbols_check_defined ();
+
+  /* If the user did not define her ENDTOKEN, do it now. */
+  if (!endtoken)
+    {
+      endtoken = symbol_get ("$end", empty_location);
+      endtoken->class = token_sym;
+      endtoken->number = 0;
+      /* Value specified by POSIX.  */
+      endtoken->user_token_number = 0;
+    }
+
+  /* Find the start symbol if no %start.  */
+  if (!start_flag)
+    {
+      symbol_list *node;
+      for (node = grammar;
+           node != NULL && symbol_is_dummy (node->content.sym);
+           node = node->next)
+        {
+          for (node = node->next;
+               node != NULL && node->content.sym != NULL;
+               node = node->next)
+            ;
+        }
+      aver (node != NULL);
+      grammar_start_symbol_set (node->content.sym,
+                                node->content.sym->location);
+    }
+
+  /* Insert the initial rule, whose line is that of the first rule
+     (not that of the start symbol):
+
+     accept: %start EOF.  */
+  {
+    symbol_list *p = symbol_list_sym_new (accept, empty_location);
+    p->location = grammar->location;
+    p->next = symbol_list_sym_new (startsymbol, empty_location);
+    p->next->next = symbol_list_sym_new (endtoken, empty_location);
+    p->next->next->next = symbol_list_sym_new (NULL, empty_location);
+    p->next->next->next->next = grammar;
+    nrules += 1;
+    nritems += 3;
+    grammar = p;
+  }
+
+  aver (nsyms <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars);
 
 
-  /* Initialize the symbol table.  */
-  tabinit ();
-  /* Construct the error token */
-  errtoken = getsym ("error");
-  errtoken->class = token_sym;
-  errtoken->user_token_number = 256;   /* Value specified by POSIX.  */
-  /* Construct a token that represents all undefined literal tokens.
-     It is always token number 2.  */
-  undeftoken = getsym ("$undefined.");
-  undeftoken->class = token_sym;
-  undeftoken->user_token_number = 2;
-
-  /* Read the declaration section.  Copy %{ ... %} groups to FTABLE
-     and FDEFINES file.  Also notice any %token, %left, etc. found
-     there.  */
-  putc ('\n', ftable);
-  fprintf (ftable, "\
-/* %s, made from %s\n\
-   by GNU bison %s.  */\n\
-\n", no_parser_flag ? "Bison-generated parse tables" : "A Bison parser", infile, VERSION);
-
-  fputs ("#define YYBISON 1  /* Identify Bison output.  */\n\n", ftable);
-  read_declarations ();
-  /* Start writing the guard and action files, if they are needed.  */
-  output_headers ();
-  /* Read in the grammar, build grammar in list form.  Write out
-     guards and actions.  */
-  readgram ();
-  /* Now we know whether we need the line-number stack.  If we do,
-     write its type into the .tab.h file.  */
-  if (fdefines)
-    reader_output_yylsp (fdefines);
-  /* Write closing delimiters for actions and guards.  */
-  output_trailers ();
-  if (locations_flag)
-    fputs ("#define YYLSP_NEEDED\n\n", ftable);
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
-  packsymbols ();
+  symbols_pack ();
+
+  /* Scan rule actions after invoking symbol_check_alias_consistency (in
+     symbols_pack above) so that token types are set correctly before the rule
+     action type checking.
+
+     Before invoking grammar_rule_check (in packgram below) on any rule, make
+     sure all actions have already been scanned in order to set `used' flags.
+     Otherwise, checking that a midrule's $$ should be set will not always work
+     properly because the check must forward-reference the midrule's parent
+     rule.  For the same reason, all the `used' flags must be set before
+     checking whether to remove `$' from any midrule symbol name (also in
+     packgram).  */
+  {
+    symbol_list *sym;
+    for (sym = grammar; sym; sym = sym->next)
+      code_props_translate_code (&sym->action_props);
+  }
+
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();
   /* Convert the grammar into the format described in gram.h.  */
   packgram ();
-  /* Free the symbol table data structure since symbols are now all
-     referred to by symbol number.  */
-  free_symtab ();
-}
 
 
-
-void
-reader_output_yylsp (FILE *f)
-{
-  if (locations_flag)
-    fputs ("\
-\n\
-#ifndef YYLTYPE\n\
-typedef struct yyltype\n\
-{\n\
-  int timestamp;\n\
-  int first_line;\n\
-  int first_column;\
-\n\
-  int last_line;\n\
-  int last_column;\n\
-  char *text;\n\
-} yyltype;\n\
-\n\
-# define YYLTYPE yyltype\n\
-#endif\n\
-\n",
-          f);
+  /* The grammar as a symbol_list is no longer needed. */
+  symbol_list_free (grammar);
 }
 }