X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/9a1af7e6b2ba4581b98f18a64db7431fcd8d5b52..4134cae3c5ff2fc3346ebc5b10d5c25c72c72cfe:/src/reader.c?ds=sidebyside

diff --git a/src/reader.c b/src/reader.c
index 3f7cb0e3..49e5158e 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -1,637 +1,726 @@
 /* Input parser for bison
-   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+   Copyright 1984, 1986, 1989, 1992, 1998, 2000
+   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
-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.
+   Bison is free software; you can redistribute it and/or modify
+   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.
 
-Bison 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.
+   Bison 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
-along with Bison; see the file COPYING.  If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   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.  */
 
 
-/* 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 <stdio.h>
-#include <ctype.h>
 #include "system.h"
+#include "obstack.h"
+#include "quotearg.h"
+#include "quote.h"
+#include "getargs.h"
 #include "files.h"
-#include "new.h"
+#include "xalloc.h"
 #include "symtab.h"
 #include "lex.h"
 #include "gram.h"
-#include "machine.h"
-
-#define	LTYPESTR	"\n#ifndef YYLTYPE\ntypedef\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"
+#include "complain.h"
+#include "output.h"
+#include "reader.h"
+#include "conflicts.h"
+#include "macrotab.h"
 
 /* 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 bucket *symval;
-extern int numval;
-extern int failure;
-extern int expected_conflicts;
-extern char *token_buffer;
-
-extern int atoi ();
-
-extern void init_lex();
-extern void tabinit();
-extern void output_headers();
-extern void output_trailers();
-extern void free_symtab();
-extern void open_extra_files();
-extern void fatal();
-extern void fatals();
-extern void unlex();
-extern void done();
-
-extern int skip_white_space();
-extern int parse_percent_token();
-extern int lex();
-
-void read_declarations();
-void copy_definition();
-void parse_token_decl();
-void parse_start_decl();
-void parse_type_decl();
-void parse_assoc_decl();
-void parse_union_decl();
-void parse_expect_decl();
-void copy_action();
-void readgram();
-void record_rule_line();
-void packsymbols();
-void output_token_defines();
-void packgram();
-int read_signed_integer();
-int get_type();
-
-typedef
-  struct symbol_list
-    {
-      struct symbol_list *next;
-      bucket *sym;
-      bucket *ruleprec;
-    }
-  symbol_list;
-
+static int rline_allocated;
 
+typedef struct symbol_list
+{
+  struct symbol_list *next;
+  bucket *sym;
+  bucket *ruleprec;
+}
+symbol_list;
 
 int lineno;
-symbol_list *grammar;
-int start_flag;
-bucket *startval;
 char **tags;
+short *user_toknums;
+static symbol_list *grammar;
+static int start_flag;
+static bucket *startval;
 
 /* 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.  */
+/* Nonzero if %union has been seen.  */
+static int typed;
 
-static int lastprec;  /* incremented for each %left, %right or %nonassoc seen */
-
-static int gensym_count;  /* incremented for each generated symbol */
+/* Incremented for each %left, %right or %nonassoc seen */
+static int lastprec;
 
 static bucket *errtoken;
+static bucket *undeftoken;
+
 
-/* Nonzero if any action or guard uses the @n construct.  */
-static int yylsp_needed;
-
-extern char *version_string;
+/*===================\
+| Low level lexing.  |
+\===================*/
 
-void
-reader()
+static void
+skip_to_char (int target)
 {
-  start_flag = 0;
-  startval = NULL;  /* start symbol not specified yet. */
+  int c;
+  if (target == '\n')
+    complain (_("   Skipping to next \\n"));
+  else
+    complain (_("   Skipping to next %c"), target);
 
-#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;
+  do
+    c = skip_white_space ();
+  while (c != target && c != EOF);
+  if (c != EOF)
+    ungetc (c, finput);
+}
 
-  nsyms = 1;
-  nvars = 0;
-  nrules = 0;
-  nitems = 0;
-  rline_allocated = 10;
-  rline = NEW2(rline_allocated, short);
 
-  typed = 0;
-  lastprec = 0;
+/*---------------------------------------------------------.
+| 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;
 
-  gensym_count = 0;
+  if (c == '-')
+    {
+      c = getc (stream);
+      sign = -1;
+    }
 
-  semantic_parser = 0;
-  pure_parser = 0;
-  yylsp_needed = 0;
+  while (isdigit (c))
+    {
+      n = 10 * n + (c - '0');
+      c = getc (stream);
+    }
 
-  grammar = NULL;
+  ungetc (c, stream);
 
-  init_lex();
-  lineno = 1;
+  return sign * n;
+}
+
+/*--------------------------------------------------------------.
+| Get the data type (alternative in the union) of the value for |
+| symbol N in rule RULE.                                        |
+`--------------------------------------------------------------*/
 
-  /* 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.  */
-  getsym("$illegal.")->class = STOKEN;
-  /* Read the declaration section.  Copy %{ ... %} groups to ftable and fdefines file.
-     Also notice any %token, %left, etc. found there.  */
-  fprintf(ftable, "\n/*  A Bison parser, made from %s", infile);
-  fprintf(ftable, " with Bison version %s  */\n\n", version_string);
-  fprintf(ftable, "#define YYBISON 1  /* Identify Bison output.  */\n\n");
-  read_declarations();
-  /* output the definition of YYLTYPE into the fattrs and fdefines files.  */
-  /* fattrs winds up in the .tab.c file, before bison.simple.  */
-  fprintf(fattrs, LTYPESTR);
-  /* 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 (yylsp_needed)
+static char *
+get_type_name (int n, symbol_list * rule)
+{
+  int i;
+  symbol_list *rp;
+
+  if (n < 0)
     {
-      if (fdefines)
-	fprintf(fdefines, LTYPESTR);
+      complain (_("invalid $ value"));
+      return NULL;
     }
-  /* 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();
-}
 
+  rp = rule;
+  i = 0;
 
+  while (i < n)
+    {
+      rp = rp->next;
+      if (rp == NULL || rp->sym == NULL)
+	{
+	  complain (_("invalid $ value"));
+	  return NULL;
+	}
+      i++;
+    }
 
-/* read from finput until %% is seen.  Discard the %%.
-Handle any % declarations,
-and copy the contents of any %{ ... %} groups to fattrs.  */
+  return rp->sym->type_name;
+}
+
+/*------------------------------------------------------------.
+| Dump the string from FIN to OOUT if non null.  MATCH is the |
+| delimiter of the string (either ' or ").                    |
+`------------------------------------------------------------*/
 
-void
-read_declarations ()
+static inline void
+copy_string2 (FILE *fin, struct obstack *oout, int match, int store)
 {
-  register int c;
-  register int tok;
+  int c;
 
-  for (;;)
+  if (store)
+    obstack_1grow (oout, match);
+
+  c = getc (fin);
+
+  while (c != match)
     {
-      c = skip_white_space();
+      if (c == EOF)
+	fatal (_("unterminated string at end of file"));
+      if (c == '\n')
+	{
+	  complain (_("unterminated string"));
+	  ungetc (c, fin);
+	  c = match;		/* invent terminator */
+	  continue;
+	}
 
-      if (c == '%')
+      obstack_1grow (oout, c);
+
+      if (c == '\\')
 	{
-	  tok = parse_percent_token();
+	  c = getc (fin);
+	  if (c == EOF)
+	    fatal (_("unterminated string at end of file"));
+	  obstack_1grow (oout, c);
 
-	  switch (tok)
-	    {
-	    case TWO_PERCENTS:
-	      return;
+	  if (c == '\n')
+	    lineno++;
+	}
 
-	    case PERCENT_LEFT_CURLY:
-	      copy_definition();
-	      break;
+      c = getc (fin);
+    }
 
-	    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 LEFT:
-	      parse_assoc_decl(LEFT_ASSOC);
-	      break;
+  if (store)
+    obstack_1grow (oout, c);
+}
 
-	    case RIGHT:
-	      parse_assoc_decl(RIGHT_ASSOC);
-	      break;
+/* FIXME. */
 
-	    case NONASSOC:
-	      parse_assoc_decl(NON_ASSOC);
-	      break;
+static inline void
+copy_string (FILE *fin, struct obstack *oout, int match)
+{
+  copy_string2 (fin, oout, match, 1);
+}
 
-	    case SEMANTIC_PARSER:
-	      if (semantic_parser == 0)
-		{
-		  semantic_parser = 1;
-		  open_extra_files();
-		}
-	      break;
+/* FIXME. */
 
-	    case PURE_PARSER:
-	      pure_parser = 1;
-	      break;
+static inline void
+copy_identifier (FILE *fin, struct obstack *oout)
+{
+  int c;
 
-	    default:
-	      fatal("junk after `%%' in definition section");
+  while (isalnum (c = getc (fin)) || c == '_')
+    obstack_1grow (oout, c);
+
+  ungetc (c, fin);
+}
+
+/*-----------------------------------------------------------------.
+| Dump the wannabee comment from IN to OUT1 and OUT2 (which can be |
+| NULL).  In fact we just saw a `/', which might or might not be a |
+| comment.  In any case, copy what we saw.                         |
+|                                                                  |
+| OUT2 might be NULL.                                              |
+`-----------------------------------------------------------------*/
+
+static inline void
+copy_comment2 (FILE *fin, struct obstack *oout1, struct obstack *oout2)
+{
+  int cplus_comment;
+  int ended;
+  int c;
+
+  /* We read a `/', output it. */
+  obstack_1grow (oout1, '/');
+  if (oout2)
+    obstack_1grow (oout2, '/');
+
+  switch ((c = getc (fin)))
+    {
+    case '/':
+      cplus_comment = 1;
+      break;
+    case '*':
+      cplus_comment = 0;
+      break;
+    default:
+      ungetc (c, fin);
+      return;
+    }
+
+  obstack_1grow (oout1, c);
+  if (oout2)
+    obstack_1grow (oout2, c);
+  c = getc (fin);
+
+  ended = 0;
+  while (!ended)
+    {
+      if (!cplus_comment && c == '*')
+	{
+	  while (c == '*')
+	    {
+	      obstack_1grow (oout1, c);
+	      if (oout2)
+		obstack_1grow (oout2, c);
+	      c = getc (fin);
+	    }
+
+	  if (c == '/')
+	    {
+	      obstack_1grow (oout1, c);
+	      if (oout2)
+		obstack_1grow (oout2, c);
+	      ended = 1;
 	    }
 	}
+      else if (c == '\n')
+	{
+	  lineno++;
+	  obstack_1grow (oout1, c);
+	  if (oout2)
+	    obstack_1grow (oout2, c);
+	  if (cplus_comment)
+	    ended = 1;
+	  else
+	    c = getc (fin);
+	}
       else if (c == EOF)
-        fatal("no input grammar");
-      else if (c >= 040 && c <= 0177)
-	fatals ("unknown character `%c' in declaration section", c);
+	fatal (_("unterminated comment"));
       else
-	fatals ("unknown character with code 0x%x in declaration section", c);
+	{
+	  obstack_1grow (oout1, c);
+	  if (oout2)
+	    obstack_1grow (oout2, c);
+	  c = getc (fin);
+	}
     }
 }
 
 
-/* copy the contents of a %{ ... %} into the definitions file.
-The %{ has already been read.  Return after reading the %}.  */
+/*-------------------------------------------------------------------.
+| Dump the comment (actually the current string starting with a `/') |
+| from FIN to OOUT.                                                  |
+`-------------------------------------------------------------------*/
 
-void
-copy_definition ()
+static inline void
+copy_comment (FILE *fin, struct obstack *oout)
 {
-  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;
+  copy_comment2 (fin, oout, NULL);
+}
+
+
+/*-----------------------------------------------------------------.
+| FIN is pointing to a location (i.e., a `@').  Output to OOUT a   |
+| reference to this location. STACK_OFFSET is the number of values |
+| in the current rule so far, which says where to find `$0' with   |
+| respect to the top of the stack.                                 |
+`-----------------------------------------------------------------*/
 
-  if (!nolinesflag)
-    fprintf(fattrs, "#line %d \"%s\"\n", lineno, infile);
+static inline void
+copy_at (FILE *fin, struct obstack *oout, int stack_offset)
+{
+  int c;
+
+  c = getc (fin);
+  if (c == '$')
+    {
+      obstack_sgrow (oout, "yyloc");
+      locations_flag = 1;
+    }
+  else if (isdigit (c) || c == '-')
+    {
+      int n;
+
+      ungetc (c, fin);
+      n = read_signed_integer (fin);
+
+      obstack_fgrow1 (oout, "yylsp[%d]", n - stack_offset);
+      locations_flag = 1;
+    }
+  else
+    {
+      char buf[] = "@c";
+      buf[1] = c;
+      complain (_("%s is invalid"), quote (buf));
+    }
+}
+
+
+/*-------------------------------------------------------------------.
+| FIN is pointing to a wannabee semantic value (i.e., a `$').        |
+|                                                                    |
+| Possible inputs: $[<TYPENAME>]($|integer)                          |
+|                                                                    |
+| Output to OOUT a reference to this semantic value. STACK_OFFSET is |
+| the number of values in the current rule so far, which says where  |
+| to find `$0' with respect to the top of the stack.                 |
+`-------------------------------------------------------------------*/
+
+static inline void
+copy_dollar (FILE *fin, struct obstack *oout,
+	     symbol_list *rule, int stack_offset)
+{
+  int c = getc (fin);
+  const char *type_name = NULL;
+
+  /* Get the type name if explicit. */
+  if (c == '<')
+    {
+      read_type_name (fin);
+      type_name = token_buffer;
+      value_components_used = 1;
+      c = getc (fin);
+    }
+
+  if (c == '$')
+    {
+      obstack_sgrow (oout, "yyval");
+
+      if (!type_name)
+	type_name = get_type_name (0, rule);
+      if (type_name)
+	obstack_fgrow1 (oout, ".%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);
+
+      obstack_fgrow1 (oout, "yyvsp[%d]", n - stack_offset);
+
+      if (type_name)
+	obstack_fgrow1 (oout, ".%s", type_name);
+      if (!type_name && typed)
+	complain (_("$%d of `%s' has no declared type"),
+		  n, rule->sym->tag);
+    }
+  else
+    {
+      char buf[] = "$c";
+      buf[1] = c;
+      complain (_("%s is invalid"), quote (buf));
+    }
+}
+
+/*-------------------------------------------------------------------.
+| Copy the contents of a `%{ ... %}' into the definitions file.  The |
+| `%{' has already been read.  Return after reading the `%}'.        |
+`-------------------------------------------------------------------*/
+
+static void
+copy_definition (void)
+{
+  int c;
+  /* -1 while reading a character if prev char was %. */
+  int after_percent;
+
+#if 0
+  if (!no_lines_flag)
+    obstack_fgrow2 (&attrs_obstack, "#line %d %s\n",
+		    lineno, quotearg_style (c_quoting_style, infile));
+#endif
 
   after_percent = 0;
 
-  c = getc(finput);
+  c = getc (finput);
 
   for (;;)
     {
       switch (c)
 	{
 	case '\n':
-	  putc(c, fattrs);
+	  obstack_1grow (&attrs_obstack, c);
 	  lineno++;
 	  break;
 
 	case '%':
-          after_percent = -1;
+	  after_percent = -1;
 	  break;
-	      
+
 	case '\'':
 	case '"':
-	  match = c;
-	  putc(c, fattrs);
-	  c = getc(finput);
-
-	  while (c != match)
-	    {
-	      if (c == EOF || c == '\n')
-		fatal("unterminated string");
-
-	      putc(c, fattrs);
-	      
-	      if (c == '\\')
-		{
-		  c = getc(finput);
-		  if (c == EOF)
-		    fatal("unterminated string");
-		  putc(c, fattrs);
-		  if (c == '\n')
-		    lineno++;
-		}
-
-	      c = getc(finput);
-	    }
-
-	  putc(c, fattrs);
+	  copy_string (finput, &attrs_obstack, c);
 	  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);
-		}
-	    }
-
+	  copy_comment (finput, &attrs_obstack);
 	  break;
 
 	case EOF:
-	  fatal("unterminated `%{' definition");
+	  fatal ("%s", _("unterminated `%{' definition"));
 
 	default:
-	  putc(c, fattrs);
+	  obstack_1grow (&attrs_obstack, c);
 	}
 
-      c = getc(finput);
+      c = getc (finput);
 
       if (after_percent)
 	{
 	  if (c == '}')
 	    return;
-	  putc('%', fattrs);
+	  obstack_1grow (&attrs_obstack, '%');
 	}
       after_percent = 0;
-
     }
-
 }
 
 
+/*-------------------------------------------------------------------.
+| 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.                                                      |
+`-------------------------------------------------------------------*/
 
-/* 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 (what_is, what_is_not)
-     int what_is, what_is_not;
+static void
+parse_token_decl (symbol_class what_is, symbol_class what_is_not)
 {
-/*   register int start_lineno; JF */
-  register int token = 0;
-  register int prev;
-  register char *typename = 0;
-  int k;
+  token_t token = 0;
+  char *typename = 0;
 
-/*   start_lineno = lineno; JF */
+  /* The symbol being defined.  */
+  struct bucket *symbol = NULL;
 
+  /* After `%token' and `%nterm', any number of symbols maybe be
+     defined.  */
   for (;;)
     {
-      if(ungetc(skip_white_space(), finput) == '%')
-	return;
-
-/*      if (lineno != start_lineno)
-	return; JF */
+      int tmp_char = ungetc (skip_white_space (), finput);
 
-      /* we have not passed a newline, so the token now starting is in this declaration */
-      prev = token;
+      /* `%' (for instance from `%token', or from `%%' etc.) is the
+	 only valid means to end this declaration.  */
+      if (tmp_char == '%')
+	return;
+      if (tmp_char == EOF)
+	fatal (_("Premature EOF after %s"), token_buffer);
 
-      token = lex();
-      if (token == COMMA)
-	continue;
-      if (token == TYPENAME)
+      token = lex ();
+      if (token == tok_comma)
 	{
-	  k = strlen(token_buffer);
-	  typename = NEW2(k + 1, char);
-	  strcpy(typename, token_buffer);
+	  symbol = NULL;
+	  continue;
+	}
+      if (token == tok_typename)
+	{
+	  typename = xstrdup (token_buffer);
 	  value_components_used = 1;
+	  symbol = NULL;
 	}
-      else if (token == IDENTIFIER)
+      else if (token == tok_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 == tok_identifier)
 	{
 	  int oldclass = symval->class;
+	  symbol = symval;
 
-	  if (symval->class == what_is_not)
-	    fatals("symbol %s redefined", symval->tag);
-	  symval->class = what_is;
-	  if (what_is == SNTERM && oldclass != SNTERM)
-	    symval->value = nvars++;
+	  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 (symval->type_name == NULL)
-		symval->type_name = typename;
-	      else
-		fatals("type redeclaration for %s", symval->tag);
+	      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 (prev == IDENTIFIER && token == NUMBER)
-        {
-	  symval->user_token_number = numval;
+      else if (symbol && token == tok_number)
+	{
+	  symbol->user_token_number = numval;
 	  translations = 1;
-        }
+	}
       else
-	fatal("invalid text in %token or %nterm declaration");
+	{
+	  complain (_("`%s' is invalid in %s"),
+		    token_buffer, (what_is == token_sym) ? "%token" : "%nterm");
+	  skip_to_char ('%');
+	}
     }
 
 }
 
 
+/*------------------------------.
+| Parse what comes after %start |
+`------------------------------*/
 
-/* parse what comes after %start */
-
-void
-parse_start_decl ()
+static void
+parse_start_decl (void)
 {
   if (start_flag)
-    fatal("multiple %start declarations");
-  start_flag = 1;
-  if (lex() != IDENTIFIER)
-    fatal("invalid %start declaration");
-  startval = symval;
+    complain (_("multiple %s declarations"), "%start");
+  if (lex () != tok_identifier)
+    complain (_("invalid %s declaration"), "%start");
+  else
+    {
+      start_flag = 1;
+      startval = symval;
+    }
 }
 
+/*-----------------------------------------------------------.
+| read in a %type declaration and record its information for |
+| get_type_name to access                                    |
+`-----------------------------------------------------------*/
 
-
-/* read in a %type declaration and record its information for get_type_name to access */
-
-void
-parse_type_decl ()
+static void
+parse_type_decl (void)
 {
-  register int k;
-  register char *name;
-/*   register int start_lineno; JF */
-
-  if (lex() != TYPENAME)
-    fatal("ill-formed %type declaration");
+  char *name;
 
-  k = strlen(token_buffer);
-  name = NEW2(k + 1, char);
-  strcpy(name, token_buffer);
+  if (lex () != tok_typename)
+    {
+      complain ("%s", _("%type declaration has no <typename>"));
+      skip_to_char ('%');
+      return;
+    }
 
-/*   start_lineno = lineno; */
+  name = xstrdup (token_buffer);
 
   for (;;)
     {
-      register int t;
+      token_t t;
+      int tmp_char = ungetc (skip_white_space (), finput);
 
-      if(ungetc(skip_white_space(), finput) == '%')
+      if (tmp_char == '%')
 	return;
+      if (tmp_char == EOF)
+	fatal (_("Premature EOF after %s"), token_buffer);
 
-/*       if (lineno != start_lineno)
-	return; JF */
-
-      /* we have not passed a newline, so the token now starting is in this declaration */
-
-      t = lex();
+      t = lex ();
 
       switch (t)
 	{
 
-	case COMMA:
-	case SEMICOLON:
+	case tok_comma:
+	case tok_semicolon:
 	  break;
 
-	case IDENTIFIER:
+	case tok_identifier:
 	  if (symval->type_name == NULL)
 	    symval->type_name = name;
-	  else
-	    fatals("type redeclaration for %s", symval->tag);
+	  else if (strcmp (name, symval->type_name) != 0)
+	    complain (_("type redeclaration for %s"), symval->tag);
 
 	  break;
 
 	default:
-	  fatal("invalid %type declaration");
+	  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.  */
-/* assoc is either LEFT_ASSOC, RIGHT_ASSOC or NON_ASSOC.  */
+/*----------------------------------------------------------------.
+| Read in a %left, %right or %nonassoc declaration and record its |
+| information.                                                    |
+`----------------------------------------------------------------*/
 
-void
-parse_assoc_decl (assoc)
-int assoc;
+static void
+parse_assoc_decl (associativity assoc)
 {
-  register int k;
-  register char *name = NULL;
-/*  register int start_lineno; JF */
-  register int prev = 0;	/* JF added = 0 to keep lint happy */
-
-  lastprec++;  /* Assign a new precedence level, never 0.  */
+  char *name = NULL;
+  int prev = 0;
 
-/*   start_lineno = lineno; */
+  lastprec++;			/* Assign a new precedence level, never 0.  */
 
   for (;;)
     {
-      register int t;
+      token_t t;
+      int tmp_char = ungetc (skip_white_space (), finput);
 
-      if(ungetc(skip_white_space(), finput) == '%')
+      if (tmp_char == '%')
 	return;
+      if (tmp_char == EOF)
+	fatal (_("Premature EOF after %s"), token_buffer);
 
-      /* if (lineno != start_lineno)
-	return; JF */
-
-      /* we have not passed a newline, so the token now starting is in this declaration */
-
-      t = lex();
+      t = lex ();
 
       switch (t)
 	{
-
-	case TYPENAME:
-	  k = strlen(token_buffer);
-	  name = NEW2(k + 1, char);
-	  strcpy(name, token_buffer);
+	case tok_typename:
+	  name = xstrdup (token_buffer);
 	  break;
 
-	case COMMA:
+	case tok_comma:
 	  break;
 
-	case IDENTIFIER:
+	case tok_identifier:
 	  if (symval->prec != 0)
-	    fatals("redefining precedence of %s", symval->tag);
+	    complain (_("redefining precedence of %s"), symval->tag);
 	  symval->prec = lastprec;
 	  symval->assoc = assoc;
-	  if (symval->class == SNTERM)
-	    fatals("symbol %s redefined", symval->tag);
-	  symval->class = STOKEN;
+	  if (symval->class == nterm_sym)
+	    complain (_("symbol %s redefined"), symval->tag);
+	  symval->class = token_sym;
 	  if (name)
-	    { /* record the type, if one is specified */
+	    {			/* record the type, if one is specified */
 	      if (symval->type_name == NULL)
 		symval->type_name = name;
-	      else
-		fatals("type redeclaration for %s", symval->tag);
+	      else if (strcmp (name, symval->type_name) != 0)
+		complain (_("type redeclaration for %s"), symval->tag);
 	    }
 	  break;
 
-	case NUMBER:
-	  if (prev == IDENTIFIER)
-            {
+	case tok_number:
+	  if (prev == tok_identifier)
+	    {
 	      symval->user_token_number = numval;
 	      translations = 1;
-            }
-          else	  
-	    fatal("invalid text in association declaration");
+	    }
+	  else
+	    {
+	      complain (_
+			("invalid text (%s) - number should be after identifier"),
+token_buffer);
+	      skip_to_char ('%');
+	    }
 	  break;
 
-	case SEMICOLON:
+	case tok_semicolon:
 	  return;
 
 	default:
-	  fatal("malformatted association declaration");
+	  complain (_("unexpected item: %s"), token_buffer);
+	  skip_to_char ('%');
 	}
 
       prev = t;
@@ -641,42 +730,41 @@ int assoc;
 
 
 
-/* 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.  */
+/*--------------------------------------------------------------.
+| Copy the union declaration into ATTRS_OBSTACK (and fdefines), |
+| where it is made into the definition of YYSTYPE, the type of  |
+| elements of the parser value stack.                           |
+`--------------------------------------------------------------*/
 
-void
-parse_union_decl()
+static void
+parse_union_decl (void)
 {
-  register int c;
-  register int count;
-  register int in_comment;
-  int cplus_comment;
+  int c;
+  int count = 0;
 
   if (typed)
-    fatal("multiple %union declarations");
+    complain (_("multiple %s declarations"), "%union");
 
   typed = 1;
 
-  if (!nolinesflag)
-    fprintf(fattrs, "\n#line %d \"%s\"\n", lineno, infile);
+  if (!no_lines_flag)
+    obstack_fgrow2 (&attrs_obstack, "\n#line %d %s\n",
+		    lineno, quotearg_style (c_quoting_style, 
+					    macro_find("filename")));
   else
-    fprintf(fattrs, "\n");
+    obstack_1grow (&attrs_obstack, '\n');
 
-  fprintf(fattrs, "typedef union");
-  if (fdefines)
-    fprintf(fdefines, "typedef union");
+  obstack_sgrow (&attrs_obstack, "typedef union");
+  if (defines_flag)
+    obstack_sgrow (&defines_obstack, "typedef union");
 
-  count = 0;
-  in_comment = 0;
-
-  c = getc(finput);
+  c = getc (finput);
 
   while (c != EOF)
     {
-      putc(c, fattrs);
-      if (fdefines)
-	putc(c, fdefines);
+      obstack_1grow (&attrs_obstack, c);
+      if (defines_flag)
+	obstack_1grow (&defines_obstack, c);
 
       switch (c)
 	{
@@ -685,635 +773,662 @@ parse_union_decl()
 	  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");
-
-		  if (!cplus_comment && c == '*')
-		    {
-		      c = getc(finput);
-		      if (c == '/')
-			{
-			  putc('/', fattrs);
-			  if (fdefines)
-			    putc('/', fdefines);
-			  in_comment = 0;
-			}
-		    }
-		  else
-		    c = getc(finput);
-		}
-	    }
+	  copy_comment2 (finput, &defines_obstack, &attrs_obstack);
 	  break;
 
-
 	case '{':
 	  count++;
 	  break;
 
 	case '}':
 	  if (count == 0)
-	    fatal ("unmatched close-brace (`}')");
+	    complain (_("unmatched %s"), "`}'");
 	  count--;
-	  if (count == 0)
+	  if (count <= 0)
 	    {
-	      fprintf(fattrs, " YYSTYPE;\n");
-	      if (fdefines)
-		fprintf(fdefines, " YYSTYPE;\n");
+	      obstack_sgrow (&attrs_obstack, " YYSTYPE;\n");
+	      if (defines_flag)
+		obstack_sgrow (&defines_obstack, " YYSTYPE;\n");
 	      /* JF don't choke on trailing semi */
-	      c=skip_white_space();
-	      if(c!=';') ungetc(c,finput);
+	      c = skip_white_space ();
+	      if (c != ';')
+		ungetc (c, finput);
 	      return;
 	    }
 	}
 
-      c = getc(finput);
+      c = getc (finput);
     }
 }
 
-/* parse the declaration %expect N which says to expect N
-   shift-reduce conflicts.  */
 
-void
-parse_expect_decl()
+/*-------------------------------------------------------.
+| Parse the declaration %expect N which says to expect N |
+| shift-reduce conflicts.                                |
+`-------------------------------------------------------*/
+
+static void
+parse_expect_decl (void)
 {
-  register int c;
-  register int count;
-  char buffer[20];
+  int c = skip_white_space ();
+  ungetc (c, finput);
 
-  c = getc(finput);
-  while (c == ' ' || c == '\t')
-    c = getc(finput);
+  if (!isdigit (c))
+    complain (_("argument of %%expect is not an integer"));
+  else
+    expected_conflicts = read_signed_integer (finput);
+}
 
-  count = 0;
-  while (c >= '0' && c <= '9')
+
+/*-------------------------------------------------------------------.
+| 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)
+{
+  token_t token;
+  struct bucket *symbol;
+  char *typename = 0;
+  int usrtoknum;
+
+  translations = 1;
+  token = lex ();		/* fetch typename or first token */
+  if (token == tok_typename)
     {
-      if (count < 20)
-	buffer[count++] = c;
-      c = getc(finput);
+      typename = xstrdup (token_buffer);
+      value_components_used = 1;
+      token = lex ();		/* fetch first token */
     }
-  buffer[count] = 0;
 
-  ungetc (c, finput);
+  /* process first token */
 
-  expected_conflicts = atoi (buffer);
-}
+  if (token != tok_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;
 
-/* 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.  */
+  token = lex ();		/* get number or literal string */
 
-char *
-get_type_name(n, rule)
-int n;
-symbol_list *rule;
-{
-  static char *msg = "invalid $ value";
+  if (token == tok_number)
+    {
+      usrtoknum = numval;
+      token = lex ();		/* okay, did number, now get literal */
+    }
+  else
+    usrtoknum = 0;
 
-  register int i;
-  register symbol_list *rp;
+  /* process literal string token */
 
-  if (n < 0)
-    fatal(msg);
+  if (token != tok_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;
 
-  rp = rule;
-  i = 0;
+  symval->alias = symbol;
+  symbol->alias = symval;
 
-  while (i < n)
+  /* symbol and symval combined are only one symbol.  */
+  nsyms--;
+}
+
+/* FIXME. */
+
+static void
+parse_macro_decl (void)
+{
+  int ch = ungetc (skip_white_space (), finput);
+  char* macro_key;
+  char* macro_value;
+
+  /* Read key. */
+  if (!isalpha (ch) && ch != '_')
     {
-      rp = rp->next;
-      if (rp == NULL || rp->sym == NULL)
-	fatal(msg);
-      i++;
+      complain (_("invalid %s declaration"), "%define");
+      skip_to_char ('%');
+      return;
+    }
+  copy_identifier (finput, &macro_obstack);
+  obstack_1grow (&macro_obstack, 0);
+  macro_key = obstack_finish (&macro_obstack);
+  
+  /* Read value. */
+  ch = skip_white_space ();
+  if (ch != '"')
+    {
+      ungetc (ch, finput);
+      if (ch != EOF)
+	{
+	  complain (_("invalid %s declaration"), "%define");
+	  skip_to_char ('%');
+	  return;
+	}
+      else
+	fatal (_("Premature EOF after %s"), "\"");
     }
+  copy_string2 (finput, &macro_obstack, '"', 0);
+  obstack_1grow (&macro_obstack, 0);
+  macro_value = obstack_finish (&macro_obstack);
 
-  return (rp->sym->type_name);
+  /* Store the (key, value) pair in the environment. */
+  macro_insert (macro_key, macro_value);
 }
 
 
-
-/* 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.  */
+/*----------------------------------.
+| Parse what comes after %skeleton. |
+`----------------------------------*/
 
 void
-copy_guard(rule, stack_offset)
-symbol_list *rule;
-int stack_offset;
+parse_skel_decl (void)
 {
-  register int c;
-  register int n;
-  register int count;
-  register int match;
-  register int ended;
-  register char *type_name;
-  int brace_flag = 0;
-  int cplus_comment;
+  /* Complete with parse_dquoted_param () on the CVS branch 1.29.  */
+}
 
-  /* offset is always 0 if parser has already popped the stack pointer */
-  if (semantic_parser) stack_offset = 0;
+/*------------------------------------------.
+| Parse what comes after %header_extension. |
+`------------------------------------------*/
 
-  fprintf(fguard, "\ncase %d:\n", nrules);
-  if (!nolinesflag)
-    fprintf(fguard, "#line %d \"%s\"\n", lineno, infile);
-  putc('{', fguard);
+static void
+parse_header_extension_decl (void)
+{
+  char buff[32];
 
-  count = 0;
-  c = getc(finput);
+  if (header_extension)
+    complain (_("multiple %%header_extension declarations"));
+  fscanf (finput, "%s", buff);
+  header_extension = xstrdup (buff);
+}
 
-  while (brace_flag ? (count > 0) : (c != ';'))
+/*------------------------------------------.
+| Parse what comes after %source_extension. |
+`------------------------------------------*/
+
+static void
+parse_source_extension_decl (void)
+{
+  char buff[32];
+
+  if (src_extension)
+    complain (_("multiple %%source_extension declarations"));
+  fscanf (finput, "%s", buff);
+  src_extension = xstrdup (buff);
+}
+
+/*----------------------------------------------------------------.
+| Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
+| any `%' declarations, and copy the contents of any `%{ ... %}'  |
+| groups to ATTRS_OBSTACK.                                        |
+`----------------------------------------------------------------*/
+
+static void
+read_declarations (void)
+{
+  int c;
+  int tok;
+
+  for (;;)
     {
-      switch (c)
+      c = skip_white_space ();
+
+      if (c == '%')
 	{
-	case '\n':
-	  putc(c, fguard);
-	  lineno++;
-	  break;
+	  tok = parse_percent_token ();
 
-	case '{':
-	  putc(c, fguard);
-	  brace_flag = 1;
-	  count++;
-	  break;
+	  switch (tok)
+	    {
+	    case tok_two_percents:
+	      return;
 
-	case '}':
-	  putc(c, fguard);
-	  if (count > 0)
-	    count--;
-	  else
-	    fatal("unmatched right brace ('}')");
-          break;
+	    case tok_percent_left_curly:
+	      copy_definition ();
+	      break;
 
-	case '\'':
-	case '"':
-	  match = c;
-	  putc(c, fguard);
-	  c = getc(finput);
+	    case tok_token:
+	      parse_token_decl (token_sym, nterm_sym);
+	      break;
 
-	  while (c != match)
-	    {
-	      if (c == EOF || c == '\n')
-		fatal("unterminated string");
+	    case tok_nterm:
+	      parse_token_decl (nterm_sym, token_sym);
+	      break;
+
+	    case tok_type:
+	      parse_type_decl ();
+	      break;
+
+	    case tok_start:
+	      parse_start_decl ();
+	      break;
+
+	    case tok_union:
+	      parse_union_decl ();
+	      break;
+
+	    case tok_expect:
+	      parse_expect_decl ();
+	      break;
+
+	    case tok_thong:
+	      parse_thong_decl ();
+	      break;
+
+	    case tok_left:
+	      parse_assoc_decl (left_assoc);
+	      break;
 
-	      putc(c, fguard);
+	    case tok_right:
+	      parse_assoc_decl (right_assoc);
+	      break;
+
+	    case tok_nonassoc:
+	      parse_assoc_decl (non_assoc);
+	      break;
+
+	    case tok_hdrext:
+	      parse_header_extension_decl ();
+	      break;
+
+	    case tok_srcext:
+	      parse_source_extension_decl ();
+	      break;
+
+	    case tok_define:
+	      parse_macro_decl ();
+	      break;
 	      
-	      if (c == '\\')
-		{
-		  c = getc(finput);
-		  if (c == EOF)
-		    fatal("unterminated string");
-		  putc(c, fguard);
-		  if (c == '\n')
-		    lineno++;
-		}
+	    case tok_skel:
+	      parse_skel_decl ();
+	      break;
 
-	      c = getc(finput);
+	    case tok_noop:
+	      break;
+
+	    default:
+	      complain (_("unrecognized: %s"), token_buffer);
+	      skip_to_char ('%');
 	    }
+	}
+      else if (c == EOF)
+	fatal (_("no input grammar"));
+      else
+	{
+	  char buf[] = "c";
+	  buf[0] = c;
+	  complain (_("unknown character: %s"), quote (buf));
+	  skip_to_char ('%');
+	}
+    }
+}
+
+/*-------------------------------------------------------------------.
+| 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;
+  char buf[4096];
 
-	  putc(c, fguard);
-	  break;
+  /* offset is always 0 if parser has already popped the stack pointer */
+  if (semantic_parser)
+    stack_offset = 0;
 
-	case '/':
-	  putc(c, fguard);
-	  c = getc(finput);
-	  if (c != '*' && c != '/')
-	    continue;
+  sprintf (buf, "\ncase %d:\n", nrules);
+  obstack_grow (&action_obstack, buf, strlen (buf));
 
-	  cplus_comment = (c == '/');
-	  putc(c, fguard);
-	  c = getc(finput);
+  if (!no_lines_flag)
+    {
+      sprintf (buf, "#line %d %s\n",
+	       lineno, quotearg_style (c_quoting_style, 
+				       macro_find ("filename")));
+      obstack_grow (&action_obstack, buf, strlen (buf));
+    }
+  obstack_1grow (&action_obstack, '{');
 
-	  ended = 0;
-	  while (!ended)
+  count = 1;
+  c = getc (finput);
+
+  while (count > 0)
+    {
+      while (c != '}')
+	{
+	  switch (c)
 	    {
-	      if (!cplus_comment && c == '*')
-		{
-		  while (c == '*')
-		    {
-		      putc(c, fguard);
-		      c = getc(finput);
-		    }
-
-		  if (c == '/')
-		    {
-		      putc(c, fguard);
-		      ended = 1;
-		    }
-		}
-	      else if (c == '\n')
-		{
-		  lineno++;
-		  putc(c, fguard);
-		  if (cplus_comment)
-		    ended = 1;
-		  else
-		    c = getc(finput);
-		}
-	      else if (c == EOF)
-		fatal("unterminated comment");
-	      else
-		{
-		  putc(c, fguard);
-		  c = getc(finput);
-		}
+	    case '\n':
+	      obstack_1grow (&action_obstack, c);
+	      lineno++;
+	      break;
+
+	    case '{':
+	      obstack_1grow (&action_obstack, c);
+	      count++;
+	      break;
+
+	    case '\'':
+	    case '"':
+	      copy_string (finput, &action_obstack, c);
+	      break;
+
+	    case '/':
+	      copy_comment (finput, &action_obstack);
+	      break;
+
+	    case '$':
+	      copy_dollar (finput, &action_obstack,
+			   rule, stack_offset);
+	      break;
+
+	    case '@':
+	      copy_at (finput, &action_obstack,
+		       stack_offset);
+	      break;
+
+	    case EOF:
+	      fatal (_("unmatched %s"), "`{'");
+
+	    default:
+	      obstack_1grow (&action_obstack, c);
 	    }
 
+	  c = getc (finput);
+	}
+
+      /* above loop exits when c is '}' */
+
+      if (--count)
+	{
+	  obstack_1grow (&action_obstack, c);
+	  c = getc (finput);
+	}
+    }
+
+  obstack_sgrow (&action_obstack, ";\n    break;}");
+}
+
+/*-------------------------------------------------------------------.
+| After `%guard' is seen in the input file, copy the actual guard    |
+| into the guards file.  If the guard is followed by an action, copy |
+| that into the actions file.  STACK_OFFSET is the number of values  |
+| in the current rule so far, which says where to find `$0' with     |
+| respect to the top of the stack, for the simple parser in which    |
+| the stack is not popped until after the guard is run.              |
+`-------------------------------------------------------------------*/
+
+static void
+copy_guard (symbol_list *rule, int stack_offset)
+{
+  int c;
+  int count;
+  int brace_flag = 0;
+
+  /* offset is always 0 if parser has already popped the stack pointer */
+  if (semantic_parser)
+    stack_offset = 0;
+
+  obstack_fgrow1 (&guard_obstack, "\ncase %d:\n", nrules);
+  if (!no_lines_flag)
+    obstack_fgrow2 (&guard_obstack, "#line %d %s\n",
+		    lineno, quotearg_style (c_quoting_style,
+					    macro_find ("filename")));
+  obstack_1grow (&guard_obstack, '{');
+
+  count = 0;
+  c = getc (finput);
+
+  while (brace_flag ? (count > 0) : (c != ';'))
+    {
+      switch (c)
+	{
+	case '\n':
+	  obstack_1grow (&guard_obstack, c);
+	  lineno++;
 	  break;
 
-	case '$':
-	  c = getc(finput);
-	  type_name = NULL;
+	case '{':
+	  obstack_1grow (&guard_obstack, c);
+	  brace_flag = 1;
+	  count++;
+	  break;
 
-	  if (c == '<')
+	case '}':
+	  obstack_1grow (&guard_obstack, c);
+	  if (count > 0)
+	    count--;
+	  else
 	    {
-	      register char *cp = token_buffer;
-
-	      while ((c = getc(finput)) != '>' && c > 0)
-		*cp++ = c;
-	      *cp = 0;
-	      type_name = token_buffer;
-
-	      c = getc(finput);
+	      complain (_("unmatched %s"), "`}'");
+	      c = getc (finput);	/* skip it */
 	    }
+	  break;
 
-	  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)	/* JF */
-		fprintf(stderr,"%s:%d:  warning:  $$ of '%s' has no declared type.\n",infile,lineno,rule->sym->tag);
-	    }
+	case '\'':
+	case '"':
+	  copy_string (finput, &guard_obstack, c);
+	  break;
 
-	  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)	/* JF */
-		fprintf(stderr,"%s:%d:  warning:  $%d of '%s' has no declared type.\n",infile,lineno,n,rule->sym->tag);
-	      continue;
-	    }
-	  else
-	    fatals("$%c is invalid",c);	/* JF changed style */
+	case '/':
+	  copy_comment (finput, &guard_obstack);
+	  break;
 
+	case '$':
+	  copy_dollar (finput, &guard_obstack, rule, stack_offset);
 	  break;
 
 	case '@':
-	  c = getc(finput);
-	  if (isdigit(c) || c == '-')
-	    {
-	      ungetc (c, finput);
-	      n = read_signed_integer(finput);
-	      c = getc(finput);
-	    }
-	  else
-	    fatals("@%c is invalid",c);	/* JF changed style */
-
-	  fprintf(fguard, "yylsp[%d]", n - stack_offset);
-	  yylsp_needed = 1;
-
-	  continue;
+	  copy_at (finput, &guard_obstack, stack_offset);
+	  break;
 
 	case EOF:
-	  fatal("unterminated %guard clause");
+	  fatal ("%s", _("unterminated %guard clause"));
 
 	default:
-	  putc(c, fguard);
+	  obstack_1grow (&guard_obstack, c);
 	}
 
       if (c != '}' || count != 0)
-	c = getc(finput);
+	c = getc (finput);
     }
 
-  c = skip_white_space();
+  c = skip_white_space ();
 
-  fprintf(fguard, ";\n    break;}");
+  obstack_sgrow (&guard_obstack, ";\n    break;}");
   if (c == '{')
-    copy_action(rule, stack_offset);
+    copy_action (rule, stack_offset);
   else if (c == '=')
     {
-      c = getc(finput);
+      c = getc (finput);	/* why not skip_white_space -wjh */
       if (c == '{')
-	copy_action(rule, stack_offset);
+	copy_action (rule, stack_offset);
     }
   else
-    ungetc(c, finput);
+    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.  */
-
-void
-copy_action(rule, stack_offset)
-symbol_list *rule;
-int stack_offset;
+static void
+record_rule_line (void)
 {
-  register int c;
-  register int n;
-  register int count;
-  register int match;
-  register int ended;
-  register char *type_name;
-  int cplus_comment;
-
-  /* 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);
+  /* Record each rule's source line number in rline table.  */
 
-  while (count > 0)
+  if (nrules >= rline_allocated)
     {
-      while (c != '}')
-        {
-          switch (c)
-	    {
-	    case '\n':
-	      putc(c, faction);
-	      lineno++;
-	      break;
-
-	    case '{':
-	      putc(c, faction);
-	      count++;
-	      break;
-
-	    case '\'':
-	    case '"':
-	      match = c;
-	      putc(c, faction);
-	      c = getc(finput);
-
-	      while (c != match)
-		{
-		  if (c == EOF || c == '\n')
-		    fatal("unterminated string");
-
-		  putc(c, faction);
-
-		  if (c == '\\')
-		    {
-		      c = getc(finput);
-		      if (c == EOF)
-			fatal("unterminated string");
-		      putc(c, faction);
-		      if (c == '\n')
-			lineno++;
-		    }
-
-		  c = getc(finput);
-		}
-
-	      putc(c, faction);
-	      break;
-
-	    case '/':
-	      putc(c, faction);
-	      c = getc(finput);
-	      if (c != '*' && c != '/')
-		continue;
-
-	      cplus_comment = (c == '/');
-	      putc(c, faction);
-	      c = getc(finput);
+      rline_allocated = nrules * 2;
+      rline = XREALLOC (rline, short, rline_allocated);
+    }
+  rline[nrules] = lineno;
+}
 
-	      ended = 0;
-	      while (!ended)
-		{
-		  if (!cplus_comment && c == '*')
-		    {
-		      while (c == '*')
-		        {
-			  putc(c, faction);
-			  c = getc(finput);
-			}
-
-		      if (c == '/')
-			{
-			  putc(c, faction);
-			  ended = 1;
-			}
-		    }
-		  else if (c == '\n')
-		    {
-		      lineno++;
-		      putc(c, faction);
-		      if (cplus_comment)
-			ended = 1;
-		      else
-		        c = getc(finput);
-		    }
-		  else if (c == EOF)
-		    fatal("unterminated comment");
-		  else
-		    {
-		      putc(c, faction);
-		      c = getc(finput);
-		    }
-		}
 
-	      break;
+/*-------------------------------------------------------------------.
+| Generate a dummy symbol, a nonterminal, whose name cannot conflict |
+| with the user's names.                                             |
+`-------------------------------------------------------------------*/
 
-	    case '$':
-	      c = getc(finput);
-	      type_name = NULL;
+static bucket *
+gensym (void)
+{
+  /* Incremented for each generated symbol */
+  static int gensym_count = 0;
+  static char buf[256];
 
-	      if (c == '<')
-		{
-		  register char *cp = token_buffer;
+  bucket *sym;
 
-		  while ((c = getc(finput)) != '>' && c > 0)
-		    *cp++ = c;
-		  *cp = 0;
-		  type_name = token_buffer;
-		  value_components_used = 1;
+  sprintf (buf, "@%d", ++gensym_count);
+  token_buffer = buf;
+  sym = getsym (token_buffer);
+  sym->class = nterm_sym;
+  sym->value = nvars++;
+  return sym;
+}
 
-		  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)	/* JF */
-		    fprintf(stderr,"%s:%d:  warning:  $$ of '%s' has no declared type.\n",infile,lineno,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)	/* JF */
-		    fprintf(stderr,"%s:%d:  warning:  $%d of '%s' has no declared type.\n",infile,lineno,n,rule->sym->tag);
-		  continue;
-		}
-	      else
-		fatals("$%c is invalid",c);	/* JF changed format */
+#if 0
+/*------------------------------------------------------------------.
+| read in a %type declaration and record its information for        |
+| get_type_name to access.  This is unused.  It is only called from |
+| the #if 0 part of readgram                                        |
+`------------------------------------------------------------------*/
+
+static int
+get_type (void)
+{
+  int k;
+  token_t token;
+  char *name;
 
-	      break;
+  token = lex ();
 
-	    case '@':
-	      c = getc(finput);
-	      if (isdigit(c) || c == '-')
-		{
-		  ungetc (c, finput);
-		  n = read_signed_integer(finput);
-		  c = getc(finput);
-		}
-	      else
-		fatal("invalid @-construct");
+  if (token != tok_typename)
+    {
+      complain (_("invalid %s declaration"), "%type");
+      return t;
+    }
 
-	      fprintf(faction, "yylsp[%d]", n - stack_offset);
-	      yylsp_needed = 1;
+  name = xstrdup (token_buffer);
 
-	      continue;
+  for (;;)
+    {
+      token = lex ();
 
-	    case EOF:
-	      fatal("unmatched '{'");
+      switch (token)
+	{
+	case tok_semicolon:
+	  return lex ();
 
-	    default:
-	      putc(c, faction);
-	    }
+	case tok_comma:
+	  break;
 
-          c = getc(finput);
-        }
+	case tok_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);
 
-      /* above loop exits when c is '}' */
+	  break;
 
-      if (--count)
-        {
-	  putc(c, faction);
-	  c = getc(finput);
+	default:
+	  return token;
 	}
     }
-
-  fprintf(faction, ";\n    break;}");
-}
-
-
-
-/* generate a dummy symbol, a nonterminal,
-whose name cannot conflict with the user's names. */
-
-bucket *
-gensym()
-{
-  register bucket *sym;
-
-  sprintf (token_buffer, "@%d", ++gensym_count);
-  sym = getsym(token_buffer);
-  sym->class = SNTERM;
-  sym->value = nvars++;
-  return (sym);
 }
 
-/* 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.  */
-
-void
-readgram()
+#endif
+
+/*------------------------------------------------------------------.
+| Parse the input grammar into a one symbol_list structure.  Each   |
+| rule is represented by a sequence of symbols: the left hand side  |
+| followed by the contents of the right hand side, followed by a    |
+| null pointer instead of a symbol to terminate the rule.  The next |
+| symbol is the lhs of the following rule.                          |
+|                                                                   |
+| All guards and actions are copied out to the appropriate files,   |
+| labelled by the rule number they apply to.                        |
+`------------------------------------------------------------------*/
+
+static void
+readgram (void)
 {
-  register int t;
-  register bucket *lhs;
-  register symbol_list *p;
-  register symbol_list *p1;
-  register bucket *bp;
+  token_t t;
+  bucket *lhs = NULL;
+  symbol_list *p;
+  symbol_list *p1;
+  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.  */
+  /* 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();
+  t = lex ();
 
-  while (t != TWO_PERCENTS && t != ENDFILE)
+  while (t != tok_two_percents && t != tok_eof)
     {
-      if (t == IDENTIFIER || t == BAR)
+      if (t == tok_identifier || t == tok_bar)
 	{
-	  register int actionflag = 0;
-	  int rulelength = 0;  /* number of symbols in rhs of this rule so far  */
+	  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)
+	  if (t == tok_identifier)
 	    {
 	      lhs = symval;
-    
-	      t = lex();
-	      if (t != COLON)
-		fatal("ill-formed rule");
-	    }
-
-	  if (nrules == 0)
-	    {
-	      if (t == BAR)
-		fatal("grammar starts with vertical bar");
 
 	      if (!start_flag)
-		startval = lhs;
+		{
+		  startval = lhs;
+		  start_flag = 1;
+		}
+
+	      t = lex ();
+	      if (t != tok_colon)
+		{
+		  complain (_("ill-formed rule: initial symbol not followed by colon"));
+		  unlex (t);
+		}
 	    }
 
+	  if (nrules == 0 && t == tok_bar)
+	    {
+	      complain (_("grammar starts with vertical bar"));
+	      lhs = symval;	/* BOGUS: use a random symval */
+	    }
 	  /* start a new rule and record its lhs.  */
 
 	  nrules++;
@@ -1321,7 +1436,7 @@ readgram()
 
 	  record_rule_line ();
 
-	  p = NEW(symbol_list);
+	  p = XCALLOC (symbol_list, 1);
 	  p->sym = lhs;
 
 	  crule1 = p1;
@@ -1335,55 +1450,63 @@ readgram()
 
 	  /* mark the rule's lhs as a nonterminal if not already so.  */
 
-	  if (lhs->class == SUNKNOWN)
+	  if (lhs->class == unknown_sym)
 	    {
-	      lhs->class = SNTERM;
+	      lhs->class = nterm_sym;
 	      lhs->value = nvars;
 	      nvars++;
 	    }
-	  else if (lhs->class == STOKEN)
-	    fatals("rule given for %s, which is a token", lhs->tag);
+	  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();
+	      t = lex ();
+	      if (t == tok_prec)
+		{
+		  t = lex ();
+		  crule->ruleprec = symval;
+		  t = lex ();
+		}
 
-	      if (! (t == IDENTIFIER || t == LEFT_CURLY)) break;
+	      if (!(t == tok_identifier || t == tok_left_curly))
+		break;
 
 	      /* If next token is an identifier, see if a colon follows it.
-		 If one does, exit this rule now.  */
-	      if (t == IDENTIFIER)
+	         If one does, exit this rule now.  */
+	      if (t == tok_identifier)
 		{
-		  register bucket *ssave;
-		  register int t1;
+		  bucket *ssave;
+		  token_t t1;
 
 		  ssave = symval;
-		  t1 = lex();
-		  unlex(t1);
+		  t1 = lex ();
+		  unlex (t1);
 		  symval = ssave;
-		  if (t1 == COLON) break;
+		  if (t1 == tok_colon)
+		    break;
 
-		  if(!first_rhs)	/* JF */
+		  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)
+	         of a rule, so make a dummy rule to reduce it to a
+	         non-terminal.  */
+	      if (action_flag)
 		{
-		  register bucket *sdummy;
+		  bucket *sdummy;
 
-		  /* Since the action was written out with this rule's */
-		  /* number, we must write give the new rule this number */
-		  /* by inserting the new rule before it.  */
+		  /* 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();
+		  sdummy = gensym ();
 
 		  /* Make a new rule, whose body is empty,
 		     before the current one, so that the action
@@ -1391,254 +1514,310 @@ readgram()
 		  nrules++;
 		  nitems++;
 		  record_rule_line ();
-		  p = NEW(symbol_list);
+		  p = XCALLOC (symbol_list, 1);
 		  if (crule1)
 		    crule1->next = p;
-		  else grammar = p;
+		  else
+		    grammar = p;
 		  p->sym = sdummy;
-		  crule1 = NEW(symbol_list);
+		  crule1 = XCALLOC (symbol_list, 1);
 		  p->next = crule1;
 		  crule1->next = crule;
 
-		  /* insert the dummy generated by that rule into this rule.  */
+		  /* Insert the dummy generated by that rule into this
+		     rule.  */
 		  nitems++;
-		  p = NEW(symbol_list);
+		  p = XCALLOC (symbol_list, 1);
 		  p->sym = sdummy;
 		  p1->next = p;
 		  p1 = p;
 
-		  actionflag = 0;
+		  action_flag = 0;
 		}
 
-	      if (t == IDENTIFIER)
+	      if (t == tok_identifier)
 		{
 		  nitems++;
-		  p = NEW(symbol_list);
+		  p = XCALLOC (symbol_list, 1);
 		  p->sym = symval;
 		  p1->next = p;
 		  p1 = p;
 		}
-	      else /* handle an action.  */
+	      else		/* handle an action.  */
 		{
-		  copy_action(crule, rulelength);
-		  actionflag = 1;
+		  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 = NEW(symbol_list);
+	  p = XCALLOC (symbol_list, 1);
 	  p1->next = p;
 	  p1 = p;
 
-	  if (t == PREC)
+	  if (t == tok_prec)
 	    {
-	      t = lex();
+	      complain (_("two @prec's in a row"));
+	      t = lex ();
 	      crule->ruleprec = symval;
-	      t = lex();
+	      t = lex ();
 	    }
-	  if (t == GUARD)
+	  if (t == tok_guard)
 	    {
-	      if (! semantic_parser)
-		fatal("%guard present but %semantic_parser not specified");
+	      if (!semantic_parser)
+		complain (_("%%guard present but %%semantic_parser not specified"));
 
-	      copy_guard(crule, rulelength);
-	      t = lex();
+	      copy_guard (crule, rulelength);
+	      t = lex ();
 	    }
-	  else if (t == LEFT_CURLY)
+	  else if (t == tok_left_curly)
 	    {
-	      if (actionflag) fatal("two actions at end of one rule");
-	      copy_action(crule, rulelength);
-	      t = lex();
+	      /* 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,
-	     warn if any type mismatch.  */
-	  else if (!xactions && first_rhs && lhs->type_name != first_rhs->type_name)
+	  /* 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))
-		fprintf(stderr, "%s:%d:  warning:  type clash ('%s' '%s') on default action\n",
-			infile,
-			lineno,
-			lhs->type_name ? lhs->type_name : "",
-			first_rhs->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)
-	    fprintf(stderr,
-		    "%s:%d:  warning: empty rule for typed nonterminal, and no action\n",
-		    infile,
-		    lineno);
-	  if (t == SEMICOLON)
-	    t = lex();
+	    complain (_("empty rule for typed nonterminal, and no action"));
+	  if (t == tok_semicolon)
+	    t = lex ();
 	}
+#if 0
       /* these things can appear as alternatives to rules.  */
-      else if (t == TOKEN)
+/* 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 == tok_token)
 	{
-	  parse_token_decl(STOKEN, SNTERM);
-	  t = lex();
+	  parse_token_decl (token_sym, nterm_sym);
+	  t = lex ();
 	}
-      else if (t == NTERM)
+      else if (t == tok_nterm)
 	{
-	  parse_token_decl(SNTERM, STOKEN);
-	  t = lex();
+	  parse_token_decl (nterm_sym, token_sym);
+	  t = lex ();
 	}
-      else if (t == TYPE)
+      else if (t == tok_type)
 	{
-	  t = get_type();
+	  t = get_type ();
 	}
-      else if (t == UNION)
+      else if (t == tok_union)
 	{
-	  parse_union_decl();
-	  t = lex();
+	  parse_union_decl ();
+	  t = lex ();
 	}
-      else if (t == EXPECT)
+      else if (t == tok_expect)
 	{
-	  parse_expect_decl();
-	  t = lex();
+	  parse_expect_decl ();
+	  t = lex ();
 	}
-      else if (t == START)
+      else if (t == tok_start)
 	{
-	  parse_start_decl();
-	  t = lex();
+	  parse_start_decl ();
+	  t = lex ();
 	}
+#endif
+
       else
-	fatal("invalid input");
+	{
+	  complain (_("invalid input: %s"), quote (token_buffer));
+	  t = lex ();
+	}
     }
 
+  /* grammar has been read.  Do some checking */
+
   if (nsyms > MAXSHORT)
-    fatals("too many symbols (tokens plus nonterminals); maximum %d",
+    fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
 	   MAXSHORT);
   if (nrules == 0)
-    fatal("no 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");
-    }
+    fatal (_("no rules in the input grammar"));
 
   /* Report any undefined symbols and consider them nonterminals.  */
 
   for (bp = firstsymbol; bp; bp = bp->next)
-    if (bp->class == SUNKNOWN)
+    if (bp->class == unknown_sym)
       {
-	fprintf(stderr, "symbol %s used, not defined as token, and no rules for it\n",
-			bp->tag);
-	failure = 1;
-	bp->class = SNTERM;
+	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;
 }
 
-
-void
-record_rule_line ()
+/* At the end of the grammar file, some C source code must
+   be stored. It is going to be associated to the epilogue
+   directive.  */
+static void
+read_additionnal_code (void)
 {
-  /* Record each rule's source line number in rline table.  */
-
-  if (nrules >= rline_allocated)
-    {
-      rline_allocated = nrules * 2;
-      rline = (short *) xrealloc (rline,
-				  rline_allocated * sizeof (short));
-    }
-  rline[nrules] = lineno;
+  char c;
+  struct obstack el_obstack;
+  
+  obstack_init (&el_obstack);
+
+  while ((c = getc (finput)) != EOF)
+    obstack_1grow (&el_obstack, c);
+  
+  obstack_1grow (&el_obstack, 0);
+  macro_insert ("epilogue", obstack_finish (&el_obstack));
 }
 
+
+/*--------------------------------------------------------------.
+| For named tokens, but not literal ones, define the name.  The |
+| value is the user token number.                               |
+`--------------------------------------------------------------*/
 
-/* read in a %type declaration and record its information for get_type_name to access */
-
-int
-get_type()
+static void
+output_token_defines (struct obstack *oout)
 {
-  register int k;
-  register int t;
-  register char *name;
-
-  t = lex();
-
-  if (t != TYPENAME)
-    fatal("ill-formed %type declaration");
-
-  k = strlen(token_buffer);
-  name = NEW2(k + 1, char);
-  strcpy(name, token_buffer);
+  bucket *bp;
+  char *cp, *symbol;
+  char c;
 
-  for (;;)
+  for (bp = firstsymbol; bp; bp = bp->next)
     {
-      t = lex();
+      symbol = bp->tag;		/* get symbol */
 
-      switch (t)
+      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)
 	{
-	case SEMICOLON:
-	  return (lex());
-
-	case COMMA:
-	  break;
-
-	case IDENTIFIER:
-	  if (symval->type_name == NULL)
-	    symval->type_name = name;
+	  /* use literal string only if given a symbol with an alias */
+	  if (bp->alias)
+	    symbol = bp->alias->tag;
 	  else
-	    fatals("type redeclaration for %s", symval->tag);
+	    continue;
+	}
 
-	  break;
+      /* Don't #define nonliteral tokens whose names contain periods.  */
+      cp = symbol;
+      while ((c = *cp++) && c != '.');
+      if (c != '\0')
+	continue;
 
-	default:
-	  return (t);
-	}
+      obstack_fgrow2 (oout, "# define\t%s\t%d\n",
+		      symbol,
+		      (translations ? bp->user_token_number : bp->value));
+      if (semantic_parser)
+	obstack_fgrow2 (oout, "# define\tT%s\t%d\n", symbol, bp->value);
     }
 }
 
 
+/*------------------------------------------------------------------.
+| Assign symbol numbers, and write definition of token names into   |
+| FDEFINES.  Set up vectors TAGS and SPREC of names and precedences |
+| of symbols.                                                       |
+`------------------------------------------------------------------*/
 
-/* assign symbol numbers, and write definition of token names into fdefines.
-Set up vectors tags and sprec of names and precedences of symbols.  */
-
-void
-packsymbols()
+static void
+packsymbols (void)
 {
-  register bucket *bp;
-  register int tokno = 1;
-  register int i;
-  register int last_user_token_number;
-
-  /* int lossage = 0; JF set but not used */
+  bucket *bp;
+  int tokno = 1;
+  int i;
+  int last_user_token_number;
+  static char DOLLAR[] = "$";
 
-  tags = NEW2(nsyms + 1, char *);
-  tags[0] = "$";
+  tags = XCALLOC (char *, nsyms + 1);
+  tags[0] = DOLLAR;
+  user_toknums = XCALLOC (short, nsyms + 1);
+  user_toknums[0] = 0;
 
-  sprec = NEW2(nsyms, short);
-  sassoc = NEW2(nsyms, short);
+  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 == SNTERM)
+      if (bp->class == nterm_sym)
 	{
 	  bp->value += ntokens;
 	}
-      else
+      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;
-	  bp->value = tokno++;
 	}
 
       tags[bp->value] = bp->tag;
+      user_toknums[bp->value] = bp->user_token_number;
       sprec[bp->value] = bp->prec;
       sassoc[bp->value] = bp->assoc;
 
@@ -1646,54 +1825,60 @@ packsymbols()
 
   if (translations)
     {
-      register int i;
+      int j;
 
-      token_translations = NEW2(max_user_token_number+1, short);
+      token_translations = XCALLOC (short, max_user_token_number + 1);
 
-      /* initialize all entries for literal tokens to 2,
-	 the internal token number for $illegal., which represents all invalid inputs.  */
-      for (i = 0; i <= max_user_token_number; i++)
-        token_translations[i] = 2;      
-    }
+      /* 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;
-      if (translations)
+      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)
-	    {
-	    	/* JF made this a call to fatals() */
-	      fatals( "tokens %s and %s both assigned number %d",
-			      tags[token_translations[bp->user_token_number]],
-			      bp->tag,
-			      bp->user_token_number);
-	    }
+	    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;
 
-  output_token_defines(ftable);
+  output_token_defines (&output_obstack);
+  obstack_1grow (&output_obstack, 0);
+  macro_insert ("tokendef", obstack_finish (&output_obstack));
+
+#if 0
+  if (!no_parser_flag)
+    output_token_defines (&table_obstack);
+#endif
 
-  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);
+  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 (definesflag)
+  if (defines_flag)
     {
-      output_token_defines(fdefines);
+      output_token_defines (&defines_obstack);
 
       if (!pure_parser)
 	{
 	  if (spec_name_prefix)
-	    fprintf(fdefines, "\nextern YYSTYPE %slval;\n", spec_name_prefix);
+	    obstack_fgrow1 (&defines_obstack, "\nextern YYSTYPE %slval;\n",
+			    spec_name_prefix);
 	  else
-	    fprintf(fdefines, "\nextern YYSTYPE yylval;\n");
+	    obstack_sgrow (&defines_obstack,
+				 "\nextern YYSTYPE yylval;\n");
 	}
 
       if (semantic_parser)
@@ -1701,73 +1886,39 @@ packsymbols()
 	  {
 	    /* don't make these for dummy nonterminals made by gensym.  */
 	    if (*tags[i] != '@')
-	      fprintf(fdefines, "#define\tNT%s\t%d\n", tags[i], i);
+	       obstack_fgrow2 (&defines_obstack,
+			       "# define\tNT%s\t%d\n", tags[i], i);
 	  }
 #if 0
       /* `fdefines' is now a temporary file, so we need to copy its
          contents in `done', so we can't close it here.  */
-      fclose(fdefines);
+      fclose (fdefines);
       fdefines = NULL;
 #endif
     }
 }
-      
-
-void
-output_token_defines(file)
-FILE *file;
-{
-  bucket *bp;
-
-  for (bp = firstsymbol; bp; bp = bp->next)
-    {
-      if (bp->value >= ntokens) continue;
-
-      /* For named tokens, but not literal ones, define the name.  */
-      /* The value is the user token number.  */
-
-      if ('\'' != *tags[bp->value] && bp != errtoken)
-	{
-	  register char *cp = tags[bp->value];
-	  register char c;
-
-	  /* Don't #define nonliteral tokens whose names contain periods.  */
-
-	  while ((c = *cp++) && c != '.');
-	  if (!c)
-	    {
-              fprintf(file, "#define\t%s\t%d\n", tags[bp->value],
-			    (translations ? bp->user_token_number : bp->value));
-	      if (semantic_parser)
-                fprintf(file, "#define\tT%s\t%d\n", tags[bp->value],
-			      bp->value);
-	    }
-	}
-    }
-
-  putc('\n', file);
-}
 
 
+/*---------------------------------------------------------------.
+| Convert the rules into the representation using RRHS, RLHS and |
+| RITEMS.                                                        |
+`---------------------------------------------------------------*/
 
-/* convert the rules into the representation using rrhs, rlhs and ritems.  */
-
-void
-packgram()
+static void
+packgram (void)
 {
-  register int itemno;
-  register int ruleno;
-  register symbol_list *p;
-/*  register bucket *bp; JF unused */
+  int itemno;
+  int ruleno;
+  symbol_list *p;
 
   bucket *ruleprec;
 
-  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;
+  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;
 
   itemno = 0;
   ruleno = 1;
@@ -1785,55 +1936,113 @@ packgram()
 	  ritem[itemno++] = p->sym->value;
 	  /* A rule gets by default the precedence and associativity
 	     of the last token in it.  */
-          if (p->sym->class == STOKEN)
+	  if (p->sym->class == token_sym)
 	    {
 	      rprec[ruleno] = p->sym->prec;
 	      rassoc[ruleno] = p->sym->assoc;
 	    }
-	  if (p) p = p->next;
+	  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;
+	  rprec[ruleno] = ruleprec->prec;
+	  rassoc[ruleno] = ruleprec->assoc;
 	  rprecsym[ruleno] = ruleprec->value;
 	}
 
       ritem[itemno++] = -ruleno;
       ruleno++;
 
-      if (p) p = p->next;
+      if (p)
+	p = p->next;
     }
 
   ritem[itemno] = 0;
 }
 
-/* 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 guards are copied into the GUARD_OBSTACK |
+| and all actions into ACTION_OBSTACK, in each case forming the body |
+| of a C function (YYGUARD or YYACTION) which contains a switch      |
+| statement to decide which guard or action to execute.              |
+`-------------------------------------------------------------------*/
 
-int
-read_signed_integer (stream)
-     FILE *stream;
+void
+reader (void)
 {
-  register int c = getc(stream);
-  register int sign = 1;
-  register int n;
+  start_flag = 0;
+  startval = NULL;		/* start symbol not specified yet. */
 
-  if (c == '-')
-    {
-      c = getc(stream);
-      sign = -1;
-    }
-  n = 0;
-  while (isdigit(c))
-    {
-      n = 10*n + (c - '0');
-      c = getc(stream);
-    }
+#if 0
+  /* initially assume token number translation not needed.  */
+  translations = 0;
+#endif
+  /* Nowadays translations is always set to 1, since we give `error' a
+     user-token-number to satisfy the Posix demand for YYERRCODE==256.
+   */
+  translations = 1;
+
+  nsyms = 1;
+  nvars = 0;
+  nrules = 0;
+  nitems = 0;
+  rline_allocated = 10;
+  rline = XCALLOC (short, rline_allocated);
+
+  typed = 0;
+  lastprec = 0;
 
-  ungetc(c, stream);
+  semantic_parser = 0;
+  pure_parser = 0;
+
+  grammar = NULL;
 
-  return n * sign;
+  init_lex ();
+  lineno = 1;
+
+  /* Initialize the macro obstack.  */
+  obstack_init (&macro_obstack);
+
+  /* Initialize the symbol table.  */
+  tabinit ();
+
+  /* Construct the error token */
+  errtoken = getsym ("error");
+  errtoken->class = token_sym;
+  errtoken->user_token_number = 256;	/* Value specified by POSIX.  */
+
+  /* Construct a token that represents all undefined literal tokens.
+     It is always token number 2.  */
+  undeftoken = getsym ("$undefined.");
+  undeftoken->class = token_sym;
+  undeftoken->user_token_number = 2;
+
+  /* Read the declaration section.  Copy %{ ... %} groups to
+     TABLE_OBSTACK and FDEFINES file.  Also notice any %token, %left,
+     etc. found there.  */
+  read_declarations ();
+  /* Read in the grammar, build grammar in list form.  Write out
+     guards and actions.  */
+  readgram ();
+  /* Some C code is given at the end of the grammar file. */
+  read_additionnal_code ();
+  /* Now we know whether we need the line-number stack.  If we do,
+     write its type into the .tab.h file.  */
+#if 0
+  if (defines_flag)
+    reader_output_yylsp (&defines_obstack);
+#endif
+  /* 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 ();
 }