* src/symtab.c (bucket_new): New function.

[bison.git] / src / reader.c

diff --git a/src/reader.c b/src/reader.c
index cb297c4c0e60e977af3951ddc9603c902fea5a0d..e5aca8c474cb10f3bc9b2f19c74b45590550e65c 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -23,48 +23,19 @@
 #include "system.h"
 #include "getargs.h"
 #include "files.h"
 #include "system.h"
 #include "getargs.h"
 #include "files.h"

-#include "alloc.h"
+#include "xalloc.h"

 #include "symtab.h"
 #include "lex.h"
 #include "gram.h"
 #include "complain.h"
 #include "output.h"
 #include "symtab.h"
 #include "lex.h"
 #include "gram.h"
 #include "complain.h"
 #include "output.h"

-
-#define        LTYPESTR        "\
-\n\
-#ifndef YYLTYPE\n\
-typedef\n\
-  struct yyltype\n\
-\
-    {\n\
-      int timestamp;\n\
-      int first_line;\n\
-      int first_column;\
-\n\
-      int last_line;\n\
-      int last_column;\n\
-      char *text;\n\
-   }\n\
-\
-  yyltype;\n\
-\n\
-#define YYLTYPE yyltype\n\
-#endif\n\
-\n"
+#include "reader.h"
+#include "conflicts.h"
+#include "quote.h"

 
 /* Number of slots allocated (but not necessarily used yet) in `rline'  */
 static int rline_allocated;
 
 
 /* Number of slots allocated (but not necessarily used yet) in `rline'  */
 static int rline_allocated;
 

-extern bucket *symval;
-extern int numval;
-extern int expected_conflicts;
-extern char *token_buffer;
-extern int maxtoken;
-
-extern void tabinit PARAMS ((void));
-extern void free_symtab PARAMS ((void));
-extern char *printable_version PARAMS ((int));
-

 typedef struct symbol_list
 {
   struct symbol_list *next;
 typedef struct symbol_list
 {
   struct symbol_list *next;


@@ -73,10 +44,6 @@ typedef struct symbol_list
 }
 symbol_list;
 
 }
 symbol_list;
 

-
-extern void reader PARAMS ((void));
-extern void reader_output_yylsp PARAMS ((FILE *));
-

 int lineno;
 char **tags;
 short *user_toknums;
 int lineno;
 char **tags;
 short *user_toknums;


@@ -88,17 +55,17 @@ static bucket *startval;
    they must be unions.  */
 static int value_components_used;
 
    they must be unions.  */
 static int value_components_used;
 

-static int typed;              /* nonzero if %union has been seen.  */
+/* Nonzero if %union has been seen.  */
+static int typed;

 
 

-static int lastprec;           /* incremented for each %left, %right or %nonassoc seen */
+/* Incremented for each %left, %right or %nonassoc seen */
+static int lastprec;

 
 

-static int gensym_count;       /* incremented for each generated symbol */
+/* Incremented for each generated symbol */
+static int gensym_count;

 
 static bucket *errtoken;
 static bucket *undeftoken;
 
 static bucket *errtoken;
 static bucket *undeftoken;

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

 \f
 
 /*===================\
 \f
 
 /*===================\


@@ -150,6 +117,40 @@ read_signed_integer (FILE *stream)
   return sign * n;
 }
 \f
   return sign * n;
 }
 \f

+/*--------------------------------------------------------------.
+| Get the data type (alternative in the union) of the value for |
+| symbol N in rule RULE.                                        |
+`--------------------------------------------------------------*/
+
+static char *
+get_type_name (int n, symbol_list * rule)
+{
+  int i;
+  symbol_list *rp;
+
+  if (n < 0)
+    {
+      complain (_("invalid $ value"));
+      return NULL;
+    }
+
+  rp = rule;
+  i = 0;
+
+  while (i < n)
+    {
+      rp = rp->next;
+      if (rp == NULL || rp->sym == NULL)
+       {
+         complain (_("invalid $ value"));
+         return NULL;
+       }
+      i++;
+    }
+
+  return rp->sym->type_name;
+}
+\f

 /*-------------------------------------------------------------------.
 | Dump the string from FINPUT to FOUTPUT.  MATCH is the delimiter of |
 | the string (either ' or ").                                        |
 /*-------------------------------------------------------------------.
 | Dump the string from FINPUT to FOUTPUT.  MATCH is the delimiter of |
 | the string (either ' or ").                                        |


@@ -194,23 +195,43 @@ copy_string (FILE *fin, FILE *fout, int match)
 }
 
 
 }
 
 

-/*---------------------------------------------------------------.
-| Dump the comment from IN to OUT1 and OUT2.  C is either `*' or |
-| `/', depending upon the type of comments used.  OUT2 might be  |
-| NULL.                                                          |
-`---------------------------------------------------------------*/
+/*----------------------------------------------------------------.
+| Dump the wannabee comment from IN to OUT1 and OUT2.  In fact we |
+| just saw a `/', which might or might not be a comment.  In any  |
+| case, copy what we saw.                                         |
+|                                                                 |
+| OUT2 might be NULL.                                             |
+`----------------------------------------------------------------*/

 
 static inline void
 
 static inline void

-copy_comment2 (FILE *in, FILE *out1, FILE *out2, int c)
+copy_comment2 (FILE *fin, FILE *out1, FILE *out2)

 {
   int cplus_comment;
   int ended;
 {
   int cplus_comment;
   int ended;

+  int c;
+
+  /* We read a `/', output it. */
+  putc ('/', out1);
+  if (out2)
+    putc ('/', out2);
+
+  switch ((c = getc (fin)))
+    {
+    case '/':
+      cplus_comment = 1;
+      break;
+    case '*':
+      cplus_comment = 0;
+      break;
+    default:
+      ungetc (c, fin);
+      return;
+    }

 
 

-  cplus_comment = (c == '/');

   putc (c, out1);
   if (out2)
     putc (c, out2);
   putc (c, out1);
   if (out2)
     putc (c, out2);

-  c = getc (in);
+  c = getc (fin);

 
   ended = 0;
   while (!ended)
 
   ended = 0;
   while (!ended)


@@ -222,7 +243,7 @@ copy_comment2 (FILE *in, FILE *out1, FILE *out2, int c)
              putc (c, out1);
              if (out2)
                putc (c, out2);
              putc (c, out1);
              if (out2)
                putc (c, out2);

-             c = getc (in);
+             c = getc (fin);

            }
 
          if (c == '/')
            }
 
          if (c == '/')


@@ -242,7 +263,7 @@ copy_comment2 (FILE *in, FILE *out1, FILE *out2, int c)
          if (cplus_comment)
            ended = 1;
          else
          if (cplus_comment)
            ended = 1;
          else

-           c = getc (in);
+           c = getc (fin);

        }
       else if (c == EOF)
        fatal (_("unterminated comment"));
        }
       else if (c == EOF)
        fatal (_("unterminated comment"));


@@ -251,21 +272,21 @@ copy_comment2 (FILE *in, FILE *out1, FILE *out2, int c)
          putc (c, out1);
          if (out2)
            putc (c, out2);
          putc (c, out1);
          if (out2)
            putc (c, out2);

-         c = getc (in);
+         c = getc (fin);

        }
     }
 }
 
 
        }
     }
 }
 
 

-/*------------------------------------------------------------.
-| Dump the comment from FIN to FOUT.  C is either `*' or `/', |
-| depending upon the type of comments used.                   |
-`------------------------------------------------------------*/
+/*-------------------------------------------------------------------.
+| Dump the comment (actually the current string starting with a `/') |
+| from FIN to FOUT.                                                  |
+`-------------------------------------------------------------------*/

 
 static inline void
 
 static inline void

-copy_comment (FILE *fin, FILE *fout, int c)
+copy_comment (FILE *fin, FILE *fout)

 {
 {

-  copy_comment2 (fin, fout, NULL, c);
+  copy_comment2 (fin, fout, NULL);

 }
 
 
 }
 
 


@@ -285,7 +306,7 @@ copy_at (FILE *fin, FILE *fout, int stack_offset)
   if (c == '$')
     {
       fprintf (fout, "yyloc");
   if (c == '$')
     {
       fprintf (fout, "yyloc");

-      yylsp_needed = 1;
+      locations_flag = 1;

     }
   else if (isdigit (c) || c == '-')
     {
     }
   else if (isdigit (c) || c == '-')
     {


@@ -295,10 +316,76 @@ copy_at (FILE *fin, FILE *fout, int stack_offset)
       n = read_signed_integer (fin);
 
       fprintf (fout, "yylsp[%d]", n - stack_offset);
       n = read_signed_integer (fin);
 
       fprintf (fout, "yylsp[%d]", n - stack_offset);

-      yylsp_needed = 1;
+      locations_flag = 1;

     }
   else
     }
   else

-    complain (_("@%s is invalid"), printable_version (c));
+    {
+      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 FOUT a reference to this semantic value. STACK_OFFSET is |
+| the number of values in the current rule so far, which says where  |
+| to find `$0' with respect to the top of the stack.                 |
+`-------------------------------------------------------------------*/
+
+static inline void
+copy_dollar (FILE *fin, FILE *fout,
+            symbol_list *rule, int stack_offset)
+{
+  int c = getc (fin);
+  char *type_name = NULL;
+
+  /* Get the type name if explicit. */
+  if (c == '<')
+    {
+      read_type_name (fin);
+      type_name = token_buffer;
+      value_components_used = 1;
+      c = getc (fin);
+    }
+
+  if (c == '$')
+    {
+      fprintf (fout, "yyval");
+      if (!type_name)
+       type_name = get_type_name (0, rule);
+      if (type_name)
+       fprintf (fout, ".%s", type_name);
+      if (!type_name && typed)
+       complain (_("$$ of `%s' has no declared type"),
+                 rule->sym->tag);
+    }
+  else if (isdigit (c) || c == '-')
+    {
+      int n;
+      ungetc (c, fin);
+      n = read_signed_integer (fin);
+
+      if (!type_name && n > 0)
+       type_name = get_type_name (n, rule);
+
+      fprintf (fout, "yyvsp[%d]", n - stack_offset);
+      if (type_name)
+       fprintf (fout, ".%s", type_name);
+      if (!type_name && typed)
+       complain (_("$%d of `%s' has no declared type"),
+                 n, rule->sym->tag);
+    }
+  else
+    {
+      char buf[] = "$c";
+      buf[1] = c;
+      complain (_("%s is invalid"), quote (buf));
+    }

 }
 \f
 /*-------------------------------------------------------------------.
 }
 \f
 /*-------------------------------------------------------------------.


@@ -313,7 +400,7 @@ copy_definition (void)
   /* -1 while reading a character if prev char was %. */
   int after_percent;
 
   /* -1 while reading a character if prev char was %. */
   int after_percent;
 

-  if (!nolinesflag)
+  if (!no_lines_flag)

     fprintf (fattrs, "#line %d \"%s\"\n", lineno, infile);
 
   after_percent = 0;
     fprintf (fattrs, "#line %d \"%s\"\n", lineno, infile);
 
   after_percent = 0;


@@ -339,11 +426,7 @@ copy_definition (void)
          break;
 
        case '/':
          break;
 
        case '/':

-         putc (c, fattrs);
-         c = getc (finput);
-         if (c != '*' && c != '/')
-           continue;
-         copy_comment (finput, fattrs, c);
+         copy_comment (finput, fattrs);

          break;
 
        case EOF:
          break;
 
        case EOF:


@@ -368,24 +451,29 @@ copy_definition (void)
 }
 
 
 }
 
 

-/*-----------------------------------------------------------------.
-| 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   |
+| token_sym and WHAT_IS_NOT is nterm_sym.  For %nterm, the arguments |
+| are reversed.                                                      |
+`-------------------------------------------------------------------*/

 
 static void
 
 static void

-parse_token_decl (int what_is, int what_is_not)
+parse_token_decl (symbol_class what_is, symbol_class what_is_not)

 {
   int token = 0;
   char *typename = 0;
 {
   int token = 0;
   char *typename = 0;

-  struct bucket *symbol = NULL;        /* pts to symbol being defined */
-  int k;

 
 

+  /* The symbol being defined.  */
+  struct bucket *symbol = NULL;
+
+  /* After `%token' and `%nterm', any number of symbols maybe be
+     defined.  */

   for (;;)
     {
       int tmp_char = ungetc (skip_white_space (), finput);
 
   for (;;)
     {
       int tmp_char = ungetc (skip_white_space (), finput);
 

+      /* `%' (for instance from `%token', or from `%%' etc.) is the
+        only valid means to end this declaration.  */

       if (tmp_char == '%')
        return;
       if (tmp_char == EOF)
       if (tmp_char == '%')
        return;
       if (tmp_char == EOF)


@@ -399,25 +487,31 @@ parse_token_decl (int what_is, int what_is_not)
        }
       if (token == TYPENAME)
        {
        }
       if (token == TYPENAME)
        {

-         k = strlen (token_buffer);
-         typename = NEW2 (k + 1, char);
-         strcpy (typename, token_buffer);
+         typename = xstrdup (token_buffer);

          value_components_used = 1;
          symbol = NULL;
        }
       else if (token == IDENTIFIER && *symval->tag == '\"' && symbol)
        {
          value_components_used = 1;
          symbol = NULL;
        }
       else if (token == IDENTIFIER && *symval->tag == '\"' && symbol)
        {

+         if (symval->alias)
+           warn (_("symbol `%s' used more than once as a literal string"),
+                 symval->tag);
+         else if (symbol->alias)
+           warn (_("symbol `%s' given more than one literal string"),
+                 symbol->tag);
+         else
+           {
+             symval->class = token_sym;
+             symval->type_name = typename;
+             symval->user_token_number = symbol->user_token_number;
+             symbol->user_token_number = SALIAS;
+             symval->alias = symbol;
+             symbol->alias = symval;
+             /* symbol and symval combined are only one symbol */
+             nsyms--;
+           }

          translations = 1;
          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 */
+         symbol = NULL;

        }
       else if (token == IDENTIFIER)
        {
        }
       else if (token == IDENTIFIER)
        {


@@ -427,7 +521,7 @@ parse_token_decl (int what_is, int what_is_not)
          if (symbol->class == what_is_not)
            complain (_("symbol %s redefined"), symbol->tag);
          symbol->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 == nterm_sym && oldclass != nterm_sym)

            symbol->value = nvars++;
 
          if (typename)
            symbol->value = nvars++;
 
          if (typename)


@@ -446,7 +540,7 @@ parse_token_decl (int what_is, int what_is_not)
       else
        {
          complain (_("`%s' is invalid in %s"),
       else
        {
          complain (_("`%s' is invalid in %s"),

-                   token_buffer, (what_is == STOKEN) ? "%token" : "%nterm");
+                   token_buffer, (what_is == token_sym) ? "%token" : "%nterm");

          skip_to_char ('%');
        }
     }
          skip_to_char ('%');
        }
     }


@@ -454,7 +548,9 @@ parse_token_decl (int what_is, int what_is_not)
 }
 
 
 }
 
 

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

 
 static void
 parse_start_decl (void)
 
 static void
 parse_start_decl (void)


@@ -470,43 +566,6 @@ parse_start_decl (void)
     }
 }
 
     }
 }
 

-
-
-/*--------------------------------------------------------------.
-| Get the data type (alternative in the union) of the value for |
-| symbol n in rule rule.                                        |
-`--------------------------------------------------------------*/
-
-static char *
-get_type_name (int n, symbol_list * rule)
-{
-  int i;
-  symbol_list *rp;
-
-  if (n < 0)
-    {
-      complain (_("invalid $ value"));
-      return NULL;
-    }
-
-  rp = rule;
-  i = 0;
-
-  while (i < n)
-    {
-      rp = rp->next;
-      if (rp == NULL || rp->sym == NULL)
-       {
-         complain (_("invalid $ value"));
-         return NULL;
-       }
-      i++;
-    }
-
-  return rp->sym->type_name;
-}
-
-

 /*-----------------------------------------------------------.
 | 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                                    |


@@ -515,7 +574,6 @@ get_type_name (int n, symbol_list * rule)
 static void
 parse_type_decl (void)
 {
 static void
 parse_type_decl (void)
 {

-  int k;

   char *name;
 
   if (lex () != TYPENAME)
   char *name;
 
   if (lex () != TYPENAME)


@@ -525,9 +583,7 @@ parse_type_decl (void)
       return;
     }
 
       return;
     }
 

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

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


@@ -566,13 +622,14 @@ parse_type_decl (void)
 
 
 
 
 
 

-/* 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.                                                    |
+`----------------------------------------------------------------*/

 
 static void
 
 static void

-parse_assoc_decl (int assoc)
+parse_assoc_decl (associativity assoc)

 {
 {

-  int k;

   char *name = NULL;
   int prev = 0;
 
   char *name = NULL;
   int prev = 0;
 


@@ -592,11 +649,8 @@ parse_assoc_decl (int assoc)
 
       switch (t)
        {
 
       switch (t)
        {

-

        case TYPENAME:
        case TYPENAME:

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

          break;
 
        case COMMA:
          break;
 
        case COMMA:


@@ -607,9 +661,9 @@ parse_assoc_decl (int assoc)
            complain (_("redefining precedence of %s"), symval->tag);
          symval->prec = lastprec;
          symval->assoc = assoc;
            complain (_("redefining precedence of %s"), symval->tag);
          symval->prec = lastprec;
          symval->assoc = assoc;

-         if (symval->class == SNTERM)
+         if (symval->class == nterm_sym)

            complain (_("symbol %s redefined"), symval->tag);
            complain (_("symbol %s redefined"), symval->tag);

-         symval->class = STOKEN;
+         symval->class = token_sym;

          if (name)
            {                   /* record the type, if one is specified */
              if (symval->type_name == NULL)
          if (name)
            {                   /* record the type, if one is specified */
              if (symval->type_name == NULL)


@@ -649,9 +703,11 @@ token_buffer);
 
 
 
 
 
 

-/* 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 fattrs (and fdefines), where it is |
+| made into the definition of YYSTYPE, the type of elements of the   |
+| parser value stack.                                                |
+`-------------------------------------------------------------------*/

 
 static void
 parse_union_decl (void)
 
 static void
 parse_union_decl (void)


@@ -664,7 +720,7 @@ parse_union_decl (void)
 
   typed = 1;
 
 
   typed = 1;
 

-  if (!nolinesflag)
+  if (!no_lines_flag)

     fprintf (fattrs, "\n#line %d \"%s\"\n", lineno, infile);
   else
     fprintf (fattrs, "\n");
     fprintf (fattrs, "\n#line %d \"%s\"\n", lineno, infile);
   else
     fprintf (fattrs, "\n");


@@ -688,13 +744,9 @@ parse_union_decl (void)
          break;
 
        case '/':
          break;
 
        case '/':

-         c = getc (finput);
-         if (c != '*' && c != '/')
-           continue;
-         copy_comment2 (finput, fattrs, fdefines, c);
+         copy_comment2 (finput, fattrs, fdefines);

          break;
 
          break;
 

-

        case '{':
          count++;
          break;
        case '{':
          count++;
          break;


@@ -720,34 +772,22 @@ parse_union_decl (void)
     }
 }
 
     }
 }
 

-/* 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.                                |
+`-------------------------------------------------------*/

 
 static void
 parse_expect_decl (void)
 {
 
 static void
 parse_expect_decl (void)
 {

-  int c;
-  int count;
-  char buffer[20];
-
-  c = getc (finput);
-  while (c == ' ' || c == '\t')
-    c = getc (finput);
-
-  count = 0;
-  while (c >= '0' && c <= '9')
-    {
-      if (count < 20)
-       buffer[count++] = c;
-      c = getc (finput);
-    }
-  buffer[count] = 0;
-
+  int c = skip_white_space ();

   ungetc (c, finput);
 
   ungetc (c, finput);
 

-  if (count <= 0 || count > 10)
-    complain ("%s", _("argument of %expect is not an integer"));
-  expected_conflicts = atoi (buffer);
+  if (!isdigit (c))
+    complain (_("argument of %%expect is not an integer"));
+  else
+    expected_conflicts = read_signed_integer (finput);

 }
 
 
 }
 
 


@@ -777,15 +817,13 @@ parse_thong_decl (void)
   int token;
   struct bucket *symbol;
   char *typename = 0;
   int token;
   struct bucket *symbol;
   char *typename = 0;

-  int k, usrtoknum;
+  int usrtoknum;

 
   translations = 1;
   token = lex ();              /* fetch typename or first token */
   if (token == TYPENAME)
     {
 
   translations = 1;
   token = lex ();              /* fetch typename or first token */
   if (token == TYPENAME)
     {

-      k = strlen (token_buffer);
-      typename = NEW2 (k + 1, char);
-      strcpy (typename, token_buffer);
+      typename = xstrdup (token_buffer);

       value_components_used = 1;
       token = lex ();          /* fetch first token */
     }
       value_components_used = 1;
       token = lex ();          /* fetch first token */
     }


@@ -799,7 +837,7 @@ parse_thong_decl (void)
       skip_to_char ('%');
       return;
     }
       skip_to_char ('%');
       return;
     }

-  symval->class = STOKEN;
+  symval->class = token_sym;

   symval->type_name = typename;
   symval->user_token_number = SALIAS;
   symbol = symval;
   symval->type_name = typename;
   symval->user_token_number = SALIAS;
   symbol = symval;


@@ -822,16 +860,18 @@ parse_thong_decl (void)
       skip_to_char ('%');
       return;
     }
       skip_to_char ('%');
       return;
     }

-  symval->class = STOKEN;
+  symval->class = token_sym;

   symval->type_name = typename;
   symval->user_token_number = usrtoknum;
 
   symval->alias = symbol;
   symbol->alias = symval;
 
   symval->type_name = typename;
   symval->user_token_number = usrtoknum;
 
   symval->alias = symbol;
   symbol->alias = symval;
 

-  nsyms--;                     /* symbol and symval combined are only one symbol */
+  /* symbol and symval combined are only one symbol.  */
+  nsyms--;

 }
 
 }
 

+

 /*----------------------------------------------------------------.
 | Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
 | any `%' declarations, and copy the contents of any `%{ ... %}'  |
 /*----------------------------------------------------------------.
 | Read from finput until `%%' is seen.  Discard the `%%'.  Handle |
 | any `%' declarations, and copy the contents of any `%{ ... %}'  |


@@ -862,11 +902,11 @@ read_declarations (void)
              break;
 
            case TOKEN:
              break;
 
            case TOKEN:

-             parse_token_decl (STOKEN, SNTERM);
+             parse_token_decl (token_sym, nterm_sym);

              break;
 
            case NTERM:
              break;
 
            case NTERM:

-             parse_token_decl (SNTERM, STOKEN);
+             parse_token_decl (nterm_sym, token_sym);

              break;
 
            case TYPE:
              break;
 
            case TYPE:


@@ -887,16 +927,17 @@ read_declarations (void)
            case THONG:
              parse_thong_decl ();
              break;
            case THONG:
              parse_thong_decl ();
              break;

+

            case LEFT:
            case LEFT:

-             parse_assoc_decl (LEFT_ASSOC);
+             parse_assoc_decl (left_assoc);

              break;
 
            case RIGHT:
              break;
 
            case RIGHT:

-             parse_assoc_decl (RIGHT_ASSOC);
+             parse_assoc_decl (right_assoc);

              break;
 
            case NONASSOC:
              break;
 
            case NONASSOC:

-             parse_assoc_decl (NON_ASSOC);
+             parse_assoc_decl (non_assoc);

              break;
 
            case SEMANTIC_PARSER:
              break;
 
            case SEMANTIC_PARSER:


@@ -923,7 +964,9 @@ read_declarations (void)
        fatal (_("no input grammar"));
       else
        {
        fatal (_("no input grammar"));
       else
        {

-         complain (_("unknown character: %s"), printable_version (c));
+         char buf[] = "c";
+         buf[0] = c;
+         complain (_("unknown character: %s"), quote (buf));

          skip_to_char ('%');
        }
     }
          skip_to_char ('%');
        }
     }


@@ -937,19 +980,17 @@ read_declarations (void)
 `-------------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------------*/
 
 static void

-copy_action (symbol_list * rule, int stack_offset)
+copy_action (symbol_list *rule, int stack_offset)

 {
   int c;
 {
   int c;

-  int n;

   int count;
   int count;

-  char *type_name;

 
   /* offset is always 0 if parser has already popped the stack pointer */
   if (semantic_parser)
     stack_offset = 0;
 
   fprintf (faction, "\ncase %d:\n", nrules);
 
   /* 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)
+  if (!no_lines_flag)

     fprintf (faction, "#line %d \"%s\"\n", lineno, infile);
   putc ('{', faction);
 
     fprintf (faction, "#line %d \"%s\"\n", lineno, infile);
   putc ('{', faction);
 


@@ -978,65 +1019,11 @@ copy_action (symbol_list * rule, int stack_offset)
              break;
 
            case '/':
              break;
 
            case '/':

-             putc (c, faction);
-             c = getc (finput);
-             if (c != '*' && c != '/')
-               continue;
-             copy_comment (finput, faction, c);
+             copy_comment (finput, faction);

              break;
 
            case '$':
              break;
 
            case '$':

-             c = getc (finput);
-             type_name = NULL;
-
-             if (c == '<')
-               {
-                 char *cp = token_buffer;
-
-                 while ((c = getc (finput)) != '>' && c > 0)
-                   {
-                     if (cp == token_buffer + maxtoken)
-                       cp = grow_token_buffer (cp);
-
-                     *cp++ = c;
-                   }
-                 *cp = 0;
-                 type_name = token_buffer;
-                 value_components_used = 1;
-
-                 c = getc (finput);
-               }
-             if (c == '$')
-               {
-                 fprintf (faction, "yyval");
-                 if (!type_name)
-                   type_name = get_type_name (0, rule);
-                 if (type_name)
-                   fprintf (faction, ".%s", type_name);
-                 if (!type_name && typed)
-                   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));
-
+             copy_dollar (finput, faction, rule, stack_offset);

              break;
 
            case '@':
              break;
 
            case '@':


@@ -1075,12 +1062,10 @@ copy_action (symbol_list * rule, int stack_offset)
 `-------------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------------*/
 
 static void

-copy_guard (symbol_list * rule, int stack_offset)
+copy_guard (symbol_list *rule, int stack_offset)

 {
   int c;
 {
   int c;

-  int n;

   int count;
   int count;

-  char *type_name;

   int brace_flag = 0;
 
   /* offset is always 0 if parser has already popped the stack pointer */
   int brace_flag = 0;
 
   /* offset is always 0 if parser has already popped the stack pointer */


@@ -1088,7 +1073,7 @@ copy_guard (symbol_list * rule, int stack_offset)
     stack_offset = 0;
 
   fprintf (fguard, "\ncase %d:\n", nrules);
     stack_offset = 0;
 
   fprintf (fguard, "\ncase %d:\n", nrules);

-  if (!nolinesflag)
+  if (!no_lines_flag)

     fprintf (fguard, "#line %d \"%s\"\n", lineno, infile);
   putc ('{', fguard);
 
     fprintf (fguard, "#line %d \"%s\"\n", lineno, infile);
   putc ('{', fguard);
 


@@ -1127,64 +1112,11 @@ copy_guard (symbol_list * rule, int stack_offset)
          break;
 
        case '/':
          break;
 
        case '/':

-         putc (c, fguard);
-         c = getc (finput);
-         if (c != '*' && c != '/')
-           continue;
-         copy_comment (finput, fguard, c);
+         copy_comment (finput, fguard);

          break;
 
        case '$':
          break;
 
        case '$':

-         c = getc (finput);
-         type_name = NULL;
-
-         if (c == '<')
-           {
-             char *cp = token_buffer;
-
-             while ((c = getc (finput)) != '>' && c > 0)
-               {
-                 if (cp == token_buffer + maxtoken)
-                   cp = grow_token_buffer (cp);
-
-                 *cp++ = c;
-               }
-             *cp = 0;
-             type_name = token_buffer;
-
-             c = getc (finput);
-           }
-
-         if (c == '$')
-           {
-             fprintf (fguard, "yyval");
-             if (!type_name)
-               type_name = rule->sym->type_name;
-             if (type_name)
-               fprintf (fguard, ".%s", type_name);
-             if (!type_name && typed)
-               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 (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;
-           }
-         else
-           complain (_("$%s is invalid"), printable_version (c));
+         copy_dollar (finput, fguard, rule, stack_offset);

          break;
 
        case '@':
          break;
 
        case '@':


@@ -1226,8 +1158,7 @@ record_rule_line (void)
   if (nrules >= rline_allocated)
     {
       rline_allocated = nrules * 2;
   if (nrules >= rline_allocated)
     {
       rline_allocated = nrules * 2;

-      rline = (short *) xrealloc ((char *) rline,
-                                 rline_allocated * sizeof (short));
+      rline = XREALLOC (rline, short, rline_allocated);

     }
   rline[nrules] = lineno;
 }
     }
   rline[nrules] = lineno;
 }


@@ -1245,7 +1176,7 @@ gensym (void)
 
   sprintf (token_buffer, "@%d", ++gensym_count);
   sym = getsym (token_buffer);
 
   sprintf (token_buffer, "@%d", ++gensym_count);
   sym = getsym (token_buffer);

-  sym->class = SNTERM;
+  sym->class = nterm_sym;

   sym->value = nvars++;
   return sym;
 }
   sym->value = nvars++;
   return sym;
 }


@@ -1272,9 +1203,7 @@ get_type (void)
       return t;
     }
 
       return t;
     }
 

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

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


@@ -1324,9 +1253,11 @@ readgram (void)
   symbol_list *p1;
   bucket *bp;
 
   symbol_list *p1;
   bucket *bp;
 

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

 
   p1 = NULL;
 
 
   p1 = NULL;
 


@@ -1336,8 +1267,9 @@ readgram (void)
     {
       if (t == IDENTIFIER || t == BAR)
        {
     {
       if (t == IDENTIFIER || t == BAR)
        {

-         int actionflag = 0;
-         int rulelength = 0;   /* number of symbols in rhs of this rule so far  */
+         int action_flag = 0;
+         /* Number of symbols in rhs of this rule so far */
+         int rulelength = 0;

          int xactions = 0;     /* JF for error checking */
          bucket *first_rhs = 0;
 
          int xactions = 0;     /* JF for error checking */
          bucket *first_rhs = 0;
 


@@ -1371,7 +1303,7 @@ readgram (void)
 
          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;


@@ -1385,13 +1317,13 @@ readgram (void)
 
          /* 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)
+         if (lhs->class == unknown_sym)

            {
            {

-             lhs->class = SNTERM;
+             lhs->class = nterm_sym;

              lhs->value = nvars;
              nvars++;
            }
              lhs->value = nvars;
              nvars++;
            }

-         else if (lhs->class == STOKEN)
+         else if (lhs->class == token_sym)

            complain (_("rule given for %s, which is a token"), lhs->tag);
 
          /* read the rhs of the rule.  */
            complain (_("rule given for %s, which is a token"), lhs->tag);
 
          /* read the rhs of the rule.  */


@@ -1432,13 +1364,13 @@ readgram (void)
              /* 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 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)
+             if (action_flag)

                {
                  bucket *sdummy;
 
                {
                  bucket *sdummy;
 

-                 /* Since the action was written out with this rule's */
-                 /* number, we must give the new rule this number */
-                 /* by inserting the new rule before it.  */
+                 /* Since the action was written out with this rule's
+                    number, we must give the new rule this number by
+                    inserting the new rule before it.  */

 
                  /* Make a dummy nonterminal, a gensym.  */
                  sdummy = gensym ();
 
                  /* Make a dummy nonterminal, a gensym.  */
                  sdummy = gensym ();


@@ -1449,30 +1381,31 @@ readgram (void)
                  nrules++;
                  nitems++;
                  record_rule_line ();
                  nrules++;
                  nitems++;
                  record_rule_line ();

-                 p = NEW (symbol_list);
+                 p = XCALLOC (symbol_list, 1);

                  if (crule1)
                    crule1->next = p;
                  else
                    grammar = p;
                  p->sym = sdummy;
                  if (crule1)
                    crule1->next = p;
                  else
                    grammar = p;
                  p->sym = sdummy;

-                 crule1 = NEW (symbol_list);
+                 crule1 = XCALLOC (symbol_list, 1);

                  p->next = crule1;
                  crule1->next = crule;
 
                  p->next = crule1;
                  crule1->next = crule;
 

-                 /* insert the dummy generated by that rule into this rule.  */
+                 /* Insert the dummy generated by that rule into this
+                    rule.  */

                  nitems++;
                  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;
 

-                 actionflag = 0;
+                 action_flag = 0;

                }
 
              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;


@@ -1480,14 +1413,14 @@ readgram (void)
              else              /* handle an action.  */
                {
                  copy_action (crule, rulelength);
              else              /* handle an action.  */
                {
                  copy_action (crule, rulelength);

-                 actionflag = 1;
+                 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  */
                  xactions++;   /* JF */
                }
              rulelength++;
            }                   /* end of  read rhs of rule */
 
          /* Put an empty link in the list to mark the end of this rule  */

-         p = NEW (symbol_list);
+         p = XCALLOC (symbol_list, 1);

          p1->next = p;
          p1 = p;
 
          p1->next = p;
          p1 = p;
 


@@ -1501,9 +1434,7 @@ readgram (void)
          if (t == GUARD)
            {
              if (!semantic_parser)
          if (t == GUARD)
            {
              if (!semantic_parser)

-               complain ("%s",
-                         _
-                         ("%guard present but %semantic_parser not specified"));
+               complain (_("%%guard present but %%semantic_parser not specified"));

 
              copy_guard (crule, rulelength);
              t = lex ();
 
              copy_guard (crule, rulelength);
              t = lex ();


@@ -1511,10 +1442,10 @@ readgram (void)
          else if (t == LEFT_CURLY)
            {
              /* This case never occurs -wjh */
          else if (t == LEFT_CURLY)
            {
              /* This case never occurs -wjh */

-             if (actionflag)
+             if (action_flag)

                complain (_("two actions at end of one rule"));
              copy_action (crule, rulelength);
                complain (_("two actions at end of one rule"));
              copy_action (crule, rulelength);

-             actionflag = 1;
+             action_flag = 1;

              xactions++;       /* -wjh */
              t = lex ();
            }
              xactions++;       /* -wjh */
              t = lex ();
            }


@@ -1545,12 +1476,12 @@ readgram (void)
 */
       else if (t == TOKEN)
        {
 */
       else if (t == TOKEN)
        {

-         parse_token_decl (STOKEN, SNTERM);
+         parse_token_decl (token_sym, nterm_sym);

          t = lex ();
        }
       else if (t == NTERM)
        {
          t = lex ();
        }
       else if (t == NTERM)
        {

-         parse_token_decl (SNTERM, STOKEN);
+         parse_token_decl (nterm_sym, token_sym);

          t = lex ();
        }
       else if (t == TYPE)
          t = lex ();
        }
       else if (t == TYPE)


@@ -1589,7 +1520,8 @@ readgram (void)
   if (nrules == 0)
     fatal (_("no rules in the input grammar"));
 
   if (nrules == 0)
     fatal (_("no rules in the input grammar"));
 

-  if (typed == 0               /* JF put out same default YYSTYPE as YACC does */
+  /* JF put out same default YYSTYPE as YACC does */
+  if (typed == 0

       && !value_components_used)
     {
       /* We used to use `unsigned long' as YYSTYPE on MSDOS,
       && !value_components_used)
     {
       /* We used to use `unsigned long' as YYSTYPE on MSDOS,


@@ -1603,12 +1535,12 @@ readgram (void)
   /* Report any undefined symbols and consider them nonterminals.  */
 
   for (bp = firstsymbol; bp; bp = bp->next)
   /* Report any undefined symbols and consider them nonterminals.  */
 
   for (bp = firstsymbol; bp; bp = bp->next)

-    if (bp->class == SUNKNOWN)
+    if (bp->class == unknown_sym)

       {
        complain (_
                  ("symbol %s is used, but is not defined as a token and has no rules"),
       {
        complain (_
                  ("symbol %s is used, but is not defined as a token and has no rules"),

-bp->tag);
-       bp->class = SNTERM;
+                 bp->tag);
+       bp->class = nterm_sym;

        bp->value = nvars++;
       }
 
        bp->value = nvars++;
       }
 


@@ -1655,7 +1587,7 @@ output_token_defines (FILE *file)
        continue;
 
       fprintf (file, "#define\t%s\t%d\n", symbol,
        continue;
 
       fprintf (file, "#define\t%s\t%d\n", symbol,

-              ((translations && !rawtoknumflag)
+              ((translations && !raw_flag)

                ? bp->user_token_number : bp->value));
       if (semantic_parser)
        fprintf (file, "#define\tT%s\t%d\n", symbol, bp->value);
                ? bp->user_token_number : bp->value));
       if (semantic_parser)
        fprintf (file, "#define\tT%s\t%d\n", symbol, bp->value);


@@ -1667,7 +1599,7 @@ output_token_defines (FILE *file)
 
 /*------------------------------------------------------------------.
 | Assign symbol numbers, and write definition of token names into   |
 
 /*------------------------------------------------------------------.
 | Assign symbol numbers, and write definition of token names into   |

-| fdefines.  Set up vectors tags and sprec of names and precedences |
+| FDEFINES.  Set up vectors TAGS and SPREC of names and precedences |

 | of symbols.                                                       |
 `------------------------------------------------------------------*/
 
 | of symbols.                                                       |
 `------------------------------------------------------------------*/
 


@@ -1682,20 +1614,20 @@ packsymbols (void)
 
   /* int lossage = 0; JF set but not used */
 
 
   /* int lossage = 0; JF set but not used */
 

-  tags = NEW2 (nsyms + 1, char *);
+  tags = XCALLOC (char *, nsyms + 1);

   tags[0] = DOLLAR;
   tags[0] = DOLLAR;

-  user_toknums = NEW2 (nsyms + 1, short);
+  user_toknums = XCALLOC (short, nsyms + 1);

   user_toknums[0] = 0;
 
   user_toknums[0] = 0;
 

-  sprec = NEW2 (nsyms, short);
-  sassoc = NEW2 (nsyms, short);
+  sprec = XCALLOC (short, nsyms);
+  sassoc = XCALLOC (short, nsyms);

 
   max_user_token_number = 256;
   last_user_token_number = 256;
 
   for (bp = firstsymbol; bp; bp = bp->next)
     {
 
   max_user_token_number = 256;
   last_user_token_number = 256;
 
   for (bp = firstsymbol; bp; bp = bp->next)
     {

-      if (bp->class == SNTERM)
+      if (bp->class == nterm_sym)

        {
          bp->value += ntokens;
        }
        {
          bp->value += ntokens;
        }


@@ -1735,12 +1667,12 @@ packsymbols (void)
            continue;           /* do not do processing below for SALIASs */
 
        }
            continue;           /* do not do processing below for SALIASs */
 
        }

-      else                     /* bp->class == STOKEN */
+      else                     /* bp->class == token_sym */

        {
          bp->value = tokno++;
        }
 
        {
          bp->value = tokno++;
        }
 

-      if (bp->class == STOKEN)
+      if (bp->class == token_sym)

        {
          if (translations && !(bp->user_token_number))
            bp->user_token_number = ++last_user_token_number;
        {
          if (translations && !(bp->user_token_number))
            bp->user_token_number = ++last_user_token_number;


@@ -1759,7 +1691,7 @@ packsymbols (void)
     {
       int j;
 
     {
       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
 
       /* initialize all entries for literal tokens to 2, the internal
          token number for $undefined., which represents all invalid


@@ -1783,17 +1715,17 @@ packsymbols (void)
 
   error_token_number = errtoken->value;
 
 
   error_token_number = errtoken->value;
 

-  if (!noparserflag)
+  if (!no_parser_flag)

     output_token_defines (ftable);
 
     output_token_defines (ftable);
 

-  if (startval->class == SUNKNOWN)
+  if (startval->class == unknown_sym)

     fatal (_("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 == token_sym)

     fatal (_("the start symbol %s is a token"), startval->tag);
 
   start_symbol = startval->value;
 
     fatal (_("the start symbol %s is a token"), startval->tag);
 
   start_symbol = startval->value;
 

-  if (definesflag)
+  if (defines_flag)

     {
       output_token_defines (fdefines);
 
     {
       output_token_defines (fdefines);
 


@@ -1837,12 +1769,12 @@ packgram (void)
 
   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;


@@ -1860,7 +1792,7 @@ packgram (void)
          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 == token_sym)

            {
              rprec[ruleno] = p->sym->prec;
              rassoc[ruleno] = p->sym->assoc;
            {
              rprec[ruleno] = p->sym->prec;
              rassoc[ruleno] = p->sym->assoc;


@@ -1916,7 +1848,7 @@ reader (void)
   nrules = 0;
   nitems = 0;
   rline_allocated = 10;
   nrules = 0;
   nitems = 0;
   rline_allocated = 10;

-  rline = NEW2 (rline_allocated, short);
+  rline = XCALLOC (short, rline_allocated);

 
   typed = 0;
   lastprec = 0;
 
   typed = 0;
   lastprec = 0;


@@ -1925,7 +1857,6 @@ reader (void)
 
   semantic_parser = 0;
   pure_parser = 0;
 
   semantic_parser = 0;
   pure_parser = 0;

-  yylsp_needed = 0;

 
   grammar = NULL;
 
 
   grammar = NULL;
 


@@ -1936,12 +1867,12 @@ reader (void)
   tabinit ();
   /* Construct the error token */
   errtoken = getsym ("error");
   tabinit ();
   /* Construct the error token */
   errtoken = getsym ("error");

-  errtoken->class = STOKEN;
+  errtoken->class = token_sym;

   errtoken->user_token_number = 256;   /* Value specified by POSIX.  */
   /* Construct a token that represents all undefined literal tokens.
      It is always token number 2.  */
   undeftoken = getsym ("$undefined.");
   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->class = token_sym;

   undeftoken->user_token_number = 2;
 
   /* Read the declaration section.  Copy %{ ... %} groups to FTABLE
   undeftoken->user_token_number = 2;
 
   /* Read the declaration section.  Copy %{ ... %} groups to FTABLE


@@ -1951,7 +1882,7 @@ reader (void)
   fprintf (ftable, "\
 /* %s, made from %s\n\
    by GNU bison %s.  */\n\
   fprintf (ftable, "\
 /* %s, made from %s\n\
    by GNU bison %s.  */\n\

-\n", noparserflag ? "Bison-generated parse tables" : "A Bison parser", infile, VERSION);
+\n", no_parser_flag ? "Bison-generated parse tables" : "A Bison parser", infile, VERSION);

 
   fputs ("#define YYBISON 1  /* Identify Bison output.  */\n\n", ftable);
   read_declarations ();
 
   fputs ("#define YYBISON 1  /* Identify Bison output.  */\n\n", ftable);
   read_declarations ();


@@ -1966,7 +1897,7 @@ reader (void)
     reader_output_yylsp (fdefines);
   /* Write closing delimiters for actions and guards.  */
   output_trailers ();
     reader_output_yylsp (fdefines);
   /* Write closing delimiters for actions and guards.  */
   output_trailers ();

-  if (yylsp_needed)
+  if (locations_flag)

     fputs ("#define YYLSP_NEEDED\n\n", ftable);
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */
     fputs ("#define YYLSP_NEEDED\n\n", ftable);
   /* Assign the symbols their symbol numbers.  Write #defines for the
      token symbols into FDEFINES if requested.  */


@@ -1978,9 +1909,27 @@ reader (void)
   free_symtab ();
 }
 
   free_symtab ();
 }
 

+

 void
 reader_output_yylsp (FILE *f)
 {
 void
 reader_output_yylsp (FILE *f)
 {

-  if (yylsp_needed)
-    fprintf (f, LTYPESTR);
+  if (locations_flag)
+    fputs ("\
+\n\
+#ifndef YYLTYPE\n\
+typedef struct yyltype\n\
+{\n\
+  int timestamp;\n\
+  int first_line;\n\
+  int first_column;\
+\n\
+  int last_line;\n\
+  int last_column;\n\
+  char *text;\n\
+} yyltype;\n\
+\n\
+# define YYLTYPE yyltype\n\
+#endif\n\
+\n",
+          f);

 }
 }