X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/3cef001a7019bed4577d7ca1ae0dbaf322adf9f1..6175ffe3211dad578ce6585584c4eb85cf891830:/src/reader.c

diff --git a/src/reader.c b/src/reader.c
index 0aea3159..3f8cab8b 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -1,5 +1,7 @@
-/* Input parser for bison
-   Copyright (C) 1984, 86, 89, 92, 98, 2000 Free Software Foundation, Inc.
+/* Input parser for Bison
+
+   Copyright (C) 1984, 1986, 1989, 1992, 1998, 2000, 2001, 2002, 2003
+   Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -18,2053 +20,536 @@
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
+#include "system.h"
 
-/* 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.
-
-   The entry point is reader ().  */
+#include <quotearg.h>
 
-#include <stdio.h>
-#include "system.h"
+#include "complain.h"
+#include "conflicts.h"
 #include "files.h"
-#include "alloc.h"
-#include "symtab.h"
-#include "lex.h"
+#include "getargs.h"
 #include "gram.h"
-#include "machine.h"
-
-#define	LTYPESTR	"\
-\n\
-#ifndef YYLTYPE\n\
-typedef\n\
-  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\
-   }\n\
-\
-  yyltype;\n\
-\n\
-#define YYLTYPE yyltype\n\
-#endif\n\
-\n"
-
-/* Number of slots allocated (but not necessarily used yet) in `rline'  */
-int rline_allocated;
-
-extern char *program_name;
-extern int definesflag;
-extern int nolinesflag;
-extern int noparserflag;
-extern int rawtoknumflag;
-extern bucket *symval;
-extern int numval;
-extern int expected_conflicts;
-extern char *token_buffer;
-extern int maxtoken;
-
-extern void init_lex PARAMS((void));
-extern char *grow_token_buffer PARAMS((char *));
-extern void tabinit PARAMS((void));
-extern void output_headers PARAMS((void));
-extern void output_trailers PARAMS((void));
-extern void free_symtab PARAMS((void));
-extern void open_extra_files PARAMS((void));
-extern char *int_to_string PARAMS((int));
-extern char *printable_version PARAMS((int));
-extern void fatal PARAMS((char *));
-extern void fatals PARAMS((char *, char *));
-extern void warn PARAMS((char *));
-extern void warni PARAMS((char *, int));
-extern void warns PARAMS((char *, char *));
-extern void warnss PARAMS((char *, char *, char *));
-extern void warnsss PARAMS((char *, char *, char *, char *));
-extern void unlex PARAMS((int));
-extern void done PARAMS((int));
-
-extern int skip_white_space PARAMS((void));
-extern int parse_percent_token PARAMS((void));
-extern int lex PARAMS((void));
-
-typedef
-  struct symbol_list
-    {
-      struct symbol_list *next;
-      bucket *sym;
-      bucket *ruleprec;
-    }
-  symbol_list;
-
-
-void reader PARAMS((void));
-void reader_output_yylsp PARAMS((FILE *));
-void read_declarations PARAMS((void));
-void copy_definition PARAMS((void));
-void parse_token_decl PARAMS((int, int));
-void parse_start_decl PARAMS((void));
-void parse_type_decl PARAMS((void));
-void parse_assoc_decl PARAMS((int));
-void parse_union_decl PARAMS((void));
-void parse_expect_decl PARAMS((void));
-char *get_type_name PARAMS((int, symbol_list *));
-void copy_guard PARAMS((symbol_list *, int));
-void parse_thong_decl PARAMS((void));
-void copy_action PARAMS((symbol_list *, int));
-bucket *gensym PARAMS((void));
-void readgram PARAMS((void));
-void record_rule_line PARAMS((void));
-void packsymbols PARAMS((void));
-void output_token_defines PARAMS((FILE *));
-void packgram PARAMS((void));
-int read_signed_integer PARAMS((FILE *));
-
-#if 0
-static int get_type PARAMS((void));
-#endif
-
-int lineno;
-symbol_list *grammar;
-int start_flag;
-bucket *startval;
-char **tags;
-int *user_toknums;
-
-/* Nonzero if components of semantic values are used, implying
-   they must be unions.  */
-static int value_components_used;
-
-static int typed;  /* nonzero if %union has been seen.  */
-
-static int lastprec;  /* incremented for each %left, %right or %nonassoc seen */
-
-static int gensym_count;  /* incremented for each generated symbol */
-
-static bucket *errtoken;
-static bucket *undeftoken;
-
-/* Nonzero if any action or guard uses the @n construct.  */
-static int yylsp_needed;
-
-
-static void
-skip_to_char (int target)
-{
-  int c;
-  if (target == '\n')
-    warn(_("   Skipping to next \\n"));
-  else
-    warni(_("   Skipping to next %c"), target);
+#include "muscle_tab.h"
+#include "output.h"
+#include "reader.h"
+#include "symlist.h"
+#include "symtab.h"
 
-  do
-    c = skip_white_space();
-  while (c != target && c != EOF);
-  if (c != EOF)
-    ungetc(c, finput);
-}
+static symbol_list *grammar = NULL;
+static int start_flag = 0;
+merger_list *merge_functions;
 
+/* Nonzero if %union has been seen.  */
+int typed = 0;
+
+/*-----------------------.
+| Set the start symbol.  |
+`-----------------------*/
 
 void
-reader (void)
+grammar_start_symbol_set (symbol *sym, location loc)
 {
-  start_flag = 0;
-  startval = NULL;  /* start symbol not specified yet. */
-
-#if 0
-  translations = 0;  /* initially assume token number translation not needed.  */
-#endif
-  /* Nowadays translations is always set to 1,
-     since we give `error' a user-token-number
-     to satisfy the Posix demand for YYERRCODE==256.  */
-  translations = 1;
-
-  nsyms = 1;
-  nvars = 0;
-  nrules = 0;
-  nitems = 0;
-  rline_allocated = 10;
-  rline = NEW2(rline_allocated, short);
-
-  typed = 0;
-  lastprec = 0;
-
-  gensym_count = 0;
-
-  semantic_parser = 0;
-  pure_parser = 0;
-  yylsp_needed = 0;
-
-  grammar = NULL;
-
-  init_lex();
-  lineno = 1;
-
-  /* initialize the symbol table.  */
-  tabinit();
-  /* construct the error token */
-  errtoken = getsym("error");
-  errtoken->class = STOKEN;
-  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 = STOKEN;
-  undeftoken->user_token_number = 2;
-  /* Read the declaration section.  Copy %{ ... %} groups to ftable and fdefines file.
-     Also notice any %token, %left, etc. found there.  */
-  if (noparserflag)
-    fprintf(ftable, "\n/*  Bison-generated parse tables, made from %s\n",
-		infile);
+  if (start_flag)
+    complain_at (loc, _("multiple %s declarations"), "%start");
   else
-    fprintf(ftable, "\n/*  A Bison parser, made from %s\n", infile);
-  fprintf(ftable, "    by %s  */\n\n", VERSION_STRING);
-  fprintf(ftable, "#define YYBISON 1  /* Identify Bison output.  */\n\n");
-  read_declarations();
-  /* start writing the guard and action files, if they are needed.  */
-  output_headers();
-  /* read in the grammar, build grammar in list form.  write out guards and actions.  */
-  readgram();
-  /* 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 (yylsp_needed)
-    fprintf(ftable, "#define YYLSP_NEEDED\n\n");
-  /* assign the symbols their symbol numbers.
-     Write #defines for the token symbols into fdefines if requested.  */
-  packsymbols();
-  /* 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 (yylsp_needed)
-    fprintf(f, LTYPESTR);
-}
-
-/* Read from finput until `%%' is seen.  Discard the `%%'.  Handle any
-   `%' declarations, and copy the contents of any `%{ ... %}' groups
-   to fattrs.  */
-
-void
-read_declarations (void)
-{
-  register int c;
-  register int tok;
-
-  for (;;)
     {
-      c = skip_white_space();
-
-      if (c == '%')
-	{
-	  tok = parse_percent_token();
-
-	  switch (tok)
-	    {
-	    case TWO_PERCENTS:
-	      return;
-
-	    case PERCENT_LEFT_CURLY:
-	      copy_definition();
-	      break;
-
-	    case TOKEN:
-	      parse_token_decl (STOKEN, SNTERM);
-	      break;
-
-	    case NTERM:
-	      parse_token_decl (SNTERM, STOKEN);
-	      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:
-	      warns(_("unrecognized: %s"), token_buffer);
-	      skip_to_char('%');
-	  }
-	}
-      else if (c == EOF)
-        fatal(_("no input grammar"));
-      else
-	{
-	  warns (_("unknown character: %s"), printable_version(c));
-	  skip_to_char('%');
-	}
+      start_flag = 1;
+      startsymbol = sym;
+      startsymbol_location = loc;
     }
 }
 
 
-/* copy the contents of a %{ ... %} into the definitions file.
-The %{ has already been read.  Return after reading the %}.  */
+/*----------------------------------------------------------------.
+| There are two prologues: one before %union, one after.  Augment |
+| the current one.                                                |
+`----------------------------------------------------------------*/
 
 void
-copy_definition (void)
+prologue_augment (const char *prologue, location loc)
 {
-  register int c;
-  register int match;
-  register int ended;
-  register int after_percent;  /* -1 while reading a character if prev char was % */
-  int cplus_comment;
-
-  if (!nolinesflag)
-    fprintf(fattrs, "#line %d \"%s\"\n", lineno, infile);
-
-  after_percent = 0;
-
-  c = getc(finput);
-
-  for (;;)
-    {
-      switch (c)
-	{
-	case '\n':
-	  putc(c, fattrs);
-	  lineno++;
-	  break;
-
-	case '%':
-          after_percent = -1;
-	  break;
-
-	case '\'':
-	case '"':
-	  match = c;
-	  putc(c, fattrs);
-	  c = getc(finput);
-
-	  while (c != match)
-	    {
-	      if (c == EOF)
-		fatal(_("unterminated string at end of file"));
-	      if (c == '\n')
-		{
-		  warn(_("unterminated string"));
-		  ungetc(c, finput);
-		  c = match;
-		  continue;
-		}
-
-	      putc(c, fattrs);
-
-	      if (c == '\\')
-		{
-		  c = getc(finput);
-		  if (c == EOF)
-		    fatal(_("unterminated string at end of file"));
-		  putc(c, fattrs);
-		  if (c == '\n')
-		    lineno++;
-		}
-
-	      c = getc(finput);
-	    }
-
-	  putc(c, fattrs);
-	  break;
-
-	case '/':
-	  putc(c, fattrs);
-	  c = getc(finput);
-	  if (c != '*' && c != '/')
-	    continue;
-
-	  cplus_comment = (c == '/');
-	  putc(c, fattrs);
-	  c = getc(finput);
-
-	  ended = 0;
-	  while (!ended)
-	    {
-	      if (!cplus_comment && c == '*')
-		{
-		  while (c == '*')
-		    {
-		      putc(c, fattrs);
-		      c = getc(finput);
-		    }
-
-		  if (c == '/')
-		    {
-		      putc(c, fattrs);
-		      ended = 1;
-		    }
-		}
-	      else if (c == '\n')
-		{
-		  lineno++;
-		  putc(c, fattrs);
-		  if (cplus_comment)
-		    ended = 1;
-		  else
-		    c = getc(finput);
-		}
-	      else if (c == EOF)
-		fatal(_("unterminated comment in `%{' definition"));
-	      else
-		{
-		  putc(c, fattrs);
-		  c = getc(finput);
-		}
-	    }
-
-	  break;
-
-	case EOF:
-	  fatal(_("unterminated `%{' definition"));
-
-	default:
-	  putc(c, fattrs);
-	}
-
-      c = getc(finput);
-
-      if (after_percent)
-	{
-	  if (c == '}')
-	    return;
-	  putc('%', fattrs);
-	}
-      after_percent = 0;
-
-    }
-
+  struct obstack *oout =
+    !typed ? &pre_prologue_obstack : &post_prologue_obstack;
+
+  obstack_fgrow1 (oout, "]b4_syncline([[%d]], [[", loc.start.line);
+  MUSCLE_OBSTACK_SGROW (oout,
+			quotearg_style (c_quoting_style, loc.start.file));
+  obstack_sgrow (oout, "]])[\n");
+  obstack_sgrow (oout, prologue);
 }
 
 
 
-/* parse what comes after %token or %nterm.
-For %token, what_is is STOKEN and what_is_not is SNTERM.
-For %nterm, the arguments are reversed.  */
-
-void
-parse_token_decl (int what_is, int what_is_not)
-{
-  register int token = 0;
-  register char *typename = 0;
-  register struct bucket *symbol = NULL;  /* pts to symbol being defined */
-  int k;
-
-  for (;;)
-    {
-      int tmp_char = ungetc (skip_white_space (), finput);
 
-      if (tmp_char == '%')
-	return;
-      if (tmp_char == EOF)
-	fatals ("Premature EOF after %s", token_buffer);
-
-      token = lex();
-      if (token == COMMA)
-	{
-	  symbol = NULL;
-	  continue;
-	}
-      if (token == TYPENAME)
-	{
-	  k = strlen(token_buffer);
-	  typename = NEW2(k + 1, char);
-	  strcpy(typename, token_buffer);
-	  value_components_used = 1;
-	  symbol = NULL;
-	}
-      else if (token == IDENTIFIER && *symval->tag == '\"'
-		&& symbol)
-	{
-	  translations = 1;
-	  symval->class = STOKEN;
-	  symval->type_name = typename;
-	  symval->user_token_number = symbol->user_token_number;
-	  symbol->user_token_number = SALIAS;
-
-	  symval->alias = symbol;
-	  symbol->alias = symval;
-	  symbol = NULL;
-
- 	  nsyms--;   /* symbol and symval combined are only one symbol */
-	}
-      else if (token == IDENTIFIER)
-	{
-	  int oldclass = symval->class;
-	  symbol = symval;
-
-	  if (symbol->class == what_is_not)
-	    warns(_("symbol %s redefined"), symbol->tag);
-	  symbol->class = what_is;
-	  if (what_is == SNTERM && oldclass != SNTERM)
-	    symbol->value = nvars++;
-
-	  if (typename)
-	    {
-	      if (symbol->type_name == NULL)
-		symbol->type_name = typename;
-	      else if (strcmp(typename, symbol->type_name) != 0)
-		warns(_("type redeclaration for %s"), symbol->tag);
-	    }
-	}
-      else if (symbol && token == NUMBER)
-        {
-	  symbol->user_token_number = numval;
-	  translations = 1;
-        }
-      else
-	{
-	  warnss(_("`%s' is invalid in %s"),
-		token_buffer,
-		(what_is == STOKEN) ? "%token" : "%nterm");
-	  skip_to_char('%');
-	}
-    }
-
-}
-
-/* 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
-*/
+/*----------------------.
+| Handle the epilogue.  |
+`----------------------*/
 
 void
-parse_thong_decl (void)
+epilogue_augment (const char *epilogue, location loc)
 {
-  register int token;
-  register struct bucket *symbol;
-  register char *typename = 0;
-  int k, usrtoknum;
-
-  translations = 1;
-  token = lex();		/* fetch typename or first token */
-  if (token == TYPENAME) {
-    k = strlen(token_buffer);
-    typename = NEW2(k + 1, char);
-    strcpy(typename, token_buffer);
-    value_components_used = 1;
-    token = lex();		/* fetch first token */
-  }
-
-  /* process first token */
-
-  if (token != IDENTIFIER)
-    {
-      warns(_("unrecognized item %s, expected an identifier"),
-	    token_buffer);
-      skip_to_char('%');
-      return;
-    }
-  symval->class = STOKEN;
-  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 != '\"')
-    {
-      warns(_("expected string constant instead of %s"),
-	    token_buffer);
-      skip_to_char('%');
-      return;
-    }
-  symval->class = STOKEN;
-  symval->type_name = typename;
-  symval->user_token_number = usrtoknum;
-
-  symval->alias = symbol;
-  symbol->alias = symval;
-
-  nsyms--;			/* symbol and symval combined are only one symbol */
-}
-
-
-/* parse what comes after %start */
-
-void
-parse_start_decl (void)
-{
-  if (start_flag)
-    warn(_("multiple %start declarations"));
-  if (lex() != IDENTIFIER)
-    warn(_("invalid %start declaration"));
-  else
-    {
-      start_flag = 1;
-      startval = symval;
-    }
+  char *extension = NULL;
+  obstack_fgrow1 (&muscle_obstack, "]b4_syncline([[%d]], [[", loc.start.line);
+  MUSCLE_OBSTACK_SGROW (&muscle_obstack,
+			quotearg_style (c_quoting_style, loc.start.file));
+  obstack_sgrow (&muscle_obstack, "]])[\n");
+  obstack_sgrow (&muscle_obstack, epilogue);
+  obstack_1grow (&muscle_obstack, 0);
+  extension = obstack_finish (&muscle_obstack);
+  muscle_grow ("epilogue", extension, "");
+  obstack_free (&muscle_obstack, extension);
 }
 
 
+
 
-/* read in a %type declaration and record its information for get_type_name to access */
+/*-------------------------------------------------------------------.
+| Return the merger index for a merging function named NAME, whose   |
+| arguments have type TYPE.  Records the function, if new, in        |
+| MERGER_LIST.							     |
+`-------------------------------------------------------------------*/
 
-void
-parse_type_decl (void)
+static int
+get_merge_function (uniqstr name, uniqstr type, location loc)
 {
-  register int k;
-  register char *name;
+  merger_list *syms;
+  merger_list head;
+  int n;
 
-  if (lex() != TYPENAME)
-    {
-      warn(_("%type declaration has no <typename>"));
-      skip_to_char('%');
-      return;
-    }
+  if (! glr_parser)
+    return 0;
 
-  k = strlen(token_buffer);
-  name = NEW2(k + 1, char);
-  strcpy(name, token_buffer);
+  if (type == NULL)
+    type = uniqstr_new ("");
 
-  for (;;)
+  head.next = merge_functions;
+  for (syms = &head, n = 1; syms->next != NULL; syms = syms->next, n += 1)
+    if (UNIQSTR_EQ (name, syms->next->name))
+      break;
+  if (syms->next == NULL)
     {
-      register int t;
-      int tmp_char = ungetc (skip_white_space (), finput);
-
-      if (tmp_char == '%')
-	return;
-      if (tmp_char == EOF)
-	fatals ("Premature EOF after %s", token_buffer);
-
-      t = lex();
-
-      switch (t)
-	{
-
-	case COMMA:
-	case SEMICOLON:
-	  break;
-
-	case IDENTIFIER:
-	  if (symval->type_name == NULL)
-	    symval->type_name = name;
-	  else if (strcmp(name, symval->type_name) != 0)
-	    warns(_("type redeclaration for %s"), symval->tag);
-
-	  break;
-
-	default:
-	  warns(_("invalid %%type declaration due to item: `%s'"), token_buffer);
-	  skip_to_char('%');
-	}
+      MALLOC (syms->next, 1);
+      syms->next->name = uniqstr_new (name);
+      syms->next->type = uniqstr_new (type);
+      syms->next->next = NULL;
+      merge_functions = head.next;
     }
+  else if (!UNIQSTR_EQ (type, syms->next->type))
+    warn_at (loc, _("result type clash on merge function %s: <%s> != <%s>"),
+	     name, type, syms->next->type);
+  return n;
 }
 
-
-
-/* read in a %left, %right or %nonassoc declaration and record its information.  */
-/* assoc is either LEFT_ASSOC, RIGHT_ASSOC or NON_ASSOC.  */
+/*--------------------------------------.
+| Free all merge-function definitions.	|
+`--------------------------------------*/
 
 void
-parse_assoc_decl (int assoc)
+free_merger_functions (void)
 {
-  register int k;
-  register char *name = NULL;
-  register int prev = 0;
-
-  lastprec++;  /* Assign a new precedence level, never 0.  */
-
-  for (;;)
+  merger_list *L0;
+  if (! glr_parser)
+    return;
+  L0 = merge_functions;
+  while (L0 != NULL)
     {
-      register int t;
-      int tmp_char = ungetc (skip_white_space (), finput);
-
-      if (tmp_char == '%')
-	return;
-      if (tmp_char == EOF)
-	fatals ("Premature EOF after %s", token_buffer);
-
-      t = lex();
-
-      switch (t)
-	{
-
-	case TYPENAME:
-	  k = strlen(token_buffer);
-	  name = NEW2(k + 1, char);
-	  strcpy(name, token_buffer);
-	  break;
-
-	case COMMA:
-	  break;
-
-	case IDENTIFIER:
-	  if (symval->prec != 0)
-	    warns(_("redefining precedence of %s"), symval->tag);
-	  symval->prec = lastprec;
-	  symval->assoc = assoc;
-	  if (symval->class == SNTERM)
-	    warns(_("symbol %s redefined"), symval->tag);
-	  symval->class = STOKEN;
-	  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)
-		warns(_("type redeclaration for %s"), symval->tag);
-	    }
-	  break;
-
-	case NUMBER:
-	  if (prev == IDENTIFIER)
-            {
-	      symval->user_token_number = numval;
-	      translations = 1;
-            }
-          else
-            {
-	      warns(_("invalid text (%s) - number should be after identifier"),
-			token_buffer);
-	      skip_to_char('%');
-            }
-	  break;
-
-	case SEMICOLON:
-	  return;
-
-	default:
-	  warns(_("unexpected item: %s"), token_buffer);
-	  skip_to_char('%');
-	}
-
-      prev = t;
-
+      merger_list *L1 = L0->next;
+      free (L0);
+      L0 = L1;
     }
 }
 
-
-
-/* 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.  */
-
+
+/*-------------------------------------------------------------------.
+| 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 actions are copied out, labelled by the rule number they apply |
+| to.                                                                |
+|                                                                    |
+| Bison used to allow some %directives in the rules sections, but    |
+| this is no longer consider appropriate: (i) the documented grammar |
+| doesn't claim it, (ii), it would promote bad style, (iii), error   |
+| recovery for %directives consists in skipping the junk until a `%' |
+| is seen and helrp synchronizing.  This scheme is definitely wrong  |
+| in the rules section.                                              |
+`-------------------------------------------------------------------*/
+
+/* The (currently) last symbol of GRAMMAR. */
+symbol_list *grammar_end = NULL;
+
+/* Append SYM to the grammar.  */
 void
-parse_union_decl (void)
+grammar_symbol_append (symbol *sym, location loc)
 {
-  register int c;
-  register int count;
-  register int in_comment;
-  int cplus_comment;
-
-  if (typed)
-    warn(_("multiple %union declarations"));
-
-  typed = 1;
+  symbol_list *p = symbol_list_new (sym, loc);
 
-  if (!nolinesflag)
-    fprintf(fattrs, "\n#line %d \"%s\"\n", lineno, infile);
+  if (grammar_end)
+    grammar_end->next = p;
   else
-    fprintf(fattrs, "\n");
+    grammar = p;
 
-  fprintf(fattrs, "typedef union");
-  if (fdefines)
-    fprintf(fdefines, "typedef union");
-
-  count = 0;
-  in_comment = 0;
-
-  c = getc(finput);
-
-  while (c != EOF)
-    {
-      putc(c, fattrs);
-      if (fdefines)
-	putc(c, fdefines);
+  grammar_end = p;
+}
 
-      switch (c)
-	{
-	case '\n':
-	  lineno++;
-	  break;
-
-	case '/':
-	  c = getc(finput);
-	  if (c != '*' && c != '/')
-	    ungetc(c, finput);
-	  else
-	    {
-	      putc(c, fattrs);
-	      if (fdefines)
-		putc(c, fdefines);
-	      cplus_comment = (c == '/');
-	      in_comment = 1;
-	      c = getc(finput);
-	      while (in_comment)
-		{
-		  putc(c, fattrs);
-		  if (fdefines)
-		    putc(c, fdefines);
-
-		  if (c == '\n')
-		    {
-		      lineno++;
-		      if (cplus_comment)
-			{
-			  in_comment = 0;
-			  break;
-			}
-		    }
-		  if (c == EOF)
-		    fatal(_("unterminated comment at end of file"));
-
-		  if (!cplus_comment && c == '*')
-		    {
-		      c = getc(finput);
-		      if (c == '/')
-			{
-			  putc('/', fattrs);
-			  if (fdefines)
-			    putc('/', fdefines);
-			  in_comment = 0;
-			}
-		    }
-		  else
-		    c = getc(finput);
-		}
-	    }
-	  break;
-
-
-	case '{':
-	  count++;
-	  break;
-
-	case '}':
-	  if (count == 0)
-	    warn (_("unmatched close-brace (`}')"));
-	  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;
-	    }
-	}
+/* 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 *current_rule = NULL;
+symbol_list *previous_rule_end = NULL;
 
-      c = getc(finput);
-    }
-}
 
-/* parse the declaration %expect N which says to expect N
-   shift-reduce conflicts.  */
+/*----------------------------------------------.
+| Create a new rule for LHS in to the GRAMMAR.  |
+`----------------------------------------------*/
 
 void
-parse_expect_decl (void)
+grammar_rule_begin (symbol *lhs, location loc)
 {
-  register int c;
-  register int count;
-  char buffer[20];
-
-  c = getc(finput);
-  while (c == ' ' || c == '\t')
-    c = getc(finput);
-
-  count = 0;
-  while (c >= '0' && c <= '9')
+  if (!start_flag)
     {
-      if (count < 20)
-	buffer[count++] = c;
-      c = getc(finput);
+      startsymbol = lhs;
+      startsymbol_location = loc;
+      start_flag = 1;
     }
-  buffer[count] = 0;
-
-  ungetc (c, finput);
-
-  if (count <= 0 || count > 10)
-	warn(_("argument of %expect is not an integer"));
-  expected_conflicts = atoi (buffer);
-}
 
-/* that's all of parsing the declaration section */
-
-/* Get the data type (alternative in the union) of the value for symbol n in rule rule.  */
-
-char *
-get_type_name (int n, symbol_list *rule)
-{
-  static char *msg = N_("invalid $ value");
+  /* Start a new rule and record its lhs.  */
+  ++nrules;
+  ++nritems;
 
-  register int i;
-  register symbol_list *rp;
-
-  if (n < 0)
-    {
-      warn(_(msg));
-      return NULL;
-    }
+  previous_rule_end = grammar_end;
+  grammar_symbol_append (lhs, loc);
+  current_rule = grammar_end;
 
-  rp = rule;
-  i = 0;
+  /* Mark the rule's lhs as a nonterminal if not already so.  */
 
-  while (i < n)
+  if (lhs->class == unknown_sym)
     {
-      rp = rp->next;
-      if (rp == NULL || rp->sym == NULL)
-	{
-	  warn(_(msg));
-	  return NULL;
-	}
-      i++;
+      lhs->class = nterm_sym;
+      lhs->number = nvars;
+      ++nvars;
     }
-
-  return (rp->sym->type_name);
+  else if (lhs->class == token_sym)
+    complain_at (loc, _("rule given for %s, which is a token"), lhs->tag);
 }
 
+/* Check that the last rule (CURRENT_RULE) is properly defined.  For
+   instance, there should be no type clash on the default action.  */
 
-/* Dump the string from FINPUT to FOUTPUT.  MATCH is the delimiter of
-   the string (either ' or ").  */
-
-void
-copy_string (FILE *finput, FILE *foutput, int match)
+static void
+grammar_current_rule_check (void)
 {
-  int c;
-
-  putc (match, foutput);
-  c = getc (finput);
-
-  while (c != match)
+  symbol *lhs = current_rule->sym;
+  char const *lhs_type = lhs->type_name;
+  symbol *first_rhs = current_rule->next->sym;
+
+  /* If there is an action, then there is nothing we can do: the user
+     is allowed to shoot herself in the foot.  */
+  if (current_rule->action)
+    return;
+
+  /* Don't worry about the default action if $$ is untyped, since $$'s
+     value can't be used.  */
+  if (! lhs_type)
+    return;
+
+  /* If $$ is being set in default way, report if any type mismatch.  */
+  if (first_rhs)
     {
-      if (c == EOF)
-	fatal(_("unterminated string at end of file"));
-      if (c == '\n')
-	{
-	  warn (_("unterminated string"));
-	  ungetc (c, finput);
-	  c = match;		/* invent terminator */
-	  continue;
-	}
-
-      putc(c, foutput);
-
-      if (c == '\\')
-	{
-	  c = getc (finput);
-	  if (c == EOF)
-	    fatal (_("unterminated string"));
-	  putc (c, foutput);
-	  if (c == '\n')
-	    lineno++;
-	}
-
-      c = getc(finput);
+      const char *rhs_type = first_rhs->type_name ? first_rhs->type_name : "";
+      if (!UNIQSTR_EQ (lhs_type, rhs_type))
+	warn_at (current_rule->location,
+		 _("type clash on default action: <%s> != <%s>"),
+		 lhs_type, rhs_type);
     }
-
-  putc(c, foutput);
+  /* Warn if there is no default for $$ but we need one.  */
+  else
+    warn_at (current_rule->location,
+	     _("empty rule for typed nonterminal, and no action"));
 }
 
 
-/* Dump the comment from FINPUT to FOUTPUT.  C is either `*' or `/',
-   depending upon the type of comments used.  */
+/*-------------------------------------.
+| End the currently being grown rule.  |
+`-------------------------------------*/
 
 void
-copy_comment (FILE *finput, FILE *foutput, int c)
+grammar_rule_end (location loc)
 {
-  int cplus_comment;
-  register int match;
-  register int ended;
-
-  cplus_comment = (c == '/');
-  putc (c, foutput);
-  c = getc (finput);
-
-  ended = 0;
-  while (!ended)
-    {
-      if (!cplus_comment && c == '*')
-	{
-	  while (c == '*')
-	    {
-	      putc(c, foutput);
-	      c = getc(finput);
-	    }
-
-	  if (c == '/')
-	    {
-	      putc(c, foutput);
-	      ended = 1;
-	    }
-	}
-      else if (c == '\n')
-	{
-	  lineno++;
-	  putc (c, foutput);
-	  if (cplus_comment)
-	    ended = 1;
-	  else
-	    c = getc(finput);
-	}
-      else if (c == EOF)
-	fatal (_("unterminated comment"));
-      else
-	{
-	  putc (c, foutput);
-	  c = getc (finput);
-	}
-    }
+  /* 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;
+  grammar_current_rule_check ();
 }
 
-/* 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.  */
-
-void
-copy_guard (symbol_list *rule, int stack_offset)
-{
-  register int c;
-  register int n;
-  register int count;
-  register char *type_name;
-  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 (!nolinesflag)
-    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
-	    {
-	      warn(_("unmatched right brace (`}')"));
-	      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 '$':
-	  c = getc(finput);
-	  type_name = NULL;
-
-	  if (c == '<')
-	    {
-	      register char *cp = token_buffer;
-
-	      while ((c = getc(finput)) != '>' && c > 0)
-		{
-		  if (cp == token_buffer + maxtoken)
-		    cp = grow_token_buffer(cp);
-
-		  *cp++ = c;
-		}
-	      *cp = 0;
-	      type_name = token_buffer;
-
-	      c = getc(finput);
-	    }
-
-	  if (c == '$')
-	    {
-	      fprintf(fguard, "yyval");
-	      if (!type_name)
-		type_name = rule->sym->type_name;
-	      if (type_name)
-		fprintf(fguard, ".%s", type_name);
-	      if(!type_name && typed)
-		warns(_("$$ of `%s' has no declared type"), rule->sym->tag);
-	    }
-	  else if (isdigit(c) || c == '-')
-	    {
-	      ungetc (c, finput);
-	      n = read_signed_integer (finput);
-	      c = getc (finput);
-
-	      if (!type_name && n > 0)
-		type_name = get_type_name(n, rule);
-
-	      fprintf(fguard, "yyvsp[%d]", n - stack_offset);
-	      if (type_name)
-		fprintf(fguard, ".%s", type_name);
-	      if (!type_name && typed)
-		warnss (_("$%s of `%s' has no declared type"),
-			int_to_string(n), rule->sym->tag);
-	      continue;
-	    }
-	  else
-	    warns(_("$%s is invalid"), printable_version(c));
-	  break;
-
-	case '@':
-	  c = getc (finput);
-	  if (c == '$')
-	    {
-	      fprintf (fguard, "yyloc");
-	      yylsp_needed = 1;
-	    }
-	  else if (isdigit(c) || c == '-')
-	    {
-	      ungetc (c, finput);
-	      n = read_signed_integer (finput);
-	      c = getc (finput);
-	      fprintf (fguard, "yylsp[%d]", n - stack_offset);
-	      yylsp_needed = 1;
-	      continue;
-	    }
-	  else
-	    {
-	      warns (_("@%s is invalid"), printable_version (c));
-	      n = 1;
-	    }
-	  break;
-
-	case EOF:
-	  fatal (_("unterminated %%guard clause"));
-
-	default:
-	  putc (c, fguard);
-	}
-
-      if (c != '}' || count != 0)
-	c = getc(finput);
-    }
-
-  c = skip_white_space();
-
-  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);
-}
-
-
-
-/* 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.  */
+/*-------------------------------------------------------------------.
+| 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
-copy_action (symbol_list *rule, int stack_offset)
+grammar_midrule_action (void)
 {
-  register int c;
-  register int n;
-  register int count;
-  register char *type_name;
-
-  /* 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 (!nolinesflag)
-    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 '$':
-	      c = getc(finput);
-	      type_name = NULL;
-
-	      if (c == '<')
-		{
-		  register char *cp = token_buffer;
-
-		  while ((c = getc(finput)) != '>' && 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(finput);
-		}
-	      if (c == '$')
-		{
-		  fprintf(faction, "yyval");
-		  if (!type_name)
-		    type_name = get_type_name(0, rule);
-		  if (type_name)
-		    fprintf(faction, ".%s", type_name);
-		  if(!type_name && typed)
-		    warns(_("$$ of `%s' has no declared type"),
-			  rule->sym->tag);
-		}
-	      else if (isdigit(c) || c == '-')
-		{
-		  ungetc (c, finput);
-		  n = read_signed_integer(finput);
-		  c = getc(finput);
-
-		  if (!type_name && n > 0)
-		    type_name = get_type_name(n, rule);
-
-		  fprintf(faction, "yyvsp[%d]", n - stack_offset);
-		  if (type_name)
-		    fprintf(faction, ".%s", type_name);
-		  if(!type_name && typed)
-		    warnss(_("$%s of `%s' has no declared type"),
-				int_to_string(n), rule->sym->tag);
-		  continue;
-		}
-	      else
-		warns(_("$%s is invalid"), printable_version(c));
-
-	      break;
-
-	    case '@':
-	      c = getc (finput);
-	      if (c == '$')
-		{
-		  fprintf (faction, "yyloc");
-		  yylsp_needed = 1;
-		}
-	      else if (isdigit(c) || c == '-')
-		{
-		  ungetc (c, finput);
-		  n = read_signed_integer (finput);
-		  c = getc (finput);
-		  fprintf (faction, "yylsp[%d]", n - stack_offset);
-		  yylsp_needed = 1;
-		  continue;
-		}
-	      else
-		{
-		  warns (_("@%s is invalid"), printable_version (c));
-		  n = 1;
-		}
-	      break;
-
-	    case EOF:
-	      fatal(_("unmatched `{'"));
-
-	    default:
-	      putc(c, faction);
-	    }
-
-          c = getc(finput);
-        }
-
-      /* above loop exits when c is '}' */
-
-      if (--count)
-        {
-	  putc(c, faction);
-	  c = getc(finput);
-	}
-    }
-
-  fprintf(faction, ";\n    break;}");
-}
-
-
+  /* 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_location;
+  symbol *dummy = dummy_symbol_get (dummy_location);
+  symbol_list *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;
+  /* 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;
+
+  if (previous_rule_end)
+    previous_rule_end->next = midrule;
+  else
+    grammar = midrule;
 
-/* generate a dummy symbol, a nonterminal,
-whose name cannot conflict with the user's names. */
+  /* End the dummy's rule.  */
+  previous_rule_end = symbol_list_new (NULL, dummy_location);
+  previous_rule_end->next = current_rule;
 
-bucket *
-gensym (void)
-{
-  register bucket *sym;
+  midrule->next = previous_rule_end;
 
-  sprintf (token_buffer, "@%d", ++gensym_count);
-  sym = getsym(token_buffer);
-  sym->class = SNTERM;
-  sym->value = nvars++;
-  return (sym);
+  /* Insert the dummy nonterminal replacing the midrule action into
+     the current rule.  */
+  grammar_current_rule_symbol_append (dummy, dummy_location);
 }
 
-/* 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.  */
+/* Set the precedence symbol of the current rule to PRECSYM. */
 
 void
-readgram (void)
+grammar_current_rule_prec_set (symbol *precsym, location loc)
 {
-  register int t;
-  register bucket *lhs = NULL;
-  register symbol_list *p;
-  register symbol_list *p1;
-  register bucket *bp;
-
-  symbol_list *crule;	/* points to first symbol_list of current rule.  */
-			/* its symbol is the lhs of the rule.   */
-  symbol_list *crule1;  /* points to the symbol_list preceding crule.  */
-
-  p1 = NULL;
-
-  t = lex();
-
-  while (t != TWO_PERCENTS && t != ENDFILE)
-    {
-      if (t == IDENTIFIER || t == BAR)
-	{
-	  register int actionflag = 0;
-	  int rulelength = 0;  /* number of symbols in rhs of this rule so far  */
-	  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)
-		{
-		  warn(_("ill-formed rule: initial symbol not followed by colon"));
-		  unlex(t);
-		}
-	    }
-
-	  if (nrules == 0 && t == BAR)
-	    {
-	      warn(_("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 = NEW(symbol_list);
-	  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 == SUNKNOWN)
-	    {
-	      lhs->class = SNTERM;
-	      lhs->value = nvars;
-	      nvars++;
-	    }
-	  else if (lhs->class == STOKEN)
-	    warns(_("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)
-		{
-		  register bucket *ssave;
-		  register 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 (actionflag)
-		{
-		  register 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 = NEW(symbol_list);
-		  if (crule1)
-		    crule1->next = p;
-		  else grammar = p;
-		  p->sym = sdummy;
-		  crule1 = NEW(symbol_list);
-		  p->next = crule1;
-		  crule1->next = crule;
-
-		  /* insert the dummy generated by that rule into this rule.  */
-		  nitems++;
-		  p = NEW(symbol_list);
-		  p->sym = sdummy;
-		  p1->next = p;
-		  p1 = p;
-
-		  actionflag = 0;
-		}
-
-	      if (t == IDENTIFIER)
-		{
-		  nitems++;
-		  p = NEW(symbol_list);
-		  p->sym = symval;
-		  p1->next = p;
-		  p1 = p;
-		}
-	      else /* handle an action.  */
-		{
-		  copy_action(crule, rulelength);
-		  actionflag = 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 = NEW(symbol_list);
-	  p1->next = p;
-	  p1 = p;
-
-	  if (t == PREC)
-	    {
-	      warn(_("two @prec's in a row"));
-	      t = lex();
-	      crule->ruleprec = symval;
-	      t = lex();
-	    }
-	  if (t == GUARD)
-	    {
-	      if (! semantic_parser)
-		warn(_("%%guard present but %%semantic_parser not specified"));
-
-	      copy_guard(crule, rulelength);
-	      t = lex();
-	    }
-	  else if (t == LEFT_CURLY)
-	    {
-		/* This case never occurs -wjh */
-	      if (actionflag)
-		warn(_("two actions at end of one rule"));
-	      copy_action(crule, rulelength);
-	      actionflag = 1;
-	      xactions++;	/* -wjh */
-	      t = lex();
-	    }
-	  /* If $$ is being set in default way, warn 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))
-		warnss(_("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)
-	    warn(_("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(STOKEN, SNTERM);
-	  t = lex();
-	}
-      else if (t == NTERM)
-	{
-	  parse_token_decl(SNTERM, STOKEN);
-	  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
-	{
-	  warns(_("invalid input: %s"), token_buffer);
-	  t = lex();
-	}
-    }
-
-  /* grammar has been read.  Do some checking */
-
-  if (nsyms > MAXSHORT)
-    fatals(_("too many symbols (tokens plus nonterminals); maximum %s"),
-	   int_to_string(MAXSHORT));
-  if (nrules == 0)
-    fatal(_("no rules in the input grammar"));
-
-  if (typed == 0	/* JF put out same default YYSTYPE as YACC does */
-      && !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 == SUNKNOWN)
-      {
-	warns(_("symbol %s is used, but is not defined as a token and has no rules"),
-			bp->tag);
-	bp->class = SNTERM;
-	bp->value = nvars++;
-      }
-
-  ntokens = nsyms - nvars;
+  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. */
 
 void
-record_rule_line (void)
+grammar_current_rule_dprec_set (int dprec, location loc)
 {
-  /* Record each rule's source line number in rline table.  */
-
-  if (nrules >= rline_allocated)
-    {
-      rline_allocated = nrules * 2;
-      rline = (short *) xrealloc ((char *) rline,
-				  rline_allocated * sizeof (short));
-    }
-  rline[nrules] = lineno;
+  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;
 }
 
+/* Attach a merge function NAME with argument type TYPE to current
+   rule. */
 
-#if 0
-/* read in a %type declaration and record its information for get_type_name to access */
-/* this is unused.  it is only called from the #if 0 part of readgram */
-static int
-get_type (void)
+void
+grammar_current_rule_merge_set (uniqstr name, location loc)
 {
-  register int k;
-  register int t;
-  register char *name;
-
-  t = lex();
-
-  if (t != TYPENAME)
-    {
-      warn(_("ill-formed %type declaration"));
-      return t;
-    }
-
-  k = strlen(token_buffer);
-  name = NEW2(k + 1, char);
-  strcpy(name, 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)
-	    warns(_("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->sym->type_name, loc);
 }
-#endif
 
-
-/* assign symbol numbers, and write definition of token names into fdefines.
-Set up vectors tags and sprec of names and precedences of symbols.  */
+/* Attach SYM to the current rule.  If needed, move the previous
+   action as a mid-rule action.  */
 
 void
-packsymbols (void)
+grammar_current_rule_symbol_append (symbol *sym, location loc)
 {
-  register bucket *bp;
-  register int tokno = 1;
-  register int i;
-  register int last_user_token_number;
-
-  /* int lossage = 0; JF set but not used */
-
-  tags = NEW2(nsyms + 1, char *);
-  tags[0] = "$";
-  user_toknums = NEW2(nsyms + 1, int);
-  user_toknums[0] = 0;
-
-  sprec = NEW2(nsyms, short);
-  sassoc = NEW2(nsyms, short);
-
-  max_user_token_number = 256;
-  last_user_token_number = 256;
-
-  for (bp = firstsymbol; bp; bp = bp->next)
-    {
-      if (bp->class == SNTERM)
-	{
-	  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)
-				warnss(_("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)
-				warnss(_("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 == STOKEN */
-	{
-	  bp->value = tokno++;
-	}
-
-      if (bp->class == STOKEN)
-	{
-	  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)
-    {
-      register int i;
-
-      token_translations = NEW2(max_user_token_number+1, short);
-
-      /* initialize all entries for literal tokens to 2,
-	 the internal token number for $undefined.,
-	 which represents all invalid inputs.  */
-      for (i = 0; i <= max_user_token_number; i++)
-        token_translations[i] = 2;
-
-      for (bp = firstsymbol; bp; bp = bp->next)
-        {
-          if (bp->value >= ntokens) continue;		  /* non-terminal */
-          if (bp->user_token_number == SALIAS) continue;
-          if (token_translations[bp->user_token_number] != 2)
-	    warnsss(_("tokens %s and %s both assigned number %s"),
-			      tags[token_translations[bp->user_token_number]],
-			      bp->tag,
-			      int_to_string(bp->user_token_number));
-          token_translations[bp->user_token_number] = bp->value;
-        }
-    }
-
-  error_token_number = errtoken->value;
-
-  if (! noparserflag)
-    output_token_defines(ftable);
-
-  if (startval->class == SUNKNOWN)
-    fatals(_("the start symbol %s is undefined"), startval->tag);
-  else if (startval->class == STOKEN)
-    fatals(_("the start symbol %s is a token"), startval->tag);
-
-  start_symbol = startval->value;
-
-  if (definesflag)
-    {
-      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)
+    grammar_midrule_action ();
+  ++nritems;
+  grammar_symbol_append (sym, loc);
 }
 
-/* For named tokens, but not literal ones, define the name.
-   The value is the user token number.
-*/
+/* Attach an ACTION to the current rule.  If needed, move the previous
+   action as a mid-rule action.  */
+
 void
-output_token_defines (FILE *file)
+grammar_current_rule_action_append (const char *action, location loc)
 {
-  bucket *bp;
-  register char *cp, *symbol;
-  register 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;
-	}
-
-      /* 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 && ! rawtoknumflag)
-			? bp->user_token_number
-			: bp->value));
-      if (semantic_parser)
-        fprintf(file, "#define\tT%s\t%d\n", symbol, bp->value);
-    }
-
-  putc('\n', file);
+  if (current_rule->action)
+    grammar_midrule_action ();
+  current_rule->action = action;
+  current_rule->action_location = loc;
 }
 
+
+/*---------------------------------------------------------------.
+| Convert the rules into the representation using RRHS, RLHS and |
+| RITEM.                                                         |
+`---------------------------------------------------------------*/
 
-
-/* convert the rules into the representation using rrhs, rlhs and ritems.  */
-
-void
+static void
 packgram (void)
 {
-  register int itemno;
-  register int ruleno;
-  register symbol_list *p;
-/*  register bucket *bp; JF unused */
-
-  bucket *ruleprec;
+  unsigned int itemno = 0;
+  rule_number ruleno = 0;
+  symbol_list *p = grammar;
 
-  ritem = NEW2(nitems + 1, short);
-  rlhs = NEW2(nrules, short) - 1;
-  rrhs = NEW2(nrules, short) - 1;
-  rprec = NEW2(nrules, short) - 1;
-  rprecsym = NEW2(nrules, short) - 1;
-  rassoc = NEW2(nrules, short) - 1;
+  CALLOC (ritem, nritems);
+  CALLOC (rules, nrules);
 
-  itemno = 0;
-  ruleno = 1;
-
-  p = grammar;
   while (p)
     {
-      rlhs[ruleno] = p->sym->value;
-      rrhs[ruleno] = itemno;
-      ruleprec = p->ruleprec;
+      symbol *ruleprec = p->ruleprec;
+      rules[ruleno].user_number = ruleno;
+      rules[ruleno].number = ruleno;
+      rules[ruleno].lhs = p->sym;
+      rules[ruleno].rhs = ritem + itemno;
+      rules[ruleno].location = p->location;
+      rules[ruleno].useful = true;
+      rules[ruleno].action = p->action;
+      rules[ruleno].action_location = p->action_location;
+      rules[ruleno].dprec = p->dprec;
+      rules[ruleno].merger = p->merger;
 
       p = p->next;
       while (p && p->sym)
 	{
-	  ritem[itemno++] = p->sym->value;
+	  /* item_number = symbol_number.
+	     But the former needs to contain more: negative rule numbers. */
+	  ritem[itemno++] = symbol_number_as_item_number (p->sym->number);
 	  /* A rule gets by default the precedence and associativity
 	     of the last token in it.  */
-          if (p->sym->class == STOKEN)
-	    {
-	      rprec[ruleno] = p->sym->prec;
-	      rassoc[ruleno] = p->sym->assoc;
-	    }
-	  if (p) p = p->next;
+	  if (p->sym->class == token_sym)
+	    rules[ruleno].prec = p->sym;
+	  if (p)
+	    p = p->next;
 	}
 
       /* If this rule has a %prec,
-	 the specified symbol's precedence replaces the default.  */
+         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++] = rule_number_as_item_number (ruleno);
+      ++ruleno;
 
-      ritem[itemno++] = -ruleno;
-      ruleno++;
-
-      if (p) p = p->next;
+      if (p)
+	p = p->next;
     }
 
-  ritem[itemno] = 0;
+  if (itemno != nritems)
+    abort ();
+
+  if (trace_flag & trace_sets)
+    ritem_print (stderr);
 }
 
-/* Read a signed integer from STREAM and return its value.  */
+/*------------------------------------------------------------------.
+| 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.    |
+`------------------------------------------------------------------*/
 
-int
-read_signed_integer (FILE *stream)
+void
+reader (void)
 {
-  register int c = getc(stream);
-  register int sign = 1;
-  register int n;
+  /* Initialize the symbol table.  */
+  symbols_new ();
+
+  /* Construct the accept symbol. */
+  accept = symbol_get ("$accept", empty_location);
+  accept->class = nterm_sym;
+  accept->number = nvars++;
+
+  /* Construct the error token */
+  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.  */
+  undeftoken = symbol_get ("$undefined", empty_location);
+  undeftoken->class = token_sym;
+  undeftoken->number = ntokens++;
+
+  /* Initialize the obstacks. */
+  obstack_init (&pre_prologue_obstack);
+  obstack_init (&post_prologue_obstack);
+
+  finput = xfopen (grammar_file, "r");
+  gram_in = finput;
+
+  gram__flex_debug = trace_flag & trace_scan;
+  gram_debug = trace_flag & trace_parse;
+  scanner_initialize ();
+  gram_parse ();
+
+  /* If something went wrong during the parsing, don't try to
+     continue.  */
+  if (complaint_issued)
+    return;
+
+  /* Grammar has been read.  Do some checking */
+  if (nrules == 0)
+    fatal (_("no rules in the input grammar"));
 
-  if (c == '-')
-    {
-      c = getc(stream);
-      sign = -1;
-    }
-  n = 0;
-  while (isdigit(c))
+  /* Report any undefined symbols and consider them nonterminals.  */
+  symbols_check_defined ();
+
+  /* If the user did not define her ENDTOKEN, do it now. */
+  if (!endtoken)
     {
-      n = 10*n + (c - '0');
-      c = getc(stream);
+      endtoken = symbol_get ("$end", empty_location);
+      endtoken->class = token_sym;
+      endtoken->number = 0;
+      /* Value specified by POSIX.  */
+      endtoken->user_token_number = 0;
     }
 
-  ungetc(c, stream);
+  /* Insert the initial rule, which line is that of the first rule
+     (not that of the start symbol):
+
+     accept: %start EOF.  */
+  {
+    symbol_list *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 <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars))
+    abort ();
+
+  xfclose (finput);
+
+  /* Assign the symbols their symbol numbers.  Write #defines for the
+     token symbols into FDEFINES if requested.  */
+  symbols_pack ();
+
+  /* Convert the grammar into the format described in gram.h.  */
+  packgram ();
 
-  return n * sign;
+  /* The grammar as a symbol_list is no longer needed. */
+  LIST_FREE (symbol_list, grammar);
 }