* src/getargs.c (fixed_outfiles): Rename as...

[bison.git] / src / reader.c
diff --git a/src/reader.c b/src/reader.c

index ae7e1d649d8abb99e7cabb912ce2e46955356704..1dfe020b588343831a07b5ea140c5873fab6c1a4 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -1,414 +1,355 @@
  /* Input parser for bison
  /* Input parser for bison
-   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+   Copyright (C) 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 "system.h"
+#include "getargs.h"
  #include "files.h"
  #include "files.h"
-#include "new.h"
+#include "xalloc.h"
  #include "symtab.h"
  #include "lex.h"
  #include "gram.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"
+
+extern char *printable_version PARAMS ((int));
+
+#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'  */
  
  /* 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 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;
  
  int lineno;
-symbol_list *grammar;
-int start_flag;
-bucket *startval;
  char **tags;
  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;
  
  
  /* 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 typed;              /* nonzero if %union has been seen.  */
  
  
-static int lastprec;  /* incremented for each %left, %right or %nonassoc seen */
+static int lastprec;           /* incremented for each %left, %right or %nonassoc seen */
  
  
-static int gensym_count;  /* incremented for each generated symbol */
+static int gensym_count;       /* incremented for each generated symbol */
  
  static bucket *errtoken;
  
  static bucket *errtoken;
+static bucket *undeftoken;
  
  /* Nonzero if any action or guard uses the @n construct.  */
  static int yylsp_needed;
  
  /* Nonzero if any action or guard uses the @n construct.  */
  static int yylsp_needed;
+\f
  
  
-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. */
-
-#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);
+  int c;
+  if (target == '\n')
+    complain (_("   Skipping to next \\n"));
+  else
+    complain (_("   Skipping to next %c"), target);
  
  
-  typed = 0;
-  lastprec = 0;
+  do
+    c = skip_white_space ();
+  while (c != target && c != EOF);
+  if (c != EOF)
+    ungetc (c, finput);
+}
  
  
-  gensym_count = 0;
  
  
-  semantic_parser = 0;
-  pure_parser = 0;
-  yylsp_needed = 0;
+/*---------------------------------------------------------.
+| Read a signed integer from STREAM and return its value.  |
+`---------------------------------------------------------*/
  
  
-  grammar = NULL;
-
-  init_lex();
-  lineno = 1;
+static inline int
+read_signed_integer (FILE *stream)
+{
+  int c = getc (stream);
+  int sign = 1;
+  int n = 0;
  
  
-  /* 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("$undefined.")->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)
+  if (c == '-')
      {
      {
-      if (fdefines)
-       fprintf(fdefines, LTYPESTR);
+      c = getc (stream);
+      sign = -1;
      }
      }
-  /* 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();
-}
  
  
+  while (isdigit (c))
+    {
+      n = 10 * n + (c - '0');
+      c = getc (stream);
+    }
  
  
+  ungetc (c, stream);
  
  
-/* read from finput until %% is seen.  Discard the %%.
-Handle any % declarations,
-and copy the contents of any %{ ... %} groups to fattrs.  */
+  return sign * n;
+}
+\f
+/*-------------------------------------------------------------------.
+| Dump the string from FINPUT to FOUTPUT.  MATCH is the delimiter of |
+| the string (either ' or ").                                        |
+`-------------------------------------------------------------------*/
  
  
-void
-read_declarations ()
+static inline void
+copy_string (FILE *fin, FILE *fout, int match)
  {
  {
-  register int c;
-  register int tok;
+  int c;
  
  
-  for (;;)
+  putc (match, fout);
+  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 == '%')
+      putc (c, fout);
+
+      if (c == '\\')
         {
         {
-         tok = parse_percent_token();
+         c = getc (fin);
+         if (c == EOF)
+           fatal (_("unterminated string at end of file"));
+         putc (c, fout);
+         if (c == '\n')
+           lineno++;
+       }
  
  
-         switch (tok)
-           {
-           case TWO_PERCENTS:
-             return;
+      c = getc (fin);
+    }
  
  
-           case PERCENT_LEFT_CURLY:
-             copy_definition();
-             break;
+  putc (c, fout);
+}
  
  
-           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;
  
  
-           case RIGHT:
-             parse_assoc_decl(RIGHT_ASSOC);
-             break;
+/*---------------------------------------------------------------.
+| Dump the comment from IN to OUT1 and OUT2.  C is either `*' or |
+| `/', depending upon the type of comments used.  OUT2 might be  |
+| NULL.                                                          |
+`---------------------------------------------------------------*/
  
  
-           case NONASSOC:
-             parse_assoc_decl(NON_ASSOC);
-             break;
+static inline void
+copy_comment2 (FILE *in, FILE *out1, FILE *out2, int c)
+{
+  int cplus_comment;
+  int ended;
  
  
-           case SEMANTIC_PARSER:
-             if (semantic_parser == 0)
-               {
-                 semantic_parser = 1;
-                 open_extra_files();
-               }
-             break;
+  cplus_comment = (c == '/');
+  putc (c, out1);
+  if (out2)
+    putc (c, out2);
+  c = getc (in);
  
  
-           case PURE_PARSER:
-             pure_parser = 1;
-             break;
+  ended = 0;
+  while (!ended)
+    {
+      if (!cplus_comment && c == '*')
+       {
+         while (c == '*')
+           {
+             putc (c, out1);
+             if (out2)
+               putc (c, out2);
+             c = getc (in);
+           }
  
  
-           default:
-             fatal("junk after `%%' in definition section");
+         if (c == '/')
+           {
+             putc (c, out1);
+             if (out2)
+               putc (c, out2);
+             ended = 1;
             }
         }
             }
         }
+      else if (c == '\n')
+       {
+         lineno++;
+         putc (c, out1);
+         if (out2)
+           putc (c, out2);
+         if (cplus_comment)
+           ended = 1;
+         else
+           c = getc (in);
+       }
        else if (c == EOF)
        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
        else
-       fatals ("unknown character with code 0x%x in declaration section", c);
+       {
+         putc (c, out1);
+         if (out2)
+           putc (c, out2);
+         c = getc (in);
+       }
      }
  }
  
  
      }
  }
  
  
-/* copy the contents of a %{ ... %} into the definitions file.
-The %{ has already been read.  Return after reading the %}.  */
+/*------------------------------------------------------------.
+| Dump the comment from FIN to FOUT.  C is either `*' or `/', |
+| depending upon the type of comments used.                   |
+`------------------------------------------------------------*/
  
  
-void
-copy_definition ()
+static inline void
+copy_comment (FILE *fin, FILE *fout, int c)
  {
  {
-  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, fout, NULL, c);
+}
+
+
+/*-----------------------------------------------------------------.
+| FIN is pointing to a location (i.e., a `@').  Output to FOUT a   |
+| reference to this location. STACK_OFFSET is the number of values |
+| in the current rule so far, which says where to find `$0' with   |
+| respect to the top of the stack.                                 |
+`-----------------------------------------------------------------*/
+
+static inline void
+copy_at (FILE *fin, FILE *fout, int stack_offset)
+{
+  int c;
+
+  c = getc (fin);
+  if (c == '$')
+    {
+      fprintf (fout, "yyloc");
+      yylsp_needed = 1;
+    }
+  else if (isdigit (c) || c == '-')
+    {
+      int n;
+
+      ungetc (c, fin);
+      n = read_signed_integer (fin);
+
+      fprintf (fout, "yylsp[%d]", n - stack_offset);
+      yylsp_needed = 1;
+    }
+  else
+    complain (_("@%s is invalid"), printable_version (c));
+}
+\f
+/*-------------------------------------------------------------------.
+| 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 (!nolinesflag)
  
    if (!nolinesflag)
-    fprintf(fattrs, "#line %d \"%s\"\n", lineno, infile);
+    fprintf (fattrs, "#line %d \"%s\"\n", lineno, infile);
  
    after_percent = 0;
  
  
    after_percent = 0;
  
-  c = getc(finput);
+  c = getc (finput);
  
    for (;;)
      {
        switch (c)
         {
         case '\n':
  
    for (;;)
      {
        switch (c)
         {
         case '\n':
-         putc(c, fattrs);
+         putc (c, fattrs);
           lineno++;
           break;
  
         case '%':
           lineno++;
           break;
  
         case '%':
-          after_percent = -1;
+         after_percent = -1;
           break;
           break;
-             
+
         case '\'':
         case '"':
         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, fattrs, c);
           break;
  
         case '/':
           break;
  
         case '/':
-         putc(c, fattrs);
-         c = getc(finput);
+         putc (c, fattrs);
+         c = getc (finput);
           if (c != '*' && c != '/')
             continue;
           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, fattrs, c);
           break;
  
         case EOF:
           break;
  
         case EOF:
-         fatal("unterminated `%{' definition");
+         fatal ("%s", _("unterminated `%{' definition"));
  
         default:
  
         default:
-         putc(c, fattrs);
+         putc (c, fattrs);
         }
  
         }
  
-      c = getc(finput);
+      c = getc (finput);
  
        if (after_percent)
         {
           if (c == '}')
             return;
  
        if (after_percent)
         {
           if (c == '}')
             return;
-         putc('%', fattrs);
+         putc ('%', fattrs);
         }
        after_percent = 0;
  
         }
        after_percent = 0;
  
@@ -417,121 +358,178 @@ copy_definition ()
  }
  
  
  }
  
  
+/*-----------------------------------------------------------------.
+| 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.                                                        |
+`-----------------------------------------------------------------*/
  
  
-/* 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 (int what_is, int what_is_not)
  {
  {
-/*   register int start_lineno; JF */
-  register int token = 0;
-  register int prev;
-  register char *typename = 0;
+  int token = 0;
+  char *typename = 0;
+  struct bucket *symbol = NULL;        /* pts to symbol being defined */
    int k;
  
    int k;
  
-/*   start_lineno = lineno; JF */
-
    for (;;)
      {
    for (;;)
      {
-      if(ungetc(skip_white_space(), finput) == '%')
-       return;
+      int tmp_char = ungetc (skip_white_space (), finput);
  
  
-/*      if (lineno != start_lineno)
-       return; JF */
-
-      /* we have not passed a newline, so the token now starting is in this declaration */
-      prev = token;
+      if (tmp_char == '%')
+       return;
+      if (tmp_char == EOF)
+       fatal (_("Premature EOF after %s"), token_buffer);
  
  
-      token = lex();
+      token = lex ();
        if (token == COMMA)
        if (token == COMMA)
-       continue;
+       {
+         symbol = NULL;
+         continue;
+       }
        if (token == TYPENAME)
         {
        if (token == TYPENAME)
         {
-         k = strlen(token_buffer);
-         typename = NEW2(k + 1, char);
-         strcpy(typename, token_buffer);
+         k = strlen (token_buffer);
+         typename = XCALLOC (char, k + 1);
+         strcpy (typename, token_buffer);
           value_components_used = 1;
           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;
         }
        else if (token == IDENTIFIER)
         {
           int oldclass = symval->class;
+         symbol = symval;
  
  
-         if (symval->class == what_is_not)
-           fatals("symbol %s redefined", symval->tag);
-         symval->class = what_is;
+         if (symbol->class == what_is_not)
+           complain (_("symbol %s redefined"), symbol->tag);
+         symbol->class = what_is;
           if (what_is == SNTERM && oldclass != SNTERM)
           if (what_is == SNTERM && oldclass != SNTERM)
-           symval->value = nvars++;
+           symbol->value = nvars++;
  
           if (typename)
             {
  
           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 == NUMBER)
+       {
+         symbol->user_token_number = numval;
           translations = 1;
           translations = 1;
-        }
+       }
        else
        else
-       fatal("invalid text in %token or %nterm declaration");
+       {
+         complain (_("`%s' is invalid in %s"),
+                   token_buffer, (what_is == STOKEN) ? "%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)
  {
    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 () != 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 */
+/*--------------------------------------------------------------.
+| Get the data type (alternative in the union) of the value for |
+| symbol n in rule rule.                                        |
+`--------------------------------------------------------------*/
  
  
-void
-parse_type_decl ()
+static char *
+get_type_name (int n, symbol_list * rule)
  {
  {
-  register int k;
-  register char *name;
-/*   register int start_lineno; JF */
+  int i;
+  symbol_list *rp;
  
  
-  if (lex() != TYPENAME)
-    fatal("ill-formed %type declaration");
+  if (n < 0)
+    {
+      complain (_("invalid $ value"));
+      return NULL;
+    }
  
  
-  k = strlen(token_buffer);
-  name = NEW2(k + 1, char);
-  strcpy(name, token_buffer);
+  rp = rule;
+  i = 0;
  
  
-/*   start_lineno = lineno; */
+  while (i < n)
+    {
+      rp = rp->next;
+      if (rp == NULL || rp->sym == NULL)
+       {
+         complain (_("invalid $ value"));
+         return NULL;
+       }
+      i++;
+    }
  
  
-  for (;;)
+  return rp->sym->type_name;
+}
+
+
+/*-----------------------------------------------------------.
+| read in a %type declaration and record its information for |
+| get_type_name to access                                    |
+`-----------------------------------------------------------*/
+
+static void
+parse_type_decl (void)
+{
+  int k;
+  char *name;
+
+  if (lex () != TYPENAME)
      {
      {
-      register int t;
+      complain ("%s", _("%type declaration has no <typename>"));
+      skip_to_char ('%');
+      return;
+    }
  
  
-      if(ungetc(skip_white_space(), finput) == '%')
-       return;
+  k = strlen (token_buffer);
+  name = XCALLOC (char, k + 1);
+  strcpy (name, token_buffer);
  
  
-/*       if (lineno != start_lineno)
-       return; JF */
+  for (;;)
+    {
+      int t;
+      int tmp_char = ungetc (skip_white_space (), finput);
  
  
-      /* we have not passed a newline, so the token now starting is in this declaration */
+      if (tmp_char == '%')
+       return;
+      if (tmp_char == EOF)
+       fatal (_("Premature EOF after %s"), token_buffer);
  
  
-      t = lex();
+      t = lex ();
  
        switch (t)
         {
  
        switch (t)
         {
@@ -543,13 +541,15 @@ parse_type_decl ()
         case IDENTIFIER:
           if (symval->type_name == NULL)
             symval->type_name = name;
         case 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:
  
           break;
  
         default:
-         fatal("invalid %type declaration");
+         complain (_("invalid %%type declaration due to item: %s"),
+                   token_buffer);
+         skip_to_char ('%');
         }
      }
  }
         }
      }
  }
@@ -559,40 +559,34 @@ parse_type_decl ()
  /* 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.  */
  /* assoc is either LEFT_ASSOC, RIGHT_ASSOC or NON_ASSOC.  */
  
-void
-parse_assoc_decl (assoc)
-int assoc;
+static void
+parse_assoc_decl (int 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.  */
+  int k;
+  char *name = NULL;
+  int prev = 0;
  
  
-/*   start_lineno = lineno; */
+  lastprec++;                  /* Assign a new precedence level, never 0.  */
  
    for (;;)
      {
  
    for (;;)
      {
-      register int t;
+      int t;
+      int tmp_char = ungetc (skip_white_space (), finput);
  
  
-      if(ungetc(skip_white_space(), finput) == '%')
+      if (tmp_char == '%')
         return;
         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:
  
        switch (t)
         {
  
         case TYPENAME:
-         k = strlen(token_buffer);
-         name = NEW2(k + 1, char);
-         strcpy(name, token_buffer);
+         k = strlen (token_buffer);
+         name = XCALLOC (char, k + 1);
+         strcpy (name, token_buffer);
           break;
  
         case COMMA:
           break;
  
         case COMMA:
@@ -600,36 +594,42 @@ int assoc;
  
         case IDENTIFIER:
           if (symval->prec != 0)
  
         case 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)
           symval->prec = lastprec;
           symval->assoc = assoc;
           if (symval->class == SNTERM)
-           fatals("symbol %s redefined", symval->tag);
+           complain (_("symbol %s redefined"), symval->tag);
           symval->class = STOKEN;
           if (name)
           symval->class = STOKEN;
           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;
               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)
             }
           break;
  
         case NUMBER:
           if (prev == IDENTIFIER)
-            {
+           {
               symval->user_token_number = numval;
               translations = 1;
               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:
           return;
  
         default:
           break;
  
         case SEMICOLON:
           return;
  
         default:
-         fatal("malformatted association declaration");
+         complain (_("unexpected item: %s"), token_buffer);
+         skip_to_char ('%');
         }
  
        prev = t;
         }
  
        prev = t;
@@ -643,38 +643,33 @@ int assoc;
     where it is made into the
     definition of YYSTYPE, the type of elements of the parser value stack.  */
  
     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)
  
    if (typed)
-    fatal("multiple %union declarations");
+    complain (_("multiple %s declarations"), "%union");
  
    typed = 1;
  
    if (!nolinesflag)
  
    typed = 1;
  
    if (!nolinesflag)
-    fprintf(fattrs, "\n#line %d \"%s\"\n", lineno, infile);
+    fprintf (fattrs, "\n#line %d \"%s\"\n", lineno, infile);
    else
    else
-    fprintf(fattrs, "\n");
+    fprintf (fattrs, "\n");
  
  
-  fprintf(fattrs, "typedef union");
+  fprintf (fattrs, "typedef union");
    if (fdefines)
    if (fdefines)
-    fprintf(fdefines, "typedef union");
-
-  count = 0;
-  in_comment = 0;
+    fprintf (fdefines, "typedef union");
  
  
-  c = getc(finput);
+  c = getc (finput);
  
    while (c != EOF)
      {
  
    while (c != EOF)
      {
-      putc(c, fattrs);
+      putc (c, fattrs);
        if (fdefines)
        if (fdefines)
-       putc(c, fdefines);
+       putc (c, fdefines);
  
        switch (c)
         {
  
        switch (c)
         {
@@ -683,50 +678,10 @@ parse_union_decl()
           break;
  
         case '/':
           break;
  
         case '/':
-         c = getc(finput);
+         c = getc (finput);
           if (c != '*' && c != '/')
           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);
-               }
-           }
+           continue;
+         copy_comment2 (finput, fattrs, fdefines, c);
           break;
  
  
           break;
  
  
@@ -736,582 +691,668 @@ parse_union_decl()
  
         case '}':
           if (count == 0)
  
         case '}':
           if (count == 0)
-           fatal ("unmatched close-brace (`}')");
+           complain (_("unmatched %s"), "`}'");
           count--;
           count--;
-         if (count == 0)
+         if (count <= 0)
             {
             {
-             fprintf(fattrs, " YYSTYPE;\n");
+             fprintf (fattrs, " YYSTYPE;\n");
               if (fdefines)
               if (fdefines)
-               fprintf(fdefines, " YYSTYPE;\n");
+               fprintf (fdefines, " YYSTYPE;\n");
               /* JF don't choke on trailing semi */
               /* 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;
             }
         }
  
               return;
             }
         }
  
-      c = getc(finput);
+      c = getc (finput);
      }
  }
  
  /* parse the declaration %expect N which says to expect N
     shift-reduce conflicts.  */
  
      }
  }
  
  /* parse the declaration %expect N which says to expect N
     shift-reduce conflicts.  */
  
-void
-parse_expect_decl()
+static void
+parse_expect_decl (void)
  {
  {
-  register int c;
-  register int count;
+  int c;
+  int count;
    char buffer[20];
  
    char buffer[20];
  
-  c = getc(finput);
+  c = getc (finput);
    while (c == ' ' || c == '\t')
    while (c == ' ' || c == '\t')
-    c = getc(finput);
+    c = getc (finput);
  
    count = 0;
    while (c >= '0' && c <= '9')
      {
        if (count < 20)
         buffer[count++] = c;
  
    count = 0;
    while (c >= '0' && c <= '9')
      {
        if (count < 20)
         buffer[count++] = c;
-      c = getc(finput);
+      c = getc (finput);
      }
    buffer[count] = 0;
  
    ungetc (c, finput);
  
      }
    buffer[count] = 0;
  
    ungetc (c, finput);
  
+  if (count <= 0 || count > 10)
+    complain ("%s", _("argument of %expect is not an integer"));
    expected_conflicts = atoi (buffer);
  }
  
    expected_conflicts = atoi (buffer);
  }
  
-/* that's all of parsing the declaration section */
-\f
-/* Get the data type (alternative in the union) of the value for symbol n in rule rule.  */
  
  
-char *
-get_type_name(n, rule)
-int n;
-symbol_list *rule;
+/*-------------------------------------------------------------------.
+| 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)
  {
  {
-  static char *msg = "invalid $ value";
+  int token;
+  struct bucket *symbol;
+  char *typename = 0;
+  int k, usrtoknum;
  
  
-  register int i;
-  register symbol_list *rp;
-
-  if (n < 0)
-    fatal(msg);
+  translations = 1;
+  token = lex ();              /* fetch typename or first token */
+  if (token == TYPENAME)
+    {
+      k = strlen (token_buffer);
+      typename = XCALLOC (char, k + 1);
+      strcpy (typename, token_buffer);
+      value_components_used = 1;
+      token = lex ();          /* fetch first token */
+    }
  
  
-  rp = rule;
-  i = 0;
+  /* process first token */
  
  
-  while (i < n)
+  if (token != IDENTIFIER)
      {
      {
-      rp = rp->next;
-      if (rp == NULL || rp->sym == NULL)
-       fatal(msg);
-      i++;
+      complain (_("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;
  
  
-  return (rp->sym->type_name);
-}
+  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 */
  
  
-/* 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.  */
+  if (token != IDENTIFIER || *symval->tag != '\"')
+    {
+      complain (_("expected string constant instead of %s"), token_buffer);
+      skip_to_char ('%');
+      return;
+    }
+  symval->class = STOKEN;
+  symval->type_name = typename;
+  symval->user_token_number = usrtoknum;
  
  
-void
-copy_guard(rule, stack_offset)
-symbol_list *rule;
-int stack_offset;
-{
-  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;
+  symval->alias = symbol;
+  symbol->alias = symval;
  
  
-  /* offset is always 0 if parser has already popped the stack pointer */
-  if (semantic_parser) stack_offset = 0;
+  nsyms--;                     /* symbol and symval combined are only one symbol */
+}
  
  
-  fprintf(fguard, "\ncase %d:\n", nrules);
-  if (!nolinesflag)
-    fprintf(fguard, "#line %d \"%s\"\n", lineno, infile);
-  putc('{', fguard);
+/*----------------------------------------------------------------.
+| Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
+| any `%' declarations, and copy the contents of any `%{ ... %}'  |
+| groups to fattrs.                                               |
+`----------------------------------------------------------------*/
  
  
-  count = 0;
-  c = getc(finput);
+static void
+read_declarations (void)
+{
+  int c;
+  int tok;
  
  
-  while (brace_flag ? (count > 0) : (c != ';'))
+  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 TWO_PERCENTS:
+             return;
  
  
-       case '}':
-         putc(c, fguard);
-         if (count > 0)
-           count--;
-         else
-           fatal("unmatched right brace ('}')");
-          break;
+           case PERCENT_LEFT_CURLY:
+             copy_definition ();
+             break;
  
  
-       case '\'':
-       case '"':
-         match = c;
-         putc(c, fguard);
-         c = getc(finput);
+           case TOKEN:
+             parse_token_decl (STOKEN, SNTERM);
+             break;
  
  
-         while (c != match)
-           {
-             if (c == EOF || c == '\n')
-               fatal("unterminated string");
+           case NTERM:
+             parse_token_decl (SNTERM, STOKEN);
+             break;
  
  
-             putc(c, fguard);
-             
-             if (c == '\\')
-               {
-                 c = getc(finput);
-                 if (c == EOF)
-                   fatal("unterminated string");
-                 putc(c, fguard);
-                 if (c == '\n')
-                   lineno++;
-               }
+           case TYPE:
+             parse_type_decl ();
+             break;
  
  
-             c = getc(finput);
-           }
+           case START:
+             parse_start_decl ();
+             break;
  
  
-         putc(c, fguard);
-         break;
+           case UNION:
+             parse_union_decl ();
+             break;
  
  
-       case '/':
-         putc(c, fguard);
-         c = getc(finput);
-         if (c != '*' && c != '/')
-           continue;
+           case EXPECT:
+             parse_expect_decl ();
+             break;
+           case THONG:
+             parse_thong_decl ();
+             break;
+           case LEFT:
+             parse_assoc_decl (LEFT_ASSOC);
+             break;
  
  
-         cplus_comment = (c == '/');
-         putc(c, fguard);
-         c = getc(finput);
+           case RIGHT:
+             parse_assoc_decl (RIGHT_ASSOC);
+             break;
  
  
-         ended = 0;
-         while (!ended)
-           {
-             if (!cplus_comment && c == '*')
-               {
-                 while (c == '*')
-                   {
-                     putc(c, fguard);
-                     c = getc(finput);
-                   }
+           case NONASSOC:
+             parse_assoc_decl (NON_ASSOC);
+             break;
  
  
-                 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
+           case SEMANTIC_PARSER:
+             if (semantic_parser == 0)
                 {
                 {
-                 putc(c, fguard);
-                 c = getc(finput);
+                 semantic_parser = 1;
+                 open_extra_files ();
                 }
                 }
-           }
-
-         break;
-
-       case '$':
-         c = getc(finput);
-         type_name = NULL;
-
-         if (c == '<')
-           {
-             register char *cp = token_buffer;
-
-             while ((c = getc(finput)) != '>' && c > 0)
-               *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)   /* 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);
+             break;
  
  
-             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 PURE_PARSER:
+             pure_parser = 1;
+             break;
  
  
-         break;
+           case NOOP:
+             break;
  
  
-       case '@':
-         c = getc(finput);
-         if (isdigit(c) || c == '-')
-           {
-             ungetc (c, finput);
-             n = read_signed_integer(finput);
-             c = getc(finput);
+           default:
+             complain (_("unrecognized: %s"), token_buffer);
+             skip_to_char ('%');
             }
             }
-         else
-           fatals("@%c is invalid",c); /* JF changed style */
-
-         fprintf(fguard, "yylsp[%d]", n - stack_offset);
-         yylsp_needed = 1;
-
-         continue;
-
-       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);
-      if (c == '{')
-       copy_action(rule, stack_offset);
+      else if (c == EOF)
+       fatal (_("no input grammar"));
+      else
+       {
+         complain (_("unknown character: %s"), printable_version (c));
+         skip_to_char ('%');
+       }
      }
      }
-  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.  */
-
-void
-copy_action(rule, stack_offset)
-symbol_list *rule;
-int stack_offset;
+\f
+/*-------------------------------------------------------------------.
+| Assuming that a `{' has just been seen, copy everything up to the  |
+| matching `}' into the actions file.  STACK_OFFSET is the number of |
+| values in the current rule so far, which says where to find `$0'   |
+| with respect to the top of the stack.                              |
+`-------------------------------------------------------------------*/
+
+static void
+copy_action (symbol_list * rule, int stack_offset)
  {
  {
-  register int c;
-  register int n;
-  register int count;
-  register int match;
-  register int ended;
-  register char *type_name;
-  int cplus_comment;
+  int c;
+  int n;
+  int count;
+  char *type_name;
  
    /* offset is always 0 if parser has already popped the stack pointer */
  
    /* offset is always 0 if parser has already popped the stack pointer */
-  if (semantic_parser) stack_offset = 0;
+  if (semantic_parser)
+    stack_offset = 0;
  
  
-  fprintf(faction, "\ncase %d:\n", nrules);
+  fprintf (faction, "\ncase %d:\n", nrules);
    if (!nolinesflag)
    if (!nolinesflag)
-    fprintf(faction, "#line %d \"%s\"\n", lineno, infile);
-  putc('{', faction);
+    fprintf (faction, "#line %d \"%s\"\n", lineno, infile);
+  putc ('{', faction);
  
    count = 1;
  
    count = 1;
-  c = getc(finput);
+  c = getc (finput);
  
    while (count > 0)
      {
        while (c != '}')
  
    while (count > 0)
      {
        while (c != '}')
-        {
-          switch (c)
+       {
+         switch (c)
             {
             case '\n':
             {
             case '\n':
-             putc(c, faction);
+             putc (c, faction);
               lineno++;
               break;
  
             case '{':
               lineno++;
               break;
  
             case '{':
-             putc(c, faction);
+             putc (c, faction);
               count++;
               break;
  
             case '\'':
             case '"':
               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);
+             copy_string (finput, faction, c);
               break;
  
             case '/':
               break;
  
             case '/':
-             putc(c, faction);
-             c = getc(finput);
+             putc (c, faction);
+             c = getc (finput);
               if (c != '*' && c != '/')
                 continue;
               if (c != '*' && c != '/')
                 continue;
+             copy_comment (finput, faction, c);
+             break;
  
  
-             cplus_comment = (c == '/');
-             putc(c, faction);
-             c = getc(finput);
+           case '$':
+             c = getc (finput);
+             type_name = NULL;
  
  
-             ended = 0;
-             while (!ended)
+             if (c == '<')
                 {
                 {
-                 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
+                 char *cp = token_buffer;
+
+                 while ((c = getc (finput)) != '>' && c > 0)
                     {
                     {
-                     putc(c, faction);
-                     c = getc(finput);
+                     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)
+                   complain (_("$$ 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)
+                   complain (_("$%d of `%s' has no declared type"),
+                             n, rule->sym->tag);
+                 continue;
+               }
+             else
+               complain (_("$%s is invalid"), printable_version (c));
  
               break;
  
  
               break;
  
-           case '$':
-             c = getc(finput);
-             type_name = NULL;
+           case '@':
+             copy_at (finput, faction, stack_offset);
+             break;
+
+           case EOF:
+             fatal (_("unmatched %s"), "`{'");
+
+           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;}");
+}
+\f
+/*-------------------------------------------------------------------.
+| After `%guard' is seen in the input file, copy the actual guard    |
+| into the guards file.  If the guard is followed by an action, copy |
+| that into the actions file.  STACK_OFFSET is the number of values  |
+| in the current rule so far, which says where to find `$0' with     |
+| respect to the top of the stack, for the simple parser in which    |
+| the stack is not popped until after the guard is run.              |
+`-------------------------------------------------------------------*/
+
+static void
+copy_guard (symbol_list * rule, int stack_offset)
+{
+  int c;
+  int n;
+  int count;
+  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
+           {
+             complain (_("unmatched %s"), "`}'");
+             c = getc (finput);        /* skip it */
+           }
+         break;
+
+       case '\'':
+       case '"':
+         copy_string (finput, fguard, c);
+         break;
+
+       case '/':
+         putc (c, fguard);
+         c = getc (finput);
+         if (c != '*' && c != '/')
+           continue;
+         copy_comment (finput, fguard, c);
+         break;
  
  
-             if (c == '<')
-               {
-                 register char *cp = token_buffer;
+       case '$':
+         c = getc (finput);
+         type_name = NULL;
  
  
-                 while ((c = getc(finput)) != '>' && c > 0)
-                   *cp++ = c;
-                 *cp = 0;
-                 type_name = token_buffer;
-                 value_components_used = 1;
+         if (c == '<')
+           {
+             char *cp = token_buffer;
  
  
-                 c = getc(finput);
-               }
-             if (c == '$')
+             while ((c = getc (finput)) != '>' && c > 0)
                 {
                 {
-                 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 (cp == token_buffer + maxtoken)
+                   cp = grow_token_buffer (cp);
  
  
-                 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;
+                 *cp++ = c;
                 }
                 }
-             else
-               fatals("$%c is invalid",c);     /* JF changed format */
+             *cp = 0;
+             type_name = token_buffer;
  
  
-             break;
+             c = getc (finput);
+           }
  
  
-           case '@':
-             c = getc(finput);
-             if (isdigit(c) || c == '-')
-               {
-                 ungetc (c, finput);
-                 n = read_signed_integer(finput);
-                 c = getc(finput);
-               }
-             else
-               fatal("invalid @-construct");
+         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)
+               complain (_("$$ 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);
  
  
-             fprintf(faction, "yylsp[%d]", n - stack_offset);
-             yylsp_needed = 1;
+             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)
+               complain (_("$%d of `%s' has no declared type"),
+                         n, rule->sym->tag);
               continue;
               continue;
-
-           case EOF:
-             fatal("unmatched '{'");
-
-           default:
-             putc(c, faction);
             }
             }
+         else
+           complain (_("$%s is invalid"), printable_version (c));
+         break;
  
  
-          c = getc(finput);
-        }
+       case '@':
+         copy_at (finput, fguard, stack_offset);
+         break;
  
  
-      /* above loop exits when c is '}' */
+       case EOF:
+         fatal ("%s", _("unterminated %guard clause"));
  
  
-      if (--count)
-        {
-         putc(c, faction);
-         c = getc(finput);
+       default:
+         putc (c, fguard);
         }
         }
+
+      if (c != '}' || count != 0)
+       c = getc (finput);
      }
  
      }
  
-  fprintf(faction, ";\n    break;}");
+  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);
  }
  }
+\f
  
  
+static void
+record_rule_line (void)
+{
+  /* Record each rule's source line number in rline table.  */
+
+  if (nrules >= rline_allocated)
+    {
+      rline_allocated = nrules * 2;
+      rline = XREALLOC (rline, short, rline_allocated);
+    }
+  rline[nrules] = lineno;
+}
  
  
  
  
-/* generate a dummy symbol, a nonterminal,
-whose name cannot conflict with the user's names. */
+/*-------------------------------------------------------------------.
+| Generate a dummy symbol, a nonterminal, whose name cannot conflict |
+| with the user's names.                                             |
+`-------------------------------------------------------------------*/
  
  
-bucket *
-gensym()
+static bucket *
+gensym (void)
  {
  {
-  register bucket *sym;
+  bucket *sym;
  
    sprintf (token_buffer, "@%d", ++gensym_count);
  
    sprintf (token_buffer, "@%d", ++gensym_count);
-  sym = getsym(token_buffer);
+  sym = getsym (token_buffer);
    sym->class = SNTERM;
    sym->value = nvars++;
    sym->class = SNTERM;
    sym->value = nvars++;
-  return (sym);
+  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.
+#if 0
+/*------------------------------------------------------------------.
+| read in a %type declaration and record its information for        |
+| get_type_name to access.  This is unused.  It is only called from |
+| the #if 0 part of readgram                                        |
+`------------------------------------------------------------------*/
+
+static int
+get_type (void)
+{
+  int k;
+  int t;
+  char *name;
+
+  t = lex ();
+
+  if (t != TYPENAME)
+    {
+      complain (_("invalid %s declaration"), "%type");
+      return t;
+    }
  
  
-All guards and actions are copied out to the appropriate files,
-labelled by the rule number they apply to.  */
+  k = strlen (token_buffer);
+  name = XCALLOC (char, k + 1);
+  strcpy (name, token_buffer);
  
  
-void
-readgram()
+  for (;;)
+    {
+      t = lex ();
+
+      switch (t)
+       {
+       case SEMICOLON:
+         return lex ();
+
+       case COMMA:
+         break;
+
+       case IDENTIFIER:
+         if (symval->type_name == NULL)
+           symval->type_name = name;
+         else if (strcmp (name, symval->type_name) != 0)
+           complain (_("type redeclaration for %s"), symval->tag);
+
+         break;
+
+       default:
+         return t;
+       }
+    }
+}
+
+#endif
+\f
+/*------------------------------------------------------------------.
+| Parse the input grammar into a one symbol_list structure.  Each   |
+| rule is represented by a sequence of symbols: the left hand side  |
+| followed by the contents of the right hand side, followed by a    |
+| null pointer instead of a symbol to terminate the rule.  The next |
+| symbol is the lhs of the following rule.                          |
+|                                                                   |
+| All guards and actions are copied out to the appropriate files,   |
+| labelled by the rule number they apply to.                        |
+`------------------------------------------------------------------*/
+
+static void
+readgram (void)
  {
  {
-  register int t;
-  register bucket *lhs;
-  register symbol_list *p;
-  register symbol_list *p1;
-  register bucket *bp;
+  int 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.  */
+  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;
  
  
    p1 = NULL;
  
-  t = lex();
+  t = lex ();
  
    while (t != TWO_PERCENTS && t != ENDFILE)
      {
        if (t == IDENTIFIER || t == BAR)
         {
  
    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 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;
           int xactions = 0;     /* JF for error checking */
           bucket *first_rhs = 0;
  
           if (t == IDENTIFIER)
             {
               lhs = symval;
-    
-             t = lex();
+
+             if (!start_flag)
+               {
+                 startval = lhs;
+                 start_flag = 1;
+               }
+
+             t = lex ();
               if (t != COLON)
               if (t != COLON)
-               fatal("ill-formed rule");
+               {
+                 complain (_("ill-formed rule: initial symbol not followed by colon"));
+                 unlex (t);
+               }
             }
  
             }
  
-         if (nrules == 0)
+         if (nrules == 0 && t == BAR)
             {
             {
-             if (t == BAR)
-               fatal("grammar starts with vertical bar");
-
-             if (!start_flag)
-               startval = lhs;
+             complain (_("grammar starts with vertical bar"));
+             lhs = symval;     /* BOGUS: use a random symval */
             }
             }
-
           /* start a new rule and record its lhs.  */
  
           nrules++;
           /* start a new rule and record its lhs.  */
  
           nrules++;
@@ -1319,7 +1360,7 @@ readgram()
  
           record_rule_line ();
  
  
           record_rule_line ();
  
-         p = NEW(symbol_list);
+         p = XCALLOC (symbol_list, 1);
           p->sym = lhs;
  
           crule1 = p1;
           p->sym = lhs;
  
           crule1 = p1;
@@ -1340,48 +1381,56 @@ readgram()
               nvars++;
             }
           else if (lhs->class == STOKEN)
               nvars++;
             }
           else if (lhs->class == STOKEN)
-           fatals("rule given for %s, which is a token", lhs->tag);
+           complain (_("rule given for %s, which is a token"), lhs->tag);
  
           /* read the rhs of the rule.  */
  
           for (;;)
             {
  
           /* read the rhs of the rule.  */
  
           for (;;)
             {
-             t = lex();
+             t = lex ();
+             if (t == PREC)
+               {
+                 t = lex ();
+                 crule->ruleprec = symval;
+                 t = lex ();
+               }
  
  
-             if (! (t == IDENTIFIER || t == LEFT_CURLY)) break;
+             if (!(t == IDENTIFIER || t == LEFT_CURLY))
+               break;
  
               /* If next token is an identifier, see if a colon follows it.
  
               /* If next token is an identifier, see if a colon follows it.
-                If one does, exit this rule now.  */
+                If one does, exit this rule now.  */
               if (t == IDENTIFIER)
                 {
               if (t == IDENTIFIER)
                 {
-                 register bucket *ssave;
-                 register int t1;
+                 bucket *ssave;
+                 int t1;
  
                   ssave = symval;
  
                   ssave = symval;
-                 t1 = lex();
-                 unlex(t1);
+                 t1 = lex ();
+                 unlex (t1);
                   symval = ssave;
                   symval = ssave;
-                 if (t1 == COLON) break;
+                 if (t1 == 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
                     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.  */
+                of a rule, so make a dummy rule to reduce it to a
+                non-terminal.  */
               if (actionflag)
                 {
               if (actionflag)
                 {
-                 register bucket *sdummy;
+                 bucket *sdummy;
  
                   /* Since the action was written out with this rule's */
  
                   /* Since the action was written out with this rule's */
-                 /* number, we must write give the new rule this number */
+                 /* number, we must give the new rule this number */
                   /* by inserting the new rule before it.  */
  
                   /* Make a dummy nonterminal, a gensym.  */
                   /* 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
  
                   /* Make a new rule, whose body is empty,
                      before the current one, so that the action
@@ -1389,18 +1438,19 @@ readgram()
                   nrules++;
                   nitems++;
                   record_rule_line ();
                   nrules++;
                   nitems++;
                   record_rule_line ();
-                 p = NEW(symbol_list);
+                 p = XCALLOC (symbol_list, 1);
                   if (crule1)
                     crule1->next = p;
                   if (crule1)
                     crule1->next = p;
-                 else grammar = p;
+                 else
+                   grammar = p;
                   p->sym = sdummy;
                   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.  */
                   nitems++;
                   p->next = crule1;
                   crule1->next = crule;
  
                   /* 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;
                   p->sym = sdummy;
                   p1->next = p;
                   p1 = p;
@@ -1411,115 +1461,132 @@ readgram()
               if (t == IDENTIFIER)
                 {
                   nitems++;
               if (t == IDENTIFIER)
                 {
                   nitems++;
-                 p = NEW(symbol_list);
+                 p = XCALLOC (symbol_list, 1);
                   p->sym = symval;
                   p1->next = p;
                   p1 = p;
                 }
                   p->sym = symval;
                   p1->next = p;
                   p1 = p;
                 }
-             else /* handle an action.  */
+             else              /* handle an action.  */
                 {
                 {
-                 copy_action(crule, rulelength);
+                 copy_action (crule, rulelength);
                   actionflag = 1;
                   xactions++;   /* JF */
                 }
               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  */
  
           /* 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)
             {
           p1->next = p;
           p1 = p;
  
           if (t == PREC)
             {
-             t = lex();
+             complain (_("two @prec's in a row"));
+             t = lex ();
               crule->ruleprec = symval;
               crule->ruleprec = symval;
-             t = lex();
+             t = lex ();
             }
           if (t == GUARD)
             {
             }
           if (t == GUARD)
             {
-             if (! semantic_parser)
-               fatal("%guard present but %semantic_parser not specified");
+             if (!semantic_parser)
+               complain ("%s",
+                         _
+                         ("%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 == LEFT_CURLY)
             {
-             if (actionflag) fatal("two actions at end of one rule");
-             copy_action(crule, rulelength);
-             t = lex();
+             /* This case never occurs -wjh */
+             if (actionflag)
+               complain (_("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 $$ 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)
             }
           /* 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);
+           complain (_("empty rule for typed nonterminal, and no action"));
           if (t == SEMICOLON)
           if (t == SEMICOLON)
-           t = lex();
+           t = lex ();
         }
         }
+#if 0
        /* these things can appear as alternatives to rules.  */
        /* 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)
         {
        else if (t == TOKEN)
         {
-         parse_token_decl(STOKEN, SNTERM);
-         t = lex();
+         parse_token_decl (STOKEN, SNTERM);
+         t = lex ();
         }
        else if (t == NTERM)
         {
         }
        else if (t == NTERM)
         {
-         parse_token_decl(SNTERM, STOKEN);
-         t = lex();
+         parse_token_decl (SNTERM, STOKEN);
+         t = lex ();
         }
        else if (t == TYPE)
         {
         }
        else if (t == TYPE)
         {
-         t = get_type();
+         t = get_type ();
         }
        else if (t == UNION)
         {
         }
        else if (t == UNION)
         {
-         parse_union_decl();
-         t = lex();
+         parse_union_decl ();
+         t = lex ();
         }
        else if (t == EXPECT)
         {
         }
        else if (t == EXPECT)
         {
-         parse_expect_decl();
-         t = lex();
+         parse_expect_decl ();
+         t = lex ();
         }
        else if (t == START)
         {
         }
        else if (t == START)
         {
-         parse_start_decl();
-         t = lex();
+         parse_start_decl ();
+         t = lex ();
         }
         }
+#endif
+
        else
        else
-       fatal("invalid input");
+       {
+         complain (_("invalid input: %s"), token_buffer);
+         t = lex ();
+       }
      }
  
      }
  
+  /* grammar has been read.  Do some checking */
+
    if (nsyms > MAXSHORT)
    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)
            MAXSHORT);
    if (nrules == 0)
-    fatal("no input grammar");
+    fatal (_("no rules in the input grammar"));
  
  
-  if (typed == 0       /* JF put out same default YYSTYPE as YACC does */
+  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,
        && !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");
+         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)
        if (fdefines)
-       fprintf(fdefines, "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
+       fprintf (fdefines, "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
      }
  
    /* Report any undefined symbols and consider them nonterminals.  */
      }
  
    /* Report any undefined symbols and consider them nonterminals.  */
@@ -1527,96 +1594,90 @@ readgram()
    for (bp = firstsymbol; bp; bp = bp->next)
      if (bp->class == SUNKNOWN)
        {
    for (bp = firstsymbol; bp; bp = bp->next)
      if (bp->class == SUNKNOWN)
        {
-       fprintf(stderr, "symbol %s used, not defined as token, and no rules for it\n",
-                       bp->tag);
-       failure = 1;
+       complain (_
+                 ("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;
  }
         bp->class = SNTERM;
         bp->value = nvars++;
        }
  
    ntokens = nsyms - nvars;
  }
+\f
+/*--------------------------------------------------------------.
+| For named tokens, but not literal ones, define the name.  The |
+| value is the user token number.                               |
+`--------------------------------------------------------------*/
  
  
-
-void
-record_rule_line ()
-{
-  /* 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;
-}
-
-
-/* read in a %type declaration and record its information for get_type_name to access */
-
-int
-get_type()
+static void
+output_token_defines (FILE *file)
  {
  {
-  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
           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);
-       }
+      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);
+}
  
  
  
  
-/* 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;
+  bucket *bp;
+  int tokno = 1;
+  int i;
+  int last_user_token_number;
+  static char DOLLAR[] = "$";
  
    /* int lossage = 0; JF set but not used */
  
  
    /* int lossage = 0; JF set but not used */
  
-  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;
  
    max_user_token_number = 256;
    last_user_token_number = 256;
@@ -1627,16 +1688,57 @@ packsymbols()
         {
           bp->value += ntokens;
         }
         {
           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 == 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;
         {
           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;
         }
  
        tags[bp->value] = bp->tag;
+      user_toknums[bp->value] = bp->user_token_number;
        sprec[bp->value] = bp->prec;
        sassoc[bp->value] = bp->assoc;
  
        sprec[bp->value] = bp->prec;
        sassoc[bp->value] = bp->assoc;
  
@@ -1644,55 +1746,53 @@ packsymbols()
  
    if (translations)
      {
  
    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 $undefined.,
-        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)
           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;
  
           token_translations[bp->user_token_number] = bp->value;
         }
      }
  
    error_token_number = errtoken->value;
  
-  output_token_defines(ftable);
+  if (!noparserflag)
+    output_token_defines (ftable);
  
    if (startval->class == SUNKNOWN)
  
    if (startval->class == SUNKNOWN)
-    fatals("the start symbol %s is undefined", startval->tag);
+    fatal (_("the start symbol %s is undefined"), startval->tag);
    else if (startval->class == STOKEN)
    else if (startval->class == STOKEN)
-    fatals("the start symbol %s is a token", startval->tag);
+    fatal (_("the start symbol %s is a token"), startval->tag);
  
    start_symbol = startval->value;
  
    if (definesflag)
      {
  
    start_symbol = startval->value;
  
    if (definesflag)
      {
-      output_token_defines(fdefines);
+      output_token_defines (fdefines);
  
        if (!pure_parser)
         {
           if (spec_name_prefix)
  
        if (!pure_parser)
         {
           if (spec_name_prefix)
-           fprintf(fdefines, "\nextern YYSTYPE %slval;\n", spec_name_prefix);
+           fprintf (fdefines, "\nextern YYSTYPE %slval;\n",
+                    spec_name_prefix);
           else
           else
-           fprintf(fdefines, "\nextern YYSTYPE yylval;\n");
+           fprintf (fdefines, "\nextern YYSTYPE yylval;\n");
         }
  
        if (semantic_parser)
         }
  
        if (semantic_parser)
@@ -1700,73 +1800,38 @@ packsymbols()
           {
             /* don't make these for dummy nonterminals made by gensym.  */
             if (*tags[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);
+             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.  */
           }
  #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
      }
  }
        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;
  
  
    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;
  
    itemno = 0;
    ruleno = 1;
@@ -1784,55 +1849,127 @@ packgram()
           ritem[itemno++] = p->sym->value;
           /* A rule gets by default the precedence and associativity
              of the last token in it.  */
           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 == STOKEN)
             {
               rprec[ruleno] = p->sym->prec;
               rassoc[ruleno] = p->sym->assoc;
             }
             {
               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,
         }
  
        /* If this rule has a %prec,
-        the specified symbol's precedence replaces the default.  */
+         the specified symbol's precedence replaces the default.  */
        if (ruleprec)
         {
        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++;
  
           rprecsym[ruleno] = ruleprec->value;
         }
  
        ritem[itemno++] = -ruleno;
        ruleno++;
  
-      if (p) p = p->next;
+      if (p)
+       p = p->next;
      }
  
    ritem[itemno] = 0;
  }
  \f
      }
  
    ritem[itemno] = 0;
  }
  \f
-/* 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 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.                        |
+`-------------------------------------------------------------------*/
  
  
-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;
+
+  gensym_count = 0;
+
+  semantic_parser = 0;
+  pure_parser = 0;
+  yylsp_needed = 0;
+
+  grammar = NULL;
+
+  init_lex ();
+  lineno = 1;
  
  
-  ungetc(c, stream);
+  /* 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.  */
+  putc ('\n', ftable);
+  fprintf (ftable, "\
+/* %s, made from %s\n\
+   by GNU bison %s.  */\n\
+\n", noparserflag ? "Bison-generated parse tables" : "A Bison parser", infile, VERSION);
+
+  fputs ("#define YYBISON 1  /* Identify Bison output.  */\n\n", ftable);
+  read_declarations ();
+  /* Start writing the guard and action files, if they are needed.  */
+  output_headers ();
+  /* Read in the grammar, build grammar in list form.  Write out
+     guards and actions.  */
+  readgram ();
+  /* Now we know whether we need the line-number stack.  If we do,
+     write its type into the .tab.h file.  */
+  if (fdefines)
+    reader_output_yylsp (fdefines);
+  /* Write closing delimiters for actions and guards.  */
+  output_trailers ();
+  if (yylsp_needed)
+    fputs ("#define YYLSP_NEEDED\n\n", ftable);
+  /* 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 ();
+}
  
  
-  return n * sign;
+void
+reader_output_yylsp (FILE *f)
+{
+  if (yylsp_needed)
+    fprintf (f, LTYPESTR);
  }
  }