Remove `%thong' support as it is undocumented, unused, duplicates

[bison.git] / src / reader.c

diff --git a/src/reader.c b/src/reader.c
index 3f7cb0e347098e384b80b423a835196511c50eae..8447f904ce8e1135e45bd95c8a54737c49e84936 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -1,1773 +1,1397 @@
 /* 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, 2001, 2002
+   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 "quotearg.h"
+#include "quote.h"
+#include "getargs.h"

 #include "files.h"
 #include "files.h"

-#include "new.h"

 #include "symtab.h"
 #include "symtab.h"

+#include "options.h"

 #include "lex.h"
 #include "gram.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"
-
-/* Number of slots allocated (but not necessarily used yet) in `rline'  */
-int rline_allocated;
-
-extern char *program_name;
-extern int definesflag;
-extern int nolinesflag;
-extern bucket *symval;
-extern int numval;
-extern int failure;
-extern int expected_conflicts;
-extern char *token_buffer;
-
-extern int atoi ();
-
-extern void init_lex();
-extern void tabinit();
-extern void output_headers();
-extern void output_trailers();
-extern void free_symtab();
-extern void open_extra_files();
-extern void fatal();
-extern void fatals();
-extern void unlex();
-extern void done();
-
-extern int skip_white_space();
-extern int parse_percent_token();
-extern int lex();
-
-void read_declarations();
-void copy_definition();
-void parse_token_decl();
-void parse_start_decl();
-void parse_type_decl();
-void parse_assoc_decl();
-void parse_union_decl();
-void parse_expect_decl();
-void copy_action();
-void readgram();
-void record_rule_line();
-void packsymbols();
-void output_token_defines();
-void packgram();
-int read_signed_integer();
-int get_type();
-
-typedef
-  struct symbol_list
-    {
-      struct symbol_list *next;
-      bucket *sym;
-      bucket *ruleprec;
-    }
-  symbol_list;
+#include "complain.h"
+#include "output.h"
+#include "reader.h"
+#include "conflicts.h"
+#include "muscle_tab.h"

 
 

+typedef struct symbol_list
+{
+  struct symbol_list *next;
+  symbol_t *sym;
+  int line;
+
+  /* The action is attached to the LHS of a rule. */
+  const char *action;
+  int action_line;

 
 

+  symbol_t *ruleprec;
+} symbol_list;

 
 int lineno;
 
 int lineno;

-symbol_list *grammar;
-int start_flag;
-bucket *startval;
-char **tags;
+static symbol_list *grammar = NULL;
+static int start_flag = 0;

 
 

-/* Nonzero if components of semantic values are used, implying
-   they must be unions.  */
-static int value_components_used;
+/* Nonzero if %union has been seen.  */
+static int typed = 0;

 
 

-static int typed;  /* nonzero if %union has been seen.  */
+/* Incremented for each %left, %right or %nonassoc seen */
+static int lastprec = 0;
+
+static symbol_list *
+symbol_list_new (symbol_t *sym)
+{
+  symbol_list *res = XMALLOC (symbol_list, 1);
+  res->next = NULL;
+  res->sym = sym;
+  res->line = lineno;
+  res->action = NULL;
+  res->action_line = 0;
+  res->ruleprec = NULL;
+  return res;
+}

 
 

-static int lastprec;  /* incremented for each %left, %right or %nonassoc seen */
+/*===================\
+| Low level lexing.  |
+\===================*/

 
 

-static int gensym_count;  /* incremented for each generated symbol */
+static void
+skip_to_char (int target)
+{
+  int c;
+  if (target == '\n')
+    complain (_("   Skipping to next \\n"));
+  else
+    complain (_("   Skipping to next %c"), target);

 
 

-static bucket *errtoken;
+  do
+    c = skip_white_space ();
+  while (c != target && c != EOF);
+  if (c != EOF)
+    ungetc (c, finput);
+}

 
 

-/* Nonzero if any action or guard uses the @n construct.  */
-static int yylsp_needed;

 
 

-extern char *version_string;
+/*---------------------------------------------------------.
+| Read a signed integer from STREAM and return its value.  |
+`---------------------------------------------------------*/

 
 

-void
-reader()
+static inline int
+read_signed_integer (FILE *stream)

 {
 {

-  start_flag = 0;
-  startval = NULL;  /* start symbol not specified yet. */
+  int c = getc (stream);
+  int sign = 1;
+  int n = 0;

 
 

-#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;
+  if (c == '-')
+    {
+      c = getc (stream);
+      sign = -1;
+    }

 
 

-  nsyms = 1;
-  nvars = 0;
-  nrules = 0;
-  nitems = 0;
-  rline_allocated = 10;
-  rline = NEW2(rline_allocated, short);
+  while (isdigit (c))
+    {
+      n = 10 * n + (c - '0');
+      c = getc (stream);
+    }

 
 

-  typed = 0;
-  lastprec = 0;
+  ungetc (c, stream);

 
 

-  gensym_count = 0;
+  return sign * n;
+}
+\f
+/*--------------------------------------------------------------.
+| Get the data type (alternative in the union) of the value for |
+| symbol N in rule RULE.                                        |
+`--------------------------------------------------------------*/

 
 

-  semantic_parser = 0;
-  pure_parser = 0;
-  yylsp_needed = 0;
+static char *
+get_type_name (int n, symbol_list *rule)
+{
+  int i;
+  symbol_list *rp;

 
 

-  grammar = NULL;
+  if (n < 0)
+    {
+      complain (_("invalid $ value"));
+      return NULL;
+    }

 
 

-  init_lex();
-  lineno = 1;
+  rp = rule;
+  i = 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("$illegal.")->class = STOKEN;
-  /* Read the declaration section.  Copy %{ ... %} groups to ftable and fdefines file.
-     Also notice any %token, %left, etc. found there.  */
-  fprintf(ftable, "\n/*  A Bison parser, made from %s", infile);
-  fprintf(ftable, " with Bison version %s  */\n\n", version_string);
-  fprintf(ftable, "#define YYBISON 1  /* Identify Bison output.  */\n\n");
-  read_declarations();
-  /* output the definition of YYLTYPE into the fattrs and fdefines files.  */
-  /* fattrs winds up in the .tab.c file, before bison.simple.  */
-  fprintf(fattrs, LTYPESTR);
-  /* start writing the guard and action files, if they are needed.  */
-  output_headers();
-  /* read in the grammar, build grammar in list form.  write out guards and actions.  */
-  readgram();
-  /* Now we know whether we need the line-number stack.
-     If we do, write its type into the .tab.h file.  */
-  if (yylsp_needed)
+  while (i < n)

     {
     {

-      if (fdefines)
-       fprintf(fdefines, LTYPESTR);
+      rp = rp->next;
+      if (rp == NULL || rp->sym == NULL)
+       {
+         complain (_("invalid $ value"));
+         return NULL;
+       }
+      ++i;

     }
     }

-  /* 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();
+
+  return rp->sym->type_name;

 }
 }

+\f
+/*------------------------------------------------------------------.
+| Copy the character C to OOUT, and insert quadigraphs when needed. |
+`------------------------------------------------------------------*/

 
 

+static inline void
+copy_character (struct obstack *oout, int c)
+{
+  switch (c)
+    {
+    case '[':
+      obstack_sgrow (oout, "@<:@");
+      break;

 
 

+    case ']':
+      obstack_sgrow (oout, "@:>@");
+      break;

 
 

-/* read from finput until %% is seen.  Discard the %%.
-Handle any % declarations,
-and copy the contents of any %{ ... %} groups to fattrs.  */
+    default:
+      obstack_1grow (oout, c);
+    }
+}

 
 

-void
-read_declarations ()
+/*------------------------------------------------------------.
+| Dump the string from FIN to OOUT if non null.  MATCH is the |
+| delimiter of the string (either ' or ").                    |
+`------------------------------------------------------------*/
+
+static inline void
+copy_string2 (FILE *fin, struct obstack *oout, int match, int store)

 {
 {

-  register int c;
-  register int tok;
+  int c;

 
 

-  for (;;)
+  if (store)
+    obstack_1grow (oout, match);
+
+  c = getc (fin);
+
+  while (c != match)

     {
     {

-      c = skip_white_space();
+      if (c == EOF)
+       fatal (_("unterminated string at end of file"));
+      if (c == '\n')
+       {
+         complain (_("unterminated string"));
+         ungetc (c, fin);
+         c = match;            /* invent terminator */
+         continue;
+       }

 
 

-      if (c == '%')
+      copy_character (oout, c);
+
+      if (c == '\\')

        {
        {

-         tok = parse_percent_token();
+         c = getc (fin);
+         if (c == EOF)
+           fatal (_("unterminated string at end of file"));
+         copy_character (oout, c);

 
 

-         switch (tok)
-           {
-           case TWO_PERCENTS:
-             return;
+         if (c == '\n')
+           ++lineno;
+       }

 
 

-           case PERCENT_LEFT_CURLY:
-             copy_definition();
-             break;
+      c = getc (fin);
+    }

 
 

-           case TOKEN:
-             parse_token_decl (STOKEN, SNTERM);
-             break;
-       
-           case NTERM:
-             parse_token_decl (SNTERM, STOKEN);
-             break;
-       
-           case TYPE:
-             parse_type_decl();
-             break;
-       
-           case START:
-             parse_start_decl();
-             break;
-       
-           case UNION:
-             parse_union_decl();
-             break;
-       
-           case EXPECT:
-             parse_expect_decl();
-             break;
-       
-           case LEFT:
-             parse_assoc_decl(LEFT_ASSOC);
-             break;
+  if (store)
+    obstack_1grow (oout, c);
+}

 
 

-           case RIGHT:
-             parse_assoc_decl(RIGHT_ASSOC);
-             break;
+/* FIXME. */

 
 

-           case NONASSOC:
-             parse_assoc_decl(NON_ASSOC);
-             break;
+static inline void
+copy_string (FILE *fin, struct obstack *oout, int match)
+{
+  copy_string2 (fin, oout, match, 1);
+}

 
 

-           case SEMANTIC_PARSER:
-             if (semantic_parser == 0)
-               {
-                 semantic_parser = 1;
-                 open_extra_files();
-               }
-             break;
+/* FIXME. */

 
 

-           case PURE_PARSER:
-             pure_parser = 1;
-             break;
+static inline void
+copy_identifier (FILE *fin, struct obstack *oout)
+{
+  int c;

 
 

-           default:
-             fatal("junk after `%%' in definition section");
+  while (isalnum (c = getc (fin)) || c == '_')
+    obstack_1grow (oout, c);
+
+  ungetc (c, fin);
+}
+
+
+/*------------------------------------------------------------------.
+| Dump the wannabee comment from IN to OOUT.  In fact we just saw a |
+| `/', which might or might not be a comment.  In any case, copy    |
+| what we saw.                                                      |
+`------------------------------------------------------------------*/
+
+static inline void
+copy_comment (FILE *fin, struct obstack *oout)
+{
+  int cplus_comment;
+  int ended;
+  int c;
+
+  /* We read a `/', output it. */
+  obstack_1grow (oout, '/');
+
+  switch ((c = getc (fin)))
+    {
+    case '/':
+      cplus_comment = 1;
+      break;
+    case '*':
+      cplus_comment = 0;
+      break;
+    default:
+      ungetc (c, fin);
+      return;
+    }
+
+  obstack_1grow (oout, c);
+  c = getc (fin);
+
+  ended = 0;
+  while (!ended)
+    {
+      if (!cplus_comment && c == '*')
+       {
+         while (c == '*')
+           {
+             obstack_1grow (oout, c);
+             c = getc (fin);
+           }
+
+         if (c == '/')
+           {
+             obstack_1grow (oout, c);
+             ended = 1;

            }
        }
            }
        }

+      else if (c == '\n')
+       {
+         ++lineno;
+         obstack_1grow (oout, c);
+         if (cplus_comment)
+           ended = 1;
+         else
+           c = getc (fin);
+       }

       else if (c == EOF)
       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);
+       {
+         copy_character (oout, c);
+         c = getc (fin);
+       }

     }
 }
 
 
     }
 }
 
 

-/* copy the contents of a %{ ... %} into the definitions file.
-The %{ has already been read.  Return after reading the %}.  */
+/*-------------------------------------------------------------------.
+| FIN is pointing to a location (i.e., a `@').  Output to OOUT a     |
+| reference to this location. RULE_LENGTH is the number of values in |
+| the current rule so far, which says where to find `$0' with        |
+| respect to the top of the stack.                                   |
+`-------------------------------------------------------------------*/

 
 

-void
-copy_definition ()
+static inline void
+copy_at (FILE *fin, struct obstack *oout, int rule_length)

 {
 {

-  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;
+  int c = getc (fin);
+  locations_flag = 1;
+
+  if (c == '$')
+    {
+      obstack_sgrow (oout, "]b4_lhs_location[");
+    }
+  else if (isdigit (c) || c == '-')
+    {
+      int n;
+
+      ungetc (c, fin);
+      n = read_signed_integer (fin);
+      if (n > rule_length)
+       complain (_("invalid value: %s%d"), "@", n);
+      else
+       obstack_fgrow2 (oout, "]b4_rhs_location([%d], [%d])[",
+                       rule_length, n);
+    }
+  else
+    {
+      char buf[] = "@c";
+      buf[1] = c;
+      complain (_("%s is invalid"), quote (buf));
+    }
+}
+
+
+/*------------------------------------------------------------------.
+| FIN is pointing to a wannabee semantic value (i.e., a `$').       |
+|                                                                   |
+| Possible inputs: $[<TYPENAME>]($|integer)                         |
+|                                                                   |
+| Output to OOUT a reference to this semantic value. RULE_LENGTH is |
+| the number of values in the current rule so far, which says where |
+| to find `$0' with respect to the top of the stack.                |
+`------------------------------------------------------------------*/
+
+static inline void
+copy_dollar (FILE *fin, struct obstack *oout,
+            symbol_list *rule, int rule_length)
+{
+  int c = getc (fin);
+  const char *type_name = NULL;
+
+  /* Get the type name if explicit. */
+  if (c == '<')
+    {
+      read_type_name (fin);
+      type_name = token_buffer;
+      c = getc (fin);
+    }
+
+  if (c == '$')
+    {
+      if (!type_name)
+       type_name = get_type_name (0, rule);
+      if (!type_name && typed)
+       complain (_("$$ of `%s' has no declared type"),
+                 rule->sym->tag);
+      if (!type_name)
+       type_name = "";
+      obstack_fgrow1 (oout,
+                     "]b4_lhs_value([%s])[", type_name);
+    }
+  else if (isdigit (c) || c == '-')
+    {
+      int n;
+      ungetc (c, fin);
+      n = read_signed_integer (fin);
+
+      if (n > rule_length)
+       complain (_("invalid value: %s%d"), "$", n);
+      else
+       {
+         if (!type_name && n > 0)
+           type_name = get_type_name (n, rule);
+         if (!type_name && typed)
+           complain (_("$%d of `%s' has no declared type"),
+                     n, rule->sym->tag);
+         if (!type_name)
+           type_name = "";
+         obstack_fgrow3 (oout, "]b4_rhs_value([%d], [%d], [%s])[",
+                         rule_length, n, type_name);
+       }
+    }
+  else
+    {
+      char buf[] = "$c";
+      buf[1] = c;
+      complain (_("%s is invalid"), quote (buf));
+    }
+}
+\f
+/*-------------------------------------------------------------------.
+| Copy the contents of a `%{ ... %}' into the definitions file.  The |
+| `%{' has already been read.  Return after reading the `%}'.        |
+`-------------------------------------------------------------------*/
+
+static void
+copy_definition (struct obstack *oout)
+{
+  int c;
+  /* -1 while reading a character if prev char was %. */
+  int after_percent;

 
 

-  if (!nolinesflag)
-    fprintf(fattrs, "#line %d \"%s\"\n", lineno, infile);
+  if (!no_lines_flag)
+    {
+      obstack_fgrow2 (oout, muscle_find ("linef"),
+                     lineno, quotearg_style (c_quoting_style,
+                                             muscle_find ("filename")));
+    }

 
   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);
-         lineno++;
+         obstack_1grow (oout, c);
+         ++lineno;

          break;
 
        case '%':
          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, oout, c);

          break;
 
        case '/':
          break;
 
        case '/':

-         putc(c, fattrs);
-         c = getc(finput);
-         if (c != '*' && c != '/')
-           continue;
-
-         cplus_comment = (c == '/');
-         putc(c, fattrs);
-         c = getc(finput);
-
-         ended = 0;
-         while (!ended)
-           {
-             if (!cplus_comment && c == '*')
-               {
-                 while (c == '*')
-                   {
-                     putc(c, fattrs);
-                     c = getc(finput);
-                   }
-
-                 if (c == '/')
-                   {
-                     putc(c, fattrs);
-                     ended = 1;
-                   }
-               }
-             else if (c == '\n')
-               {
-                 lineno++;
-                 putc(c, fattrs);
-                 if (cplus_comment)
-                   ended = 1;
-                 else
-                   c = getc(finput);
-               }
-             else if (c == EOF)
-               fatal("unterminated comment in `%{' definition");
-             else
-               {
-                 putc(c, fattrs);
-                 c = getc(finput);
-               }
-           }
-
+         copy_comment (finput, oout);

          break;
 
        case EOF:
          break;
 
        case EOF:

-         fatal("unterminated `%{' definition");
+         fatal ("%s", _("unterminated `%{' definition"));

 
        default:
 
        default:

-         putc(c, fattrs);
+         copy_character (oout, c);

        }
 
        }
 

-      c = getc(finput);
+      c = getc (finput);

 
       if (after_percent)
        {
          if (c == '}')
            return;
 
       if (after_percent)
        {
          if (c == '}')
            return;

-         putc('%', fattrs);
+         obstack_1grow (oout, '%');

        }
       after_percent = 0;
        }
       after_percent = 0;

-

     }
     }

-

 }
 
 
 }
 
 

+/*-------------------------------------------------------------------.
+| Parse what comes after %token or %nterm.  For %token, WHAT_IS is   |
+| token_sym and WHAT_IS_NOT is nterm_sym.  For %nterm, the arguments |
+| are reversed.                                                      |
+`-------------------------------------------------------------------*/

 
 

-/* parse what comes after %token or %nterm.
-For %token, what_is is STOKEN and what_is_not is SNTERM.
-For %nterm, the arguments are reversed.  */
-
-void
-parse_token_decl (what_is, what_is_not)
-     int what_is, what_is_not;
+static void
+parse_token_decl (symbol_class what_is, symbol_class what_is_not)

 {
 {

-/*   register int start_lineno; JF */
-  register int token = 0;
-  register int prev;
-  register char *typename = 0;
-  int k;
+  token_t token = tok_undef;
+  char *typename = NULL;

 
 

-/*   start_lineno = lineno; JF */
+  /* The symbol being defined.  */
+  symbol_t *symbol = NULL;

 
 

+  /* After `%token' and `%nterm', any number of symbols maybe be
+     defined.  */

   for (;;)
     {
   for (;;)
     {

-      if(ungetc(skip_white_space(), finput) == '%')
-       return;
-
-/*      if (lineno != start_lineno)
-       return; JF */
+      int tmp_char = ungetc (skip_white_space (), finput);

 
 

-      /* we have not passed a newline, so the token now starting is in this declaration */
-      prev = token;
+      /* `%' (for instance from `%token', or from `%%' etc.) is the
+        only valid means to end this declaration.  */
+      if (tmp_char == '%')
+       return;
+      if (tmp_char == EOF)
+       fatal (_("Premature EOF after %s"), token_buffer);

 
 

-      token = lex();
-      if (token == COMMA)
-       continue;
-      if (token == TYPENAME)
+      token = lex ();
+      if (token == tok_comma)
+       {
+         symbol = NULL;
+         continue;
+       }
+      if (token == tok_typename)
+       {
+         typename = xstrdup (token_buffer);
+         symbol = NULL;
+       }
+      else if (token == tok_identifier && *symval->tag == '\"' && symbol)

        {
        {

-         k = strlen(token_buffer);
-         typename = NEW2(k + 1, char);
-         strcpy(typename, token_buffer);
-         value_components_used = 1;
+         symbol_make_alias (symbol, symval, typename);
+         symbol = NULL;

        }
        }

-      else if (token == IDENTIFIER)
+      else if (token == tok_identifier)

        {
          int oldclass = symval->class;
        {
          int oldclass = symval->class;

+         symbol = symval;

 
 

-         if (symval->class == what_is_not)
-           fatals("symbol %s redefined", symval->tag);
-         symval->class = what_is;
-         if (what_is == SNTERM && oldclass != SNTERM)
-           symval->value = nvars++;
+         if (symbol->class == what_is_not)
+           complain (_("symbol %s redefined"), symbol->tag);
+         symbol->class = what_is;
+         if (what_is == nterm_sym && oldclass != nterm_sym)
+           symbol->number = nvars++;
+         if (what_is == token_sym && symbol->number == NUMBER_UNDEFINED)
+           symbol->number = ntokens++;

 
          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 (symbol && token == tok_number)
+       {
+         symbol->user_token_number = numval;
+         /* User defined EOF token? */
+         if (numval == 0)
+           {
+             eoftoken = symbol;
+             eoftoken->number = 0;
+             /* It is always mapped to 0, so it was already counted in
+                NTOKENS.  */
+             --ntokens;

            }
        }
            }
        }

-      else if (prev == IDENTIFIER && token == NUMBER)
-        {
-         symval->user_token_number = numval;
-         translations = 1;
-        }

       else
       else

-       fatal("invalid text in %token or %nterm declaration");
+       {
+         complain (_("`%s' is invalid in %s"),
+                   token_buffer,
+                   (what_is == token_sym) ? "%token" : "%nterm");
+         skip_to_char ('%');
+       }

     }
 
 }
 
 
     }
 
 }
 
 

+/*------------------------------.
+| Parse what comes after %start |
+`------------------------------*/

 
 

-/* parse what comes after %start */
-
-void
-parse_start_decl ()
+static void
+parse_start_decl (void)

 {
   if (start_flag)
 {
   if (start_flag)

-    fatal("multiple %start declarations");
-  start_flag = 1;
-  if (lex() != IDENTIFIER)
-    fatal("invalid %start declaration");
-  startval = symval;
+    complain (_("multiple %s declarations"), "%start");
+  if (lex () != tok_identifier)
+    complain (_("invalid %s declaration"), "%start");
+  else
+    {
+      start_flag = 1;
+      startsymbol = symval;
+    }

 }
 
 }
 

+/*-----------------------------------------------------------.
+| read in a %type declaration and record its information for |
+| get_type_name to access                                    |
+`-----------------------------------------------------------*/

 
 

-
-/* read in a %type declaration and record its information for get_type_name to access */
-
-void
-parse_type_decl ()
+static void
+parse_type_decl (void)

 {
 {

-  register int k;
-  register char *name;
-/*   register int start_lineno; JF */
-
-  if (lex() != TYPENAME)
-    fatal("ill-formed %type declaration");
+  char *name;

 
 

-  k = strlen(token_buffer);
-  name = NEW2(k + 1, char);
-  strcpy(name, token_buffer);
+  if (lex () != tok_typename)
+    {
+      complain ("%s", _("%type declaration has no <typename>"));
+      skip_to_char ('%');
+      return;
+    }

 
 

-/*   start_lineno = lineno; */
+  name = xstrdup (token_buffer);

 
   for (;;)
     {
 
   for (;;)
     {

-      register int t;
+      token_t t;
+      int tmp_char = ungetc (skip_white_space (), finput);

 
 

-      if(ungetc(skip_white_space(), finput) == '%')
+      if (tmp_char == '%')

        return;
        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)
        {
 
       switch (t)
        {

-
-       case COMMA:
-       case SEMICOLON:
+       case tok_comma:
+       case tok_semicolon:

          break;
 
          break;
 

-       case IDENTIFIER:
-         if (symval->type_name == NULL)
-           symval->type_name = name;
-         else
-           fatals("type redeclaration for %s", symval->tag);
-
+       case tok_identifier:
+         symbol_type_set (symval, name);

          break;
 
        default:
          break;
 
        default:

-         fatal("invalid %type declaration");
+         complain (_("invalid %%type declaration due to item: %s"),
+                   token_buffer);
+         skip_to_char ('%');

        }
     }
 }
 
 
 
        }
     }
 }
 
 
 

-/* read in a %left, %right or %nonassoc declaration and record its information.  */
-/* assoc is either LEFT_ASSOC, RIGHT_ASSOC or NON_ASSOC.  */
+/*----------------------------------------------------------------.
+| Read in a %left, %right or %nonassoc declaration and record its |
+| information.                                                    |
+`----------------------------------------------------------------*/

 
 

-void
-parse_assoc_decl (assoc)
-int assoc;
+static void
+parse_assoc_decl (associativity assoc)

 {
 {

-  register int k;
-  register char *name = NULL;
-/*  register int start_lineno; JF */
-  register int prev = 0;       /* JF added = 0 to keep lint happy */
+  char *name = NULL;
+  int prev = 0;

 
 

-  lastprec++;  /* Assign a new precedence level, never 0.  */
-
-/*   start_lineno = lineno; */
+  /* Assign a new precedence level, never 0.  */
+  ++lastprec;

 
   for (;;)
     {
 
   for (;;)
     {

-      register int t;
+      token_t t;
+      int tmp_char = ungetc (skip_white_space (), finput);

 
 

-      if(ungetc(skip_white_space(), finput) == '%')
+      if (tmp_char == '%')

        return;
        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)
        {
 
       switch (t)
        {

-
-       case TYPENAME:
-         k = strlen(token_buffer);
-         name = NEW2(k + 1, char);
-         strcpy(name, token_buffer);
+       case tok_typename:
+         name = xstrdup (token_buffer);

          break;
 
          break;
 

-       case COMMA:
+       case tok_comma:

          break;
 
          break;
 

-       case IDENTIFIER:
-         if (symval->prec != 0)
-           fatals("redefining precedence of %s", symval->tag);
-         symval->prec = lastprec;
-         symval->assoc = assoc;
-         if (symval->class == SNTERM)
-           fatals("symbol %s redefined", symval->tag);
-         symval->class = STOKEN;
-         if (name)
-           { /* record the type, if one is specified */
-             if (symval->type_name == NULL)
-               symval->type_name = name;
-             else
-               fatals("type redeclaration for %s", symval->tag);
+       case tok_identifier:
+         if (symval->class == nterm_sym)
+           complain (_("symbol %s redefined"), symval->tag);
+         if (symval->number == NUMBER_UNDEFINED)
+           {
+             symval->number = ntokens++;
+             symval->class = token_sym;

            }
            }

+         symbol_precedence_set (symval, lastprec, assoc);
+         if (name)
+           symbol_type_set (symval, name);

          break;
 
          break;
 

-       case NUMBER:
-         if (prev == IDENTIFIER)
-            {
+       case tok_number:
+         if (prev == tok_identifier)
+           {

              symval->user_token_number = numval;
              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;
 
          break;
 

-       case SEMICOLON:
+       case tok_semicolon:

          return;
 
        default:
          return;
 
        default:

-         fatal("malformatted association declaration");
+         complain (_("unexpected item: %s"), token_buffer);
+         skip_to_char ('%');

        }
 
       prev = t;
        }
 
       prev = t;

-

     }
 }
 
 
 
     }
 }
 
 
 

-/* copy the union declaration into fattrs (and fdefines),
-   where it is made into the
-   definition of YYSTYPE, the type of elements of the parser value stack.  */
+/*--------------------------------------------------------------.
+| Copy the union declaration into the stype muscle             |
+| (and fdefines),  where it is made into the definition of     |
+| YYSTYPE, the type of elements of the parser value stack.     |
+`--------------------------------------------------------------*/

 
 

-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;
+  bool done = FALSE;
+  struct obstack union_obstack;

   if (typed)
   if (typed)

-    fatal("multiple %union declarations");
+    complain (_("multiple %s declarations"), "%union");

 
   typed = 1;
 
 
   typed = 1;
 

-  if (!nolinesflag)
-    fprintf(fattrs, "\n#line %d \"%s\"\n", lineno, infile);
-  else
-    fprintf(fattrs, "\n");
-
-  fprintf(fattrs, "typedef union");
-  if (fdefines)
-    fprintf(fdefines, "typedef union");
-
-  count = 0;
-  in_comment = 0;
+  MUSCLE_INSERT_INT ("stype_line", lineno);
+  obstack_init (&union_obstack);
+  obstack_sgrow (&union_obstack, "union");

 
 

-  c = getc(finput);
-
-  while (c != EOF)
+  while (!done)

     {
     {

-      putc(c, fattrs);
-      if (fdefines)
-       putc(c, fdefines);
+      c = xgetc (finput);
+
+      /* If C contains '/', it is output by copy_comment ().  */
+      if (c != '/')
+       obstack_1grow (&union_obstack, c);

 
       switch (c)
        {
        case '\n':
 
       switch (c)
        {
        case '\n':

-         lineno++;
+         ++lineno;

          break;
 
        case '/':
          break;
 
        case '/':

-         c = getc(finput);
-         if (c != '*' && c != '/')
-           ungetc(c, finput);
-         else
-           {
-             putc(c, fattrs);
-             if (fdefines)
-               putc(c, fdefines);
-             cplus_comment = (c == '/');
-             in_comment = 1;
-             c = getc(finput);
-             while (in_comment)
-               {
-                 putc(c, fattrs);
-                 if (fdefines)
-                   putc(c, fdefines);
-
-                 if (c == '\n')
-                   {
-                     lineno++;
-                     if (cplus_comment)
-                       {
-                         in_comment = 0;
-                         break;
-                       }
-                   }
-                 if (c == EOF)
-                   fatal("unterminated comment");
-
-                 if (!cplus_comment && c == '*')
-                   {
-                     c = getc(finput);
-                     if (c == '/')
-                       {
-                         putc('/', fattrs);
-                         if (fdefines)
-                           putc('/', fdefines);
-                         in_comment = 0;
-                       }
-                   }
-                 else
-                   c = getc(finput);
-               }
-           }
+         copy_comment (finput, &union_obstack);

          break;
 
          break;
 

-

        case '{':
        case '{':

-         count++;
+         ++count;

          break;
 
        case '}':
          break;
 
        case '}':

+         /* FIXME: Errr.  How could this happen???. --akim */

          if (count == 0)
          if (count == 0)

-           fatal ("unmatched close-brace (`}')");
+           complain (_("unmatched %s"), "`}'");

          count--;
          count--;

-         if (count == 0)
-           {
-             fprintf(fattrs, " YYSTYPE;\n");
-             if (fdefines)
-               fprintf(fdefines, " YYSTYPE;\n");
-             /* JF don't choke on trailing semi */
-             c=skip_white_space();
-             if(c!=';') ungetc(c,finput);
-             return;
-           }
+         if (!count)
+           done = TRUE;
+         break;

        }
        }

-
-      c = getc(finput);

     }
     }

+
+  /* JF don't choke on trailing semi */
+  c = skip_white_space ();
+  if (c != ';')
+    ungetc (c, finput);
+  obstack_1grow (&union_obstack, 0);
+  muscle_insert ("stype", obstack_finish (&union_obstack));

 }
 
 }
 

-/* parse the declaration %expect N which says to expect N
-   shift-reduce conflicts.  */

 
 

-void
-parse_expect_decl()
+/*-------------------------------------------------------.
+| Parse the declaration %expect N which says to expect N |
+| shift-reduce conflicts.                                |
+`-------------------------------------------------------*/
+
+static void
+parse_expect_decl (void)

 {
 {

-  register int c;
-  register int count;
-  char buffer[20];
+  int c = skip_white_space ();
+  ungetc (c, finput);

 
 

-  c = getc(finput);
-  while (c == ' ' || c == '\t')
-    c = getc(finput);
+  if (!isdigit (c))
+    complain (_("argument of %%expect is not an integer"));
+  else
+    expected_conflicts = read_signed_integer (finput);
+}
+
+
+static void
+parse_muscle_decl (void)
+{
+  int ch = ungetc (skip_white_space (), finput);
+  char *muscle_key;
+  char *muscle_value;

 
 

-  count = 0;
-  while (c >= '0' && c <= '9')
+  /* Read key. */
+  if (!isalpha (ch) && ch != '_')

     {
     {

-      if (count < 20)
-       buffer[count++] = c;
-      c = getc(finput);
+      complain (_("invalid %s declaration"), "%define");
+      skip_to_char ('%');
+      return;

     }
     }

-  buffer[count] = 0;
+  copy_identifier (finput, &muscle_obstack);
+  obstack_1grow (&muscle_obstack, 0);
+  muscle_key = obstack_finish (&muscle_obstack);

 
 

-  ungetc (c, finput);
+  /* Read value. */
+  ch = skip_white_space ();
+  if (ch != '"')
+    {
+      ungetc (ch, finput);
+      if (ch != EOF)
+       {
+         complain (_("invalid %s declaration"), "%define");
+         skip_to_char ('%');
+         return;
+       }
+      else
+       fatal (_("Premature EOF after %s"), "\"");
+    }
+  copy_string2 (finput, &muscle_obstack, '"', 0);
+  obstack_1grow (&muscle_obstack, 0);
+  muscle_value = obstack_finish (&muscle_obstack);

 
 

-  expected_conflicts = atoi (buffer);
+  /* Store the (key, value) pair in the environment. */
+  muscle_insert (muscle_key, muscle_value);

 }
 
 }
 

-/* 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 a double quoted parameter. |
+`---------------------------------*/
+
+static const char *
+parse_dquoted_param (const char *from)

 {
 {

-  static char *msg = "invalid $ value";
+  struct obstack param_obstack;
+  const char *param = NULL;
+  int c;

 
 

-  register int i;
-  register symbol_list *rp;
+  obstack_init (&param_obstack);
+  c = skip_white_space ();

 
 

-  if (n < 0)
-    fatal(msg);
+  if (c != '"')
+    {
+      complain (_("invalid %s declaration"), from);
+      ungetc (c, finput);
+      skip_to_char ('%');
+      return NULL;
+    }

 
 

-  rp = rule;
-  i = 0;
+  while ((c = literalchar ()) != '"')
+    obstack_1grow (&param_obstack, c);

 
 

-  while (i < n)
+  obstack_1grow (&param_obstack, '\0');
+  param = obstack_finish (&param_obstack);
+
+  if (c != '"' || strlen (param) == 0)

     {
     {

-      rp = rp->next;
-      if (rp == NULL || rp->sym == NULL)
-       fatal(msg);
-      i++;
+      complain (_("invalid %s declaration"), from);
+      if (c != '"')
+       ungetc (c, finput);
+      skip_to_char ('%');
+      return NULL;

     }
 
     }
 

-  return (rp->sym->type_name);
+  return param;

 }
 
 }
 

+/*----------------------------------.
+| Parse what comes after %skeleton. |
+`----------------------------------*/

 
 

+static void
+parse_skel_decl (void)
+{
+  skeleton = parse_dquoted_param ("%skeleton");
+}

 
 

-/* 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.  */
+/*----------------------------------------------------------------.
+| Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
+| any `%' declarations, and copy the contents of any `%{ ... %}'  |
+| groups to PRE_PROLOGUE_OBSTACK or POST_PROLOGUE_OBSTACK.        |
+`----------------------------------------------------------------*/

 
 

-void
-copy_guard(rule, stack_offset)
-symbol_list *rule;
-int stack_offset;
+static void
+read_declarations (void)

 {
 {

-  register int c;
-  register int n;
-  register int count;
-  register int match;
-  register int ended;
-  register char *type_name;
-  int brace_flag = 0;
-  int cplus_comment;
+  for (;;)
+    {
+      int c = skip_white_space ();

 
 

-  /* offset is always 0 if parser has already popped the stack pointer */
-  if (semantic_parser) stack_offset = 0;
+      if (c == '%')
+       {
+         token_t tok = parse_percent_token ();

 
 

-  fprintf(fguard, "\ncase %d:\n", nrules);
-  if (!nolinesflag)
-    fprintf(fguard, "#line %d \"%s\"\n", lineno, infile);
-  putc('{', fguard);
+         switch (tok)
+           {
+           case tok_two_percents:
+             return;

 
 

-  count = 0;
-  c = getc(finput);
+           case tok_percent_left_curly:
+              if (!typed)
+               copy_definition (&pre_prologue_obstack);
+             else
+               copy_definition (&post_prologue_obstack);
+             break;

 
 

-  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
-           fatal("unmatched right brace ('}')");
-          break;
-
-       case '\'':
-       case '"':
-         match = c;
-         putc(c, fguard);
-         c = getc(finput);
-
-         while (c != match)
-           {
-             if (c == EOF || c == '\n')
-               fatal("unterminated string");
-
-             putc(c, fguard);
-             
-             if (c == '\\')
-               {
-                 c = getc(finput);
-                 if (c == EOF)
-                   fatal("unterminated string");
-                 putc(c, fguard);
-                 if (c == '\n')
-                   lineno++;
-               }
-
-             c = getc(finput);
-           }
-
-         putc(c, fguard);
-         break;
-
-       case '/':
-         putc(c, fguard);
-         c = getc(finput);
-         if (c != '*' && c != '/')
-           continue;
-
-         cplus_comment = (c == '/');
-         putc(c, fguard);
-         c = getc(finput);
-
-         ended = 0;
-         while (!ended)
-           {
-             if (!cplus_comment && c == '*')
-               {
-                 while (c == '*')
-                   {
-                     putc(c, fguard);
-                     c = getc(finput);
-                   }
-
-                 if (c == '/')
-                   {
-                     putc(c, fguard);
-                     ended = 1;
-                   }
-               }
-             else if (c == '\n')
-               {
-                 lineno++;
-                 putc(c, fguard);
-                 if (cplus_comment)
-                   ended = 1;
-                 else
-                   c = getc(finput);
-               }
-             else if (c == EOF)
-               fatal("unterminated comment");
-             else
-               {
-                 putc(c, fguard);
-                 c = getc(finput);
-               }
-           }
-
-         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);
-
-             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 */
-
-         break;
-
-       case '@':
-         c = getc(finput);
-         if (isdigit(c) || c == '-')
-           {
-             ungetc (c, finput);
-             n = read_signed_integer(finput);
-             c = getc(finput);
-           }
-         else
-           fatals("@%c is invalid",c); /* JF changed style */
-
-         fprintf(fguard, "yylsp[%d]", n - stack_offset);
-         yylsp_needed = 1;
-
-         continue;
-
-       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
-    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;
-{
-  register int c;
-  register int n;
-  register int count;
-  register int match;
-  register int ended;
-  register char *type_name;
-  int cplus_comment;
-
-  /* offset is always 0 if parser has already popped the stack pointer */
-  if (semantic_parser) stack_offset = 0;
-
-  fprintf(faction, "\ncase %d:\n", nrules);
-  if (!nolinesflag)
-    fprintf(faction, "#line %d \"%s\"\n", lineno, infile);
-  putc('{', faction);
+           case tok_token:
+             parse_token_decl (token_sym, nterm_sym);
+             break;

 
 

-  count = 1;
-  c = getc(finput);
+           case tok_nterm:
+             parse_token_decl (nterm_sym, token_sym);
+             break;

 
 

-  while (count > 0)
-    {
-      while (c != '}')
-        {
-          switch (c)
-           {
-           case '\n':
-             putc(c, faction);
-             lineno++;
+           case tok_type:
+             parse_type_decl ();

              break;
 
              break;
 

-           case '{':
-             putc(c, faction);
-             count++;
+           case tok_start:
+             parse_start_decl ();

              break;
 
              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);
+           case tok_union:
+             parse_union_decl ();

              break;
 
              break;
 

-           case '/':
-             putc(c, faction);
-             c = getc(finput);
-             if (c != '*' && c != '/')
-               continue;
-
-             cplus_comment = (c == '/');
-             putc(c, faction);
-             c = getc(finput);
-
-             ended = 0;
-             while (!ended)
-               {
-                 if (!cplus_comment && c == '*')
-                   {
-                     while (c == '*')
-                       {
-                         putc(c, faction);
-                         c = getc(finput);
-                       }
-
-                     if (c == '/')
-                       {
-                         putc(c, faction);
-                         ended = 1;
-                       }
-                   }
-                 else if (c == '\n')
-                   {
-                     lineno++;
-                     putc(c, faction);
-                     if (cplus_comment)
-                       ended = 1;
-                     else
-                       c = getc(finput);
-                   }
-                 else if (c == EOF)
-                   fatal("unterminated comment");
-                 else
-                   {
-                     putc(c, faction);
-                     c = getc(finput);
-                   }
-               }
+           case tok_expect:
+             parse_expect_decl ();
+             break;

 
 

+           case tok_left:
+             parse_assoc_decl (left_assoc);

              break;
 
              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;
-                 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)       /* JF */
-                   fprintf(stderr,"%s:%d:  warning:  $$ of '%s' has no declared type.\n",infile,lineno,rule->sym->tag);
-               }
-             else if (isdigit(c) || c == '-')
-               {
-                 ungetc (c, finput);
-                 n = read_signed_integer(finput);
-                 c = getc(finput);
-
-                 if (!type_name && n > 0)
-                   type_name = get_type_name(n, rule);
-
-                 fprintf(faction, "yyvsp[%d]", n - stack_offset);
-                 if (type_name)
-                   fprintf(faction, ".%s", type_name);
-                 if(!type_name && typed)       /* JF */
-                   fprintf(stderr,"%s:%d:  warning:  $%d of '%s' has no declared type.\n",infile,lineno,n,rule->sym->tag);
-                 continue;
-               }
-             else
-               fatals("$%c is invalid",c);     /* JF changed format */
+           case tok_right:
+             parse_assoc_decl (right_assoc);
+             break;

 
 

+           case tok_nonassoc:
+             parse_assoc_decl (non_assoc);

              break;
 
              break;
 

-           case '@':
-             c = getc(finput);
-             if (isdigit(c) || c == '-')
-               {
-                 ungetc (c, finput);
-                 n = read_signed_integer(finput);
-                 c = getc(finput);
-               }
-             else
-               fatal("invalid @-construct");
+           case tok_define:
+             parse_muscle_decl ();
+             break;

 
 

-             fprintf(faction, "yylsp[%d]", n - stack_offset);
-             yylsp_needed = 1;
+           case tok_skel:
+             parse_skel_decl ();
+             break;

 
 

-             continue;
+           case tok_noop:
+             break;

 
 

-           case EOF:
-             fatal("unmatched '{'");
+           case tok_stropt:
+           case tok_intopt:
+           case tok_obsolete:
+             assert (0);
+             break;

 
 

+           case tok_illegal:

            default:
            default:

-             putc(c, faction);
+             complain (_("unrecognized: %s"), token_buffer);
+             skip_to_char ('%');

            }
            }

+       }
+      else if (c == EOF)
+       fatal (_("no input grammar"));
+      else
+       {
+         char buf[] = "c";
+         buf[0] = c;
+         complain (_("unknown character: %s"), quote (buf));
+         skip_to_char ('%');
+       }
+    }
+}
+\f
+/*------------------------------------------------------------------.
+| Assuming that a `{' has just been seen, copy everything up to the |
+| matching `}' into ACTION_OBSTACK.                                 |
+|                                                                   |
+| RULE_LENGTH is the number of values in the current rule so far,   |
+| which says where to find `$0' with respect to the top of the      |
+| stack.  It is not the same as the rule->length in the case of mid |
+| rule actions.                                                     |
+|                                                                   |
+| This routine is used for actions.                                 |
+`------------------------------------------------------------------*/
+
+static void
+parse_action (symbol_list *rule, int rule_length)
+{
+  int count = 1;
+  rule->action_line = lineno;
+  while (count > 0)
+    {
+      int c;
+      while ((c = getc (finput)) != '}')
+       switch (c)
+         {
+         case '\n':
+           copy_character (&action_obstack, c);
+           ++lineno;
+           break;
+
+         case '{':
+           copy_character (&action_obstack, c);
+           ++count;
+           break;
+
+         case '\'':
+         case '"':
+           copy_string (finput, &action_obstack, c);
+           break;
+
+         case '/':
+           copy_comment (finput, &action_obstack);
+           break;
+
+         case '$':
+           copy_dollar (finput, &action_obstack, rule, rule_length);
+           break;
+
+         case '@':
+           copy_at (finput, &action_obstack, rule_length);
+           break;
+
+         case EOF:
+           fatal (_("unmatched %s"), "`{'");
+
+         default:
+           copy_character (&action_obstack, c);
+         }

 
 

-          c = getc(finput);
-        }
-
-      /* above loop exits when c is '}' */
-
+      /* Above loop exits when C is '}'.  */

       if (--count)
       if (--count)

-        {
-         putc(c, faction);
-         c = getc(finput);
-       }
+       copy_character (&action_obstack, c);

     }
 
     }
 

-  fprintf(faction, ";\n    break;}");
+  obstack_1grow (&action_obstack, '\0');
+  rule->action = obstack_finish (&action_obstack);

 }
 
 }
 

+\f

 
 

+/*-------------------------------------------------------------------.
+| Generate a dummy symbol, a nonterminal, whose name cannot conflict |
+| with the user's names.                                             |
+`-------------------------------------------------------------------*/

 
 

-/* generate a dummy symbol, a nonterminal,
-whose name cannot conflict with the user's names. */
-
-bucket *
-gensym()
+static symbol_t *
+gensym (void)

 {
 {

-  register bucket *sym;
-
-  sprintf (token_buffer, "@%d", ++gensym_count);
-  sym = getsym(token_buffer);
-  sym->class = SNTERM;
-  sym->value = nvars++;
-  return (sym);
+  /* Incremented for each generated symbol */
+  static int gensym_count = 0;
+  static char buf[256];
+
+  symbol_t *sym;
+
+  sprintf (buf, "@%d", ++gensym_count);
+  token_buffer = buf;
+  sym = getsym (token_buffer);
+  sym->class = nterm_sym;
+  sym->number = nvars++;
+  return sym;

 }
 }

-
-/* Parse the input grammar into a one symbol_list structure.
-Each rule is represented by a sequence of symbols: the left hand side
-followed by the contents of the right hand side, followed by a null pointer
-instead of a symbol to terminate the rule.
-The next symbol is the lhs of the following rule.
-
-All guards and actions are copied out to the appropriate files,
-labelled by the rule number they apply to.  */
-
-void
-readgram()
+\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 actions are copied out, labelled by the rule number they apply |
+| to.                                                                |
+|                                                                    |
+| Bison used to allow some %directives in the rules sections, but    |
+| this is no longer consider appropriate: (i) the documented grammar |
+| doesn't claim it, (ii), it would promote bad style, (iii), error   |
+| recovery for %directives consists in skipping the junk until a `%' |
+| is seen and helrp synchronizing.  This scheme is definitely wrong  |
+| in the rules section.                                              |
+`-------------------------------------------------------------------*/
+
+static void
+readgram (void)

 {
 {

-  register int t;
-  register bucket *lhs;
-  register symbol_list *p;
-  register symbol_list *p1;
-  register bucket *bp;
-
-  symbol_list *crule;  /* points to first symbol_list of current rule.  */
-                       /* its symbol is the lhs of the rule.   */
-  symbol_list *crule1;  /* points to the symbol_list preceding crule.  */
+  token_t t;
+  symbol_t *lhs = NULL;
+  symbol_list *p = NULL;
+  symbol_list *p1 = NULL;

 
 

-  p1 = NULL;
+  /* Points to first symbol_list of current rule. its symbol is the
+     lhs of the rule.  */
+  symbol_list *crule = NULL;
+  /* Points to the symbol_list preceding crule.  */
+  symbol_list *crule1 = NULL;

 
 

-  t = lex();
+  t = lex ();

 
 

-  while (t != TWO_PERCENTS && t != ENDFILE)
-    {
-      if (t == IDENTIFIER || t == BAR)
-       {
-         register int actionflag = 0;
-         int rulelength = 0;  /* number of symbols in rhs of this rule so far  */
-         int xactions = 0;     /* JF for error checking */
-         bucket *first_rhs = 0;
-
-         if (t == IDENTIFIER)
-           {
-             lhs = symval;
-    
-             t = lex();
-             if (t != COLON)
-               fatal("ill-formed rule");
-           }
-
-         if (nrules == 0)
-           {
-             if (t == BAR)
-               fatal("grammar starts with vertical bar");
-
-             if (!start_flag)
-               startval = lhs;
-           }
+  while (t != tok_two_percents && t != tok_eof)
+    if (t == tok_identifier || t == tok_bar)
+      {
+       int action_flag = 0;
+       /* Number of symbols in rhs of this rule so far */
+       int rulelength = 0;
+       int xactions = 0;       /* JF for error checking */
+       symbol_t *first_rhs = 0;

 
 

-         /* start a new rule and record its lhs.  */
+       if (t == tok_identifier)
+         {
+           lhs = symval;
+
+           if (!start_flag)
+             {
+               startsymbol = lhs;
+               start_flag = 1;
+             }
+
+           t = lex ();
+           if (t != tok_colon)
+             {
+               complain (_("ill-formed rule: initial symbol not followed by colon"));
+               unlex (t);
+             }
+         }

 
 

-         nrules++;
-         nitems++;
+       if (nrules == 0 && t == tok_bar)
+         {
+           complain (_("grammar starts with vertical bar"));
+           lhs = symval;       /* BOGUS: use a random symval */
+         }
+       /* start a new rule and record its lhs.  */

 
 

-         record_rule_line ();
+       ++nrules;
+       ++nritems;

 
 

-         p = NEW(symbol_list);
-         p->sym = lhs;
+       p = symbol_list_new (lhs);

 
 

-         crule1 = p1;
-         if (p1)
-           p1->next = p;
-         else
-           grammar = p;
+       crule1 = p1;
+       if (p1)
+         p1->next = p;
+       else
+         grammar = p;

 
 

-         p1 = p;
-         crule = p;
+       p1 = p;
+       crule = p;

 
 

-         /* mark the rule's lhs as a nonterminal if not already so.  */
+       /* mark the rule's lhs as a nonterminal if not already so.  */

 
 

-         if (lhs->class == SUNKNOWN)
-           {
-             lhs->class = SNTERM;
-             lhs->value = nvars;
-             nvars++;
-           }
-         else if (lhs->class == STOKEN)
-           fatals("rule given for %s, which is a token", lhs->tag);
-
-         /* read the rhs of the rule.  */
+       if (lhs->class == unknown_sym)
+         {
+           lhs->class = nterm_sym;
+           lhs->number = nvars;
+           ++nvars;
+         }
+       else if (lhs->class == token_sym)
+         complain (_("rule given for %s, which is a token"), lhs->tag);

 
 

-         for (;;)
-           {
-             t = lex();
-
-             if (! (t == IDENTIFIER || t == LEFT_CURLY)) break;
-
-             /* If next token is an identifier, see if a colon follows it.
-                If one does, exit this rule now.  */
-             if (t == IDENTIFIER)
-               {
-                 register bucket *ssave;
-                 register int t1;
-
-                 ssave = symval;
-                 t1 = lex();
-                 unlex(t1);
-                 symval = ssave;
-                 if (t1 == COLON) break;
-
-                 if(!first_rhs)        /* JF */
-                   first_rhs = symval;
-                 /* Not followed by colon =>
-                    process as part of this rule's rhs.  */
-               }
-
-             /* If we just passed an action, that action was in the middle
-                of a rule, so make a dummy rule to reduce it to a
-                non-terminal.  */
-             if (actionflag)
-               {
-                 register bucket *sdummy;
-
-                 /* Since the action was written out with this rule's */
-                 /* number, we must write give the new rule this number */
-                 /* by inserting the new rule before it.  */
-
-                 /* Make a dummy nonterminal, a gensym.  */
-                 sdummy = gensym();
-
-                 /* Make a new rule, whose body is empty,
-                    before the current one, so that the action
-                    just read can belong to it.  */
-                 nrules++;
-                 nitems++;
-                 record_rule_line ();
-                 p = NEW(symbol_list);
-                 if (crule1)
-                   crule1->next = p;
-                 else grammar = p;
-                 p->sym = sdummy;
-                 crule1 = NEW(symbol_list);
-                 p->next = crule1;
-                 crule1->next = crule;
-
-                 /* insert the dummy generated by that rule into this rule.  */
-                 nitems++;
-                 p = NEW(symbol_list);
-                 p->sym = sdummy;
-                 p1->next = p;
-                 p1 = p;
-
-                 actionflag = 0;
-               }
-
-             if (t == IDENTIFIER)
-               {
-                 nitems++;
-                 p = NEW(symbol_list);
-                 p->sym = symval;
-                 p1->next = p;
-                 p1 = p;
-               }
-             else /* handle an action.  */
-               {
-                 copy_action(crule, rulelength);
-                 actionflag = 1;
-                 xactions++;   /* JF */
-               }
-             rulelength++;
-           }
+       /* read the rhs of the rule.  */

 
 

-         /* Put an empty link in the list to mark the end of this rule  */
-         p = NEW(symbol_list);
-         p1->next = p;
-         p1 = p;
+       for (;;)
+         {
+           t = lex ();
+           if (t == tok_prec)
+             {
+               t = lex ();
+               crule->ruleprec = symval;
+               t = lex ();
+             }
+
+           if (!(t == tok_identifier || t == tok_left_curly))
+             break;

 
 

-         if (t == PREC)
-           {
-             t = lex();
-             crule->ruleprec = symval;
-             t = lex();
-           }
-         if (t == GUARD)
-           {
-             if (! semantic_parser)
-               fatal("%guard present but %semantic_parser not specified");
+           /* If next token is an identifier, see if a colon follows it.
+              If one does, exit this rule now.  */
+           if (t == tok_identifier)
+             {
+               symbol_t *ssave;
+               token_t t1;
+
+               ssave = symval;
+               t1 = lex ();
+               unlex (t1);
+               symval = ssave;
+               if (t1 == tok_colon)
+                 {
+                   warn (_("previous rule lacks an ending `;'"));
+                   break;
+                 }
+
+               if (!first_rhs) /* JF */
+                 first_rhs = symval;
+               /* Not followed by colon =>
+                  process as part of this rule's rhs.  */
+             }
+
+           /* If we just passed an action, that action was in the middle
+              of a rule, so make a dummy rule to reduce it to a
+              non-terminal.  */
+           if (action_flag)
+             {
+               /* Since the action was written out with this rule's
+                  number, we must give the new rule this number by
+                  inserting the new rule before it.  */
+
+               /* Make a dummy nonterminal, a gensym.  */
+               symbol_t *sdummy = gensym ();
+
+               /* Make a new rule, whose body is empty, before the
+                  current one, so that the action just read can
+                  belong to it.  */
+               ++nrules;
+               ++nritems;
+               p = symbol_list_new (sdummy);
+               /* Attach its lineno to that of the host rule. */
+               p->line = crule->line;
+               /* Move the action from the host rule to this one. */
+               p->action = crule->action;
+               p->action_line = crule->action_line;
+               crule->action = NULL;
+
+               if (crule1)
+                 crule1->next = p;
+               else
+                 grammar = p;
+               /* End of the rule. */
+               crule1 = symbol_list_new (NULL);
+               crule1->next = crule;
+
+               p->next = crule1;
+
+               /* Insert the dummy generated by that rule into this
+                  rule.  */
+               ++nritems;
+               p = symbol_list_new (sdummy);
+               p1->next = p;
+               p1 = p;
+
+               action_flag = 0;
+             }
+
+           if (t == tok_identifier)
+             {
+               ++nritems;
+               p = symbol_list_new (symval);
+               p1->next = p;
+               p1 = p;
+             }
+           else                /* handle an action.  */
+             {
+               parse_action (crule, rulelength);
+               action_flag = 1;
+               ++xactions;     /* JF */
+             }
+           ++rulelength;
+         }                     /* end of  read rhs of rule */
+
+       /* Put an empty link in the list to mark the end of this rule  */
+       p = symbol_list_new (NULL);
+       p1->next = p;
+       p1 = p;
+
+       if (t == tok_prec)
+         {
+           complain (_("two @prec's in a row"));
+           t = lex ();
+           crule->ruleprec = symval;
+           t = lex ();
+         }

 
 

-             copy_guard(crule, rulelength);
-             t = lex();
-           }
-         else if (t == LEFT_CURLY)
-           {
-             if (actionflag) fatal("two actions at end of one rule");
-             copy_action(crule, rulelength);
-             t = lex();
-           }
-         /* If $$ is being set in default way,
-            warn if any type mismatch.  */
-         else if (!xactions && first_rhs && lhs->type_name != first_rhs->type_name)
-           {
-             if (lhs->type_name == 0 || first_rhs->type_name == 0
-                 || strcmp(lhs->type_name,first_rhs->type_name))
-               fprintf(stderr, "%s:%d:  warning:  type clash ('%s' '%s') on default action\n",
-                       infile,
-                       lineno,
+       if (t == tok_left_curly)
+         {
+           /* This case never occurs -wjh */
+           if (action_flag)
+             complain (_("two actions at end of one rule"));
+           parse_action (crule, rulelength);
+           action_flag = 1;
+           ++xactions; /* -wjh */
+           t = lex ();
+         }
+       /* If $$ is being set in default way, report if any type
+          mismatch.  */
+       else if (!xactions
+                && first_rhs && lhs->type_name != first_rhs->type_name)
+         {
+           if (lhs->type_name == 0
+               || first_rhs->type_name == 0
+               || strcmp (lhs->type_name, first_rhs->type_name))
+             complain (_("type clash (`%s' `%s') on default action"),

                        lhs->type_name ? lhs->type_name : "",
                        first_rhs->type_name ? first_rhs->type_name : "");
                        lhs->type_name ? lhs->type_name : "",
                        first_rhs->type_name ? first_rhs->type_name : "");

-           }
-         /* Warn if there is no default for $$ but we need one.  */
-         else if (!xactions && !first_rhs && lhs->type_name != 0)
-           fprintf(stderr,
-                   "%s:%d:  warning: empty rule for typed nonterminal, and no action\n",
-                   infile,
-                   lineno);
-         if (t == SEMICOLON)
-           t = lex();
-       }
-      /* these things can appear as alternatives to rules.  */
-      else if (t == TOKEN)
-       {
-         parse_token_decl(STOKEN, SNTERM);
-         t = lex();
-       }
-      else if (t == NTERM)
-       {
-         parse_token_decl(SNTERM, STOKEN);
-         t = lex();
-       }
-      else if (t == TYPE)
-       {
-         t = get_type();
-       }
-      else if (t == UNION)
-       {
-         parse_union_decl();
-         t = lex();
-       }
-      else if (t == EXPECT)
-       {
-         parse_expect_decl();
-         t = lex();
-       }
-      else if (t == START)
-       {
-         parse_start_decl();
-         t = lex();
-       }
-      else
-       fatal("invalid input");
-    }
-
-  if (nsyms > MAXSHORT)
-    fatals("too many symbols (tokens plus nonterminals); maximum %d",
-          MAXSHORT);
-  if (nrules == 0)
-    fatal("no input grammar");
-
-  if (typed == 0       /* JF put out same default YYSTYPE as YACC does */
-      && !value_components_used)
-    {
-      /* We used to use `unsigned long' as YYSTYPE on MSDOS,
-        but it seems better to be consistent.
-        Most programs should declare their own type anyway.  */
-      fprintf(fattrs, "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
-      if (fdefines)
-       fprintf(fdefines, "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
-    }
-
-  /* Report any undefined symbols and consider them nonterminals.  */
-
-  for (bp = firstsymbol; bp; bp = bp->next)
-    if (bp->class == SUNKNOWN)
+         }
+       /* Warn if there is no default for $$ but we need one.  */
+       else if (!xactions && !first_rhs && lhs->type_name != 0)
+         complain (_("empty rule for typed nonterminal, and no action"));
+       if (t == tok_two_percents || t == tok_eof)
+         warn (_("previous rule lacks an ending `;'"));
+       if (t == tok_semicolon)
+         t = lex ();
+      }
+    else

       {
       {

-       fprintf(stderr, "symbol %s used, not defined as token, and no rules for it\n",
-                       bp->tag);
-       failure = 1;
-       bp->class = SNTERM;
-       bp->value = nvars++;
+       complain (_("invalid input: %s"), quote (token_buffer));
+       t = lex ();

       }
 
       }
 

-  ntokens = nsyms - nvars;
-}
+  /* grammar has been read.  Do some checking */

 
 

+  if (nrules == 0)
+    fatal (_("no rules in the input grammar"));

 
 

-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;
+  /* Report any undefined symbols and consider them nonterminals.  */
+  symbols_check_defined ();
+
+  /* Insert the initial rule, which line is that of the first rule
+     (not that of the start symbol):
+
+     axiom: %start EOF.  */
+  p = symbol_list_new (axiom);
+  p->line = grammar->line;
+  p->next = symbol_list_new (startsymbol);
+  p->next->next = symbol_list_new (eoftoken);
+  p->next->next->next = symbol_list_new (NULL);
+  p->next->next->next->next = grammar;
+  nrules += 1;
+  nritems += 3;
+  grammar = p;
+
+  if (nsyms > SHRT_MAX)
+    fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
+          SHRT_MAX);
+
+  assert (nsyms == ntokens + nvars);

 }
 
 }
 

-
-/* read in a %type declaration and record its information for get_type_name to access */
-
-int
-get_type()
+/* At the end of the grammar file, some C source code must
+   be stored. It is going to be associated to the epilogue
+   directive.  */
+static void
+read_additionnal_code (void)

 {
 {

-  register int k;
-  register int t;
-  register char *name;
-
-  t = lex();
-
-  if (t != TYPENAME)
-    fatal("ill-formed %type declaration");
+  int c;
+  struct obstack el_obstack;

 
 

-  k = strlen(token_buffer);
-  name = NEW2(k + 1, char);
-  strcpy(name, token_buffer);
+  obstack_init (&el_obstack);

 
 

-  for (;;)
+  if (!no_lines_flag)

     {
     {

-      t = lex();
-
-      switch (t)
-       {
-       case SEMICOLON:
-         return (lex());
-
-       case COMMA:
-         break;
-
-       case IDENTIFIER:
-         if (symval->type_name == NULL)
-           symval->type_name = name;
-         else
-           fatals("type redeclaration for %s", symval->tag);
-
-         break;
-
-       default:
-         return (t);
-       }
+      obstack_fgrow2 (&el_obstack, muscle_find ("linef"),
+                     lineno, quotearg_style (c_quoting_style,
+                                             muscle_find ("filename")));

     }
     }

-}
-
-
-
-/* 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()
-{
-  register bucket *bp;
-  register int tokno = 1;
-  register int i;
-  register int last_user_token_number;
-
-  /* int lossage = 0; JF set but not used */
-
-  tags = NEW2(nsyms + 1, char *);
-  tags[0] = "$";

 
 

-  sprec = NEW2(nsyms, short);
-  sassoc = NEW2(nsyms, short);
-
-  max_user_token_number = 256;
-  last_user_token_number = 256;
-
-  for (bp = firstsymbol; bp; bp = bp->next)
-    {
-      if (bp->class == SNTERM)
-       {
-         bp->value += ntokens;
-       }
-      else
-       {
-         if (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++;
-       }
+  while ((c = getc (finput)) != EOF)
+    copy_character (&el_obstack, c);

 
 

-      tags[bp->value] = bp->tag;
-      sprec[bp->value] = bp->prec;
-      sassoc[bp->value] = bp->assoc;
-
-    }
-
-  if (translations)
-    {
-      register int i;
-
-      token_translations = NEW2(max_user_token_number+1, short);
-
-      /* initialize all entries for literal tokens to 2,
-        the internal token number for $illegal., which represents all invalid inputs.  */
-      for (i = 0; i <= max_user_token_number; i++)
-        token_translations[i] = 2;      
-    }
-
-  for (bp = firstsymbol; bp; bp = bp->next)
-    {
-      if (bp->value >= ntokens) continue;
-      if (translations)
-       {
-         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);
-           }
-         token_translations[bp->user_token_number] = bp->value;
-       }
-    }
-
-  error_token_number = errtoken->value;
-
-  output_token_defines(ftable);
-
-  if (startval->class == SUNKNOWN)
-    fatals("the start symbol %s is undefined", startval->tag);
-  else if (startval->class == STOKEN)
-    fatals("the start symbol %s is a token", startval->tag);
-
-  start_symbol = startval->value;
-
-  if (definesflag)
-    {
-      output_token_defines(fdefines);
-
-      if (!pure_parser)
-       {
-         if (spec_name_prefix)
-           fprintf(fdefines, "\nextern YYSTYPE %slval;\n", spec_name_prefix);
-         else
-           fprintf(fdefines, "\nextern YYSTYPE yylval;\n");
-       }
-
-      if (semantic_parser)
-       for (i = ntokens; i < nsyms; i++)
-         {
-           /* don't make these for dummy nonterminals made by gensym.  */
-           if (*tags[i] != '@')
-             fprintf(fdefines, "#define\tNT%s\t%d\n", tags[i], i);
-         }
-#if 0
-      /* `fdefines' is now a temporary file, so we need to copy its
-         contents in `done', so we can't close it here.  */
-      fclose(fdefines);
-      fdefines = NULL;
-#endif
-    }
-}
-      
-
-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);
+  obstack_1grow (&el_obstack, 0);
+  muscle_insert ("epilogue", obstack_finish (&el_obstack));

 }
 
 }
 

+\f
+/*---------------------------------------------------------------.
+| Convert the rules into the representation using RRHS, RLHS and |
+| RITEM.                                                         |
+`---------------------------------------------------------------*/

 
 

-
-/* 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 */
-
-  bucket *ruleprec;
+  unsigned int itemno;
+  int ruleno;
+  symbol_list *p;

 
 

-  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 (item_number_t, nritems);
+  rules = XCALLOC (rule_t, nrules) - 1;

 
   itemno = 0;
   ruleno = 1;
 
   itemno = 0;
   ruleno = 1;


@@ -1775,65 +1399,124 @@ packgram()
   p = grammar;
   while (p)
     {
   p = grammar;
   while (p)
     {

-      rlhs[ruleno] = p->sym->value;
-      rrhs[ruleno] = itemno;
-      ruleprec = p->ruleprec;
+      symbol_t *ruleprec = p->ruleprec;
+      rules[ruleno].user_number = ruleno;
+      rules[ruleno].number = ruleno;
+      rules[ruleno].lhs = p->sym;
+      rules[ruleno].rhs = ritem + itemno;
+      rules[ruleno].line = p->line;
+      rules[ruleno].useful = TRUE;
+      rules[ruleno].action = p->action;
+      rules[ruleno].action_line = p->action_line;

 
       p = p->next;
       while (p && p->sym)
        {
 
       p = p->next;
       while (p && p->sym)
        {

-         ritem[itemno++] = p->sym->value;
+         /* item_number_t = symbol_number_t.
+            But the former needs to contain more: negative rule numbers. */
+         ritem[itemno++] = symbol_number_as_item_number (p->sym->number);

          /* A rule gets by default the precedence and associativity
             of the last token in it.  */
          /* A rule gets by default the precedence and associativity
             of the last token in it.  */

-          if (p->sym->class == STOKEN)
-           {
-             rprec[ruleno] = p->sym->prec;
-             rassoc[ruleno] = p->sym->assoc;
-           }
-         if (p) p = p->next;
+         if (p->sym->class == token_sym)
+           rules[ruleno].prec = p->sym;
+         if (p)
+           p = p->next;

        }
 
       /* If this rule has a %prec,
        }
 
       /* 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;
-         rprecsym[ruleno] = ruleprec->value;
+         rules[ruleno].precsym = ruleprec;
+         rules[ruleno].prec = ruleprec;

        }
        }

-

       ritem[itemno++] = -ruleno;
       ritem[itemno++] = -ruleno;

-      ruleno++;
+      ++ruleno;

 
 

-      if (p) p = p->next;
+      if (p)
+       p = p->next;

     }
 
     }
 

-  ritem[itemno] = 0;
+  assert (itemno == nritems);
+
+  if (trace_flag)
+    ritem_print (stderr);

 }
 \f
 }
 \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 actions are copied into ACTION_OBSTACK, |
+| in each case forming the body of a C function (YYACTION) which    |
+| contains a switch statement to decide which action to execute.    |
+`------------------------------------------------------------------*/

 
 

-int
-read_signed_integer (stream)
-     FILE *stream;
+void
+reader (void)

 {
 {

-  register int c = getc(stream);
-  register int sign = 1;
-  register int n;
+  lex_init ();
+  lineno = 1;

 
 

-  if (c == '-')
-    {
-      c = getc(stream);
-      sign = -1;
-    }
-  n = 0;
-  while (isdigit(c))
+  /* Initialize the muscle obstack.  */
+  obstack_init (&muscle_obstack);
+
+  /* Initialize the symbol table.  */
+  symbols_new ();
+
+  /* Construct the axiom symbol. */
+  axiom = getsym ("$axiom");
+  axiom->class = nterm_sym;
+  axiom->number = nvars++;
+
+  /* Construct the error token */
+  errtoken = getsym ("error");
+  errtoken->class = token_sym;
+  errtoken->number = ntokens++;
+
+  /* Construct a token that represents all undefined literal tokens.
+     It is always token number 2.  */
+  undeftoken = getsym ("$undefined.");
+  undeftoken->class = token_sym;
+  undeftoken->number = ntokens++;
+
+  /* Initialize the obstacks. */
+  obstack_init (&action_obstack);
+  obstack_init (&output_obstack);
+  obstack_init (&pre_prologue_obstack);
+  obstack_init (&post_prologue_obstack);
+
+  finput = xfopen (infile, "r");
+
+  /* Read the declaration section.  Copy %{ ... %} groups to
+     TABLE_OBSTACK and FDEFINES file.  Also notice any %token, %left,
+     etc. found there.  */
+  read_declarations ();
+
+  /* If the user did not define her EOFTOKEN, do it now. */
+  if (!eoftoken)

     {
     {

-      n = 10*n + (c - '0');
-      c = getc(stream);
+      eoftoken = getsym ("$");
+      eoftoken->class = token_sym;
+      eoftoken->number = 0;
+      /* Value specified by POSIX.  */
+      eoftoken->user_token_number = 0;

     }
 
     }
 

-  ungetc(c, stream);
+  /* Read in the grammar, build grammar in list form.  Write out
+     actions.  */
+  readgram ();
+  /* Some C code is given at the end of the grammar file. */
+  read_additionnal_code ();
+
+  lex_free ();
+  xfclose (finput);
+
+  /* Assign the symbols their symbol numbers.  Write #defines for the
+     token symbols into FDEFINES if requested.  */
+  symbols_pack ();
+
+  /* Convert the grammar into the format described in gram.h.  */
+  packgram ();

 
 

-  return n * sign;
+  /* The grammar as a symbol_list is no longer needed. */
+  LIST_FREE (symbol_list, grammar);

 }
 }