X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/d7913476c462b480f11e14b6829942f2691c6c01..131e2fef683836d45262423bbdf004a014335aba:/src/reader.c

diff --git a/src/reader.c b/src/reader.c
index 1dfe020b..cdacc071 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -31,30 +31,7 @@
 #include "output.h"
 #include "reader.h"
 #include "conflicts.h"
-
-extern char *printable_version PARAMS ((int));
-
-#define	LTYPESTR	"\
-\n\
-#ifndef YYLTYPE\n\
-typedef\n\
-  struct yyltype\n\
-\
-    {\n\
-      int timestamp;\n\
-      int first_line;\n\
-      int first_column;\
-\n\
-      int last_line;\n\
-      int last_column;\n\
-      char *text;\n\
-   }\n\
-\
-  yyltype;\n\
-\n\
-#define YYLTYPE yyltype\n\
-#endif\n\
-\n"
+#include "quote.h"
 
 /* Number of slots allocated (but not necessarily used yet) in `rline'  */
 static int rline_allocated;
@@ -78,17 +55,17 @@ static bucket *startval;
    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;
-
-/* Nonzero if any action or guard uses the @n construct.  */
-static int yylsp_needed;
 
 
 /*===================\
@@ -140,6 +117,40 @@ read_signed_integer (FILE *stream)
   return sign * n;
 }
 
+/*--------------------------------------------------------------.
+| 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;
+}
+
 /*-------------------------------------------------------------------.
 | Dump the string from FINPUT to FOUTPUT.  MATCH is the delimiter of |
 | the string (either ' or ").                                        |
@@ -275,7 +286,7 @@ copy_at (FILE *fin, FILE *fout, int stack_offset)
   if (c == '$')
     {
       fprintf (fout, "yyloc");
-      yylsp_needed = 1;
+      locations_flag = 1;
     }
   else if (isdigit (c) || c == '-')
     {
@@ -285,10 +296,86 @@ copy_at (FILE *fin, FILE *fout, int stack_offset)
       n = read_signed_integer (fin);
 
       fprintf (fout, "yylsp[%d]", n - stack_offset);
-      yylsp_needed = 1;
+      locations_flag = 1;
+    }
+  else
+    {
+      char buf[] = "@c";
+      buf[1] = c;
+      complain (_("%s is invalid"), quote (buf));
+    }
+}
+
+
+/*-------------------------------------------------------------------.
+| FIN is pointing to a wannabee semantic value (i.e., a `$').        |
+|                                                                    |
+| Possible inputs: $[<TYPENAME>]($|integer)                          |
+|                                                                    |
+| Output to 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 typename if explicit. */
+  if (c == '<')
+    {
+      char *cp = token_buffer;
+
+      while ((c = getc (fin)) != '>' && 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 (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
-    complain (_("@%s is invalid"), printable_version (c));
+    {
+      char buf[] = "$c";
+      buf[1] = c;
+      complain (_("%s is invalid"), quote (buf));
+    }
 }
 
 /*-------------------------------------------------------------------.
@@ -303,7 +390,7 @@ copy_definition (void)
   /* -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;
@@ -358,19 +445,18 @@ 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
-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;
   struct bucket *symbol = NULL;	/* pts to symbol being defined */
-  int k;
 
   for (;;)
     {
@@ -389,25 +475,31 @@ parse_token_decl (int what_is, int what_is_not)
 	}
       if (token == TYPENAME)
 	{
-	  k = strlen (token_buffer);
-	  typename = XCALLOC (char, k + 1);
-	  strcpy (typename, token_buffer);
+	  typename = xstrdup (token_buffer);
 	  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;
-	  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)
 	{
@@ -417,7 +509,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 (what_is == SNTERM && oldclass != SNTERM)
+	  if (what_is == nterm_sym && oldclass != nterm_sym)
 	    symbol->value = nvars++;
 
 	  if (typename)
@@ -436,7 +528,7 @@ parse_token_decl (int what_is, int what_is_not)
       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 ('%');
 	}
     }
@@ -444,7 +536,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)
@@ -460,43 +554,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                                    |
@@ -505,7 +562,6 @@ get_type_name (int n, symbol_list * rule)
 static void
 parse_type_decl (void)
 {
-  int k;
   char *name;
 
   if (lex () != TYPENAME)
@@ -515,9 +571,7 @@ parse_type_decl (void)
       return;
     }
 
-  k = strlen (token_buffer);
-  name = XCALLOC (char, k + 1);
-  strcpy (name, token_buffer);
+  name = xstrdup (token_buffer);
 
   for (;;)
     {
@@ -556,13 +610,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
-parse_assoc_decl (int assoc)
+parse_assoc_decl (associativity assoc)
 {
-  int k;
   char *name = NULL;
   int prev = 0;
 
@@ -582,11 +637,8 @@ parse_assoc_decl (int assoc)
 
       switch (t)
 	{
-
 	case TYPENAME:
-	  k = strlen (token_buffer);
-	  name = XCALLOC (char, k + 1);
-	  strcpy (name, token_buffer);
+	  name = xstrdup (token_buffer);
 	  break;
 
 	case COMMA:
@@ -597,9 +649,9 @@ parse_assoc_decl (int 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);
-	  symval->class = STOKEN;
+	  symval->class = token_sym;
 	  if (name)
 	    {			/* record the type, if one is specified */
 	      if (symval->type_name == NULL)
@@ -639,9 +691,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)
@@ -654,7 +708,7 @@ parse_union_decl (void)
 
   typed = 1;
 
-  if (!nolinesflag)
+  if (!no_lines_flag)
     fprintf (fattrs, "\n#line %d \"%s\"\n", lineno, infile);
   else
     fprintf (fattrs, "\n");
@@ -710,34 +764,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)
 {
-  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);
 
-  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);
 }
 
 
@@ -767,15 +809,13 @@ parse_thong_decl (void)
   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)
     {
-      k = strlen (token_buffer);
-      typename = XCALLOC (char, k + 1);
-      strcpy (typename, token_buffer);
+      typename = xstrdup (token_buffer);
       value_components_used = 1;
       token = lex ();		/* fetch first token */
     }
@@ -789,7 +829,7 @@ parse_thong_decl (void)
       skip_to_char ('%');
       return;
     }
-  symval->class = STOKEN;
+  symval->class = token_sym;
   symval->type_name = typename;
   symval->user_token_number = SALIAS;
   symbol = symval;
@@ -812,16 +852,18 @@ parse_thong_decl (void)
       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;
 
-  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 `%{ ... %}'  |
@@ -852,11 +894,11 @@ read_declarations (void)
 	      break;
 
 	    case TOKEN:
-	      parse_token_decl (STOKEN, SNTERM);
+	      parse_token_decl (token_sym, nterm_sym);
 	      break;
 
 	    case NTERM:
-	      parse_token_decl (SNTERM, STOKEN);
+	      parse_token_decl (nterm_sym, token_sym);
 	      break;
 
 	    case TYPE:
@@ -877,16 +919,17 @@ read_declarations (void)
 	    case THONG:
 	      parse_thong_decl ();
 	      break;
+
 	    case LEFT:
-	      parse_assoc_decl (LEFT_ASSOC);
+	      parse_assoc_decl (left_assoc);
 	      break;
 
 	    case RIGHT:
-	      parse_assoc_decl (RIGHT_ASSOC);
+	      parse_assoc_decl (right_assoc);
 	      break;
 
 	    case NONASSOC:
-	      parse_assoc_decl (NON_ASSOC);
+	      parse_assoc_decl (non_assoc);
 	      break;
 
 	    case SEMANTIC_PARSER:
@@ -913,7 +956,9 @@ read_declarations (void)
 	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 ('%');
 	}
     }
@@ -927,19 +972,17 @@ read_declarations (void)
 `-------------------------------------------------------------------*/
 
 static void
-copy_action (symbol_list * rule, int stack_offset)
+copy_action (symbol_list *rule, int stack_offset)
 {
   int c;
-  int n;
   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);
-  if (!nolinesflag)
+  if (!no_lines_flag)
     fprintf (faction, "#line %d \"%s\"\n", lineno, infile);
   putc ('{', faction);
 
@@ -976,57 +1019,7 @@ copy_action (symbol_list * rule, int stack_offset)
 	      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 '@':
@@ -1065,12 +1058,10 @@ copy_action (symbol_list * rule, int stack_offset)
 `-------------------------------------------------------------------*/
 
 static void
-copy_guard (symbol_list * rule, int stack_offset)
+copy_guard (symbol_list *rule, int stack_offset)
 {
   int c;
-  int n;
   int count;
-  char *type_name;
   int brace_flag = 0;
 
   /* offset is always 0 if parser has already popped the stack pointer */
@@ -1078,7 +1069,7 @@ copy_guard (symbol_list * rule, int stack_offset)
     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);
 
@@ -1125,56 +1116,7 @@ copy_guard (symbol_list * rule, int stack_offset)
 	  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 '@':
@@ -1234,7 +1176,7 @@ gensym (void)
 
   sprintf (token_buffer, "@%d", ++gensym_count);
   sym = getsym (token_buffer);
-  sym->class = SNTERM;
+  sym->class = nterm_sym;
   sym->value = nvars++;
   return sym;
 }
@@ -1261,9 +1203,7 @@ get_type (void)
       return t;
     }
 
-  k = strlen (token_buffer);
-  name = XCALLOC (char, k + 1);
-  strcpy (name, token_buffer);
+  name = xstrdup (token_buffer);
 
   for (;;)
     {
@@ -1313,9 +1253,11 @@ readgram (void)
   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;
 
@@ -1325,8 +1267,9 @@ readgram (void)
     {
       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;
 
@@ -1374,13 +1317,13 @@ readgram (void)
 
 	  /* mark the rule's lhs as a nonterminal if not already so.  */
 
-	  if (lhs->class == SUNKNOWN)
+	  if (lhs->class == unknown_sym)
 	    {
-	      lhs->class = SNTERM;
+	      lhs->class = nterm_sym;
 	      lhs->value = nvars;
 	      nvars++;
 	    }
-	  else if (lhs->class == STOKEN)
+	  else if (lhs->class == token_sym)
 	    complain (_("rule given for %s, which is a token"), lhs->tag);
 
 	  /* read the rhs of the rule.  */
@@ -1421,7 +1364,7 @@ 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 (actionflag)
+	      if (action_flag)
 		{
 		  bucket *sdummy;
 
@@ -1455,7 +1398,7 @@ readgram (void)
 		  p1->next = p;
 		  p1 = p;
 
-		  actionflag = 0;
+		  action_flag = 0;
 		}
 
 	      if (t == IDENTIFIER)
@@ -1469,7 +1412,7 @@ readgram (void)
 	      else		/* handle an action.  */
 		{
 		  copy_action (crule, rulelength);
-		  actionflag = 1;
+		  action_flag = 1;
 		  xactions++;	/* JF */
 		}
 	      rulelength++;
@@ -1490,9 +1433,7 @@ readgram (void)
 	  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 ();
@@ -1500,10 +1441,10 @@ readgram (void)
 	  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);
-	      actionflag = 1;
+	      action_flag = 1;
 	      xactions++;	/* -wjh */
 	      t = lex ();
 	    }
@@ -1534,12 +1475,12 @@ readgram (void)
 */
       else if (t == TOKEN)
 	{
-	  parse_token_decl (STOKEN, SNTERM);
+	  parse_token_decl (token_sym, nterm_sym);
 	  t = lex ();
 	}
       else if (t == NTERM)
 	{
-	  parse_token_decl (SNTERM, STOKEN);
+	  parse_token_decl (nterm_sym, token_sym);
 	  t = lex ();
 	}
       else if (t == TYPE)
@@ -1578,7 +1519,8 @@ readgram (void)
   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,
@@ -1592,12 +1534,12 @@ readgram (void)
   /* 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"),
-bp->tag);
-	bp->class = SNTERM;
+		  bp->tag);
+	bp->class = nterm_sym;
 	bp->value = nvars++;
       }
 
@@ -1644,7 +1586,7 @@ output_token_defines (FILE *file)
 	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);
@@ -1684,7 +1626,7 @@ packsymbols (void)
 
   for (bp = firstsymbol; bp; bp = bp->next)
     {
-      if (bp->class == SNTERM)
+      if (bp->class == nterm_sym)
 	{
 	  bp->value += ntokens;
 	}
@@ -1724,12 +1666,12 @@ packsymbols (void)
 	    continue;		/* do not do processing below for SALIASs */
 
 	}
-      else			/* bp->class == STOKEN */
+      else			/* bp->class == token_sym */
 	{
 	  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;
@@ -1772,17 +1714,17 @@ packsymbols (void)
 
   error_token_number = errtoken->value;
 
-  if (!noparserflag)
+  if (!no_parser_flag)
     output_token_defines (ftable);
 
-  if (startval->class == SUNKNOWN)
+  if (startval->class == unknown_sym)
     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;
 
-  if (definesflag)
+  if (defines_flag)
     {
       output_token_defines (fdefines);
 
@@ -1849,7 +1791,7 @@ packgram (void)
 	  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;
@@ -1914,7 +1856,6 @@ reader (void)
 
   semantic_parser = 0;
   pure_parser = 0;
-  yylsp_needed = 0;
 
   grammar = NULL;
 
@@ -1925,12 +1866,12 @@ reader (void)
   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.");
-  undeftoken->class = STOKEN;
+  undeftoken->class = token_sym;
   undeftoken->user_token_number = 2;
 
   /* Read the declaration section.  Copy %{ ... %} groups to FTABLE
@@ -1940,7 +1881,7 @@ reader (void)
   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 ();
@@ -1955,7 +1896,7 @@ reader (void)
     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.  */
@@ -1967,9 +1908,27 @@ reader (void)
   free_symtab ();
 }
 
+
 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);
 }