* src/gram.h (rule_number_t, RULE_NUMBER_MAX, int_of_rule_number)

(item_number_of_rule_number, rule_number_of_item_number): New.
* src/LR0.c, src/closure.c, src/derives.c, src/derives.h,
* src/gram.c, src/lalr.c, src/nullable.c, src/output.c, src/print.c,
* src/print_graph.c, src/reader.c, src/reduce.c, src/reduce.h:
Propagate their use.
Much remains to be done, in particular wrt `shorts' from types.h.

ChangeLog

@@ -1,3 +1,14 @@
+2002-06-30  Akim Demaille  <akim@epita.fr>
+
+	* src/gram.h (rule_number_t, RULE_NUMBER_MAX, int_of_rule_number)
+	(item_number_of_rule_number, rule_number_of_item_number): New.
+	* src/LR0.c, src/closure.c, src/derives.c, src/derives.h,
+	* src/gram.c, src/lalr.c, src/nullable.c, src/output.c, src/print.c,
+	* src/print_graph.c, src/reader.c, src/reduce.c, src/reduce.h:
+	Propagate their use.
+	Much remains to be done, in particular wrt `shorts' from types.h.
+
+	
 2002-06-30  Akim Demaille  <akim@epita.fr>
 
 	* src/symtab.c (symbol_new): Initialize the `printer' member.

src/LR0.c

@@ -74,7 +74,8 @@ static item_number_t *kernel_items = NULL;
 static void
 allocate_itemsets (void)
 {
-  int i, r;
+  symbol_number_t i;
+  rule_number_t r;
   item_number_t *rhsp;
 
   /* Count the number of occurrences of all the symbols in RITEMS.

src/closure.c

@@ -87,18 +87,19 @@ print_firsts (void)
 static void
 print_fderives (void)
 {
-  int i, j;
+  int i;
+  rule_number_t r;
 
   fprintf (stderr, "FDERIVES\n");
   for (i = ntokens; i < nsyms; i++)
     {
       fprintf (stderr, "\t%s derives\n", symbol_tag_get (symbols[i]));
-      for (j = 0; j < nrules + 1; j++)
+      for (r = 0; r < nrules + 1; r++)
-	if (bitset_test (FDERIVES (i), j))
+	if (bitset_test (FDERIVES (i), r))
 	  {
-	    item_number_t *rhsp;
+	    item_number_t *rhsp = NULL;
-	    fprintf (stderr, "\t\t%d:", j - 1);
+	    fprintf (stderr, "\t\t%d:", r - 1);
-	    for (rhsp = rules[j].rhs; *rhsp >= 0; ++rhsp)
+	    for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
 	      fprintf (stderr, " %s", symbol_tag_get (symbols[*rhsp]));
 	    fputc ('\n', stderr);
 	  }
@@ -120,7 +121,7 @@ print_fderives (void)
 static void
 set_firsts (void)
 {
-  int i, j;
+  symbol_number_t i, j;
 
   firsts = bitsetv_create (nvars, nvars, BITSET_FIXED);
 
@@ -155,7 +156,8 @@ set_firsts (void)
 static void
 set_fderives (void)
 {
-  int i, j, k;
+  symbol_number_t i, j;
+  rule_number_t k;
 
   fderives = bitsetv_create (nvars, nrules + 1, BITSET_FIXED);
 
@@ -194,7 +196,7 @@ closure (item_number_t *core, int n)
   int c;
 
   /* A bit index over RULESET. */
-  int ruleno;
+  rule_number_t ruleno;
 
   if (trace_flag)
     print_closure ("input", core, n);

src/derives.c

@@ -1,5 +1,5 @@
 /* Match rules with nonterminals for bison,
-   Copyright 1984, 1989, 2000, 2001  Free Software Foundation, Inc.
+   Copyright 1984, 1989, 2000, 2001, 2002  Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -27,7 +27,7 @@
 #include "gram.h"
 #include "derives.h"
 
-short **derives = NULL;
+rule_number_t **derives = NULL;
 
 static void
 print_derives (void)
@@ -38,15 +38,16 @@ print_derives (void)
 
   for (i = ntokens; i < nsyms; i++)
     {
-      short *sp;
+      rule_number_t *rp;
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
-      for (sp = derives[i]; *sp > 0; sp++)
+      for (rp = derives[i]; *rp > 0; rp++)
 	{
 	  item_number_t *rhsp;
-	  fprintf (stderr, "\t\t%d:", *sp);
+	  fprintf (stderr, "\t\t%d:", *rp);
-	  for (rhsp = rules[*sp].rhs; *rhsp >= 0; ++rhsp)
+	  for (rhsp = rules[*rp].rhs; *rhsp >= 0; ++rhsp)
-	    fprintf (stderr, " %s", symbols[*rhsp]->tag);
+	    fprintf (stderr, " %s", symbol_tag_get (symbols[*rhsp]));
-	  fprintf (stderr, " (rule %d)\n", -*rhsp - 1);
+	  fprintf (stderr, " (rule %d)\n",
+		   rule_number_of_item_number (*rhsp) - 1);
 	}
     }
 
@@ -57,9 +58,10 @@ print_derives (void)
 void
 set_derives (void)
 {
-  int i;
+  symbol_number_t i;
+  rule_number_t r;
   shorts *p;
-  short *q;
+  rule_number_t *q;
   shorts **dset;
   shorts *delts;
 
@@ -67,17 +69,17 @@ set_derives (void)
   delts = XCALLOC (shorts, nrules + 1);
 
   p = delts;
-  for (i = nrules; i > 0; i--)
+  for (r = nrules; r > 0; r--)
     {
-      symbol_number_t lhs = rules[i].lhs->number;
+      symbol_number_t lhs = rules[r].lhs->number;
       p->next = dset[lhs];
-      p->value = i;
+      p->value = r;
       dset[lhs] = p;
       p++;
     }
 
-  derives = XCALLOC (short *, nvars) - ntokens;
+  derives = XCALLOC (rule_number_t *, nvars) - ntokens;
-  q = XCALLOC (short, nvars + nrules);
+  q = XCALLOC (short, nvars + int_of_rule_number (nrules));
 
   for (i = ntokens; i < nsyms; i++)
     {

src/derives.h

@@ -23,7 +23,7 @@
 
 /* DERIVES[SYMBOL - NTOKENS] points to a vector of the number of the
    rules that SYMBOL derives, terminated with -1.  */
-extern short **derives;
+extern rule_number_t **derives;
 
 /* Compute DERIVES.  */
 

src/gram.c

@@ -32,7 +32,7 @@ item_number_t *ritem = NULL;
 unsigned int nritems = 0;
 
 rule_t *rules = NULL;
-int nrules = 0;
+rule_number_t nrules = 0;
 
 symbol_t **symbols = NULL;
 int nsyms = 0;
@@ -121,11 +121,11 @@ size_t
 ritem_longest_rhs (void)
 {
   int max = 0;
-  int i;
+  rule_number_t r;
 
-  for (i = 1; i < nrules + 1; ++i)
+  for (r = 1; r < nrules + 1; ++r)
     {
-      int length = rule_rhs_length (&rules[i]);
+      int length = rule_rhs_length (&rules[r]);
       if (length > max)
 	max = length;
     }
@@ -148,7 +148,7 @@ blanks_print (unsigned n, FILE *out)
 
 void
 grammar_rules_partial_print (FILE *out, const char *title,
-			     int begin, int end)
+			     rule_number_t begin, rule_number_t end)
 {
   int r;
   symbol_t *last_lhs = NULL;
@@ -195,49 +195,62 @@ grammar_rules_print (FILE *out)
 void
 grammar_dump (FILE *out, const char *title)
 {
-  int i;
-  item_number_t *r;
-
   fprintf (out, "%s\n\n", title);
   fprintf (out,
 	   "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
 	   ntokens, nvars, nsyms, nrules, nritems);
+
+
   fprintf (out, "Variables\n---------\n\n");
-  fprintf (out, "Value  Sprec  Sassoc  Tag\n");
+  {
-  for (i = ntokens; i < nsyms; i++)
+    symbol_number_t i;
-    fprintf (out, "%5d  %5d   %5d  %s\n",
+    fprintf (out, "Value  Sprec  Sassoc  Tag\n");
-	     i,
+
-	     symbols[i]->prec, symbols[i]->assoc,
+    for (i = ntokens; i < nsyms; i++)
-	     symbol_tag_get (symbols[i]));
+      fprintf (out, "%5d  %5d   %5d  %s\n",
-  fprintf (out, "\n\n");
+	       i,
+	       symbols[i]->prec, symbols[i]->assoc,
+	       symbol_tag_get (symbols[i]));
+    fprintf (out, "\n\n");
+  }
+
   fprintf (out, "Rules\n-----\n\n");
-  fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
+  {
-  for (i = 1; i < nrules + nuseless_productions + 1; i++)
+    rule_number_t i;
-    {
+    fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
-      int rhs_count = 0;
+    for (i = 1; i < nrules + nuseless_productions + 1; i++)
-      /* Find the last RHS index in ritems. */
+      {
-      for (r = rules[i].rhs; *r >= 0; ++r)
+	rule_t *rule = &rules[i];
-	++rhs_count;
+	item_number_t *r = NULL;
-      fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
+  	int rhs_count = 0;
-	       i - 1,
+	/* Find the last RHS index in ritems. */
-	       rules[i].prec ? rules[i].prec->prec : 0,
+	for (r = rule->rhs; *r >= 0; ++r)
-	       rules[i].prec ? rules[i].prec->assoc : 0,
+	  ++rhs_count;
-	       rules[i].useful,
+	fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
-	       rules[i].rhs - ritem,
+		 i - 1,
-	       rules[i].rhs - ritem + rhs_count - 1,
+		 rule->prec ? rule->prec->prec : 0,
-	       rules[i].lhs->number);
+		 rule->prec ? rule->prec->assoc : 0,
-      /* Dumped the RHS. */
+		 rule->useful,
-      for (r = rules[i].rhs; *r >= 0; r++)
+		 rule->rhs - ritem,
-	fprintf (out, " %3d", *r);
+		 rule->rhs - ritem + rhs_count - 1,
-      fprintf (out, "  [%d]\n", -(*r) - 1);
+		 rule->lhs->number);
-    }
+	/* Dumped the RHS. */
+	for (r = rule->rhs; *r >= 0; r++)
+	  fprintf (out, " %3d", *r);
+	fprintf (out, "  [%d]\n", -(*r) - 1);
+      }
+  }
   fprintf (out, "\n\n");
+
   fprintf (out, "Rules interpreted\n-----------------\n\n");
-  for (i = 1; i < nrules + nuseless_productions + 1; i++)
+  {
-    {
+    rule_number_t r;
-      fprintf (out, "%-5d  ", i);
+    for (r = 1; r < nrules + nuseless_productions + 1; r++)
-      rule_print (&rules[i], out);
+      {
-    }
+	fprintf (out, "%-5d  ", r);
+	rule_print (&rules[r], out);
+      }
+  }
   fprintf (out, "\n\n");
 }
 

src/gram.h

@@ -107,19 +107,19 @@
 # define ISTOKEN(s)	((s) < ntokens)
 # define ISVAR(s)	((s) >= ntokens)
 
-extern int nrules;
 extern int nsyms;
 extern int ntokens;
 extern int nvars;
 
-# define ITEM_NUMBER_MAX INT_MAX
 typedef int item_number_t;
+# define ITEM_NUMBER_MAX ((item_number_t) INT_MAX)
 extern item_number_t *ritem;
 extern unsigned int nritems;
 
-/* There is weird relationship between item_number_t and
+/* There is weird relationship between OT1H item_number_t and OTOH
-   symbol_number_t: we store symbol_number_t in item_number_t, but in
+   symbol_number_t and rule_number_t: we store the latter in
-   the latter we also store, as negative numbers, the rule numbers.
+   item_number_t.  symbol_number_t are stored as are, while
+   the negation of rule_number_t are stored.
 
    Therefore, an symbol_number_t must be a valid item_number_t, and we
    sometimes have to perform the converse transformation.  */
@@ -128,16 +128,28 @@ extern unsigned int nritems;
 
 extern symbol_number_t start_symbol;
 
+/* Rules numbers. */
+typedef short rule_number_t;
+# define RULE_NUMBER_MAX ((rule_number_t) SHRT_MAX)
+extern rule_number_t nrules;
+# define int_of_rule_number(RNum) ((int) (RNum))
+# define item_number_of_rule_number(RNum) ((item_number_t) (- RNum))
+# define rule_number_of_item_number(INum) ((rule_number_t) (- INum))
+
+
+/*--------.
+| Rules.  |
+`--------*/
 
 typedef struct rule_s
 {
   /* The number of the rule in the source.  It is usually the index in
      RULES too, except if there are useless rules.  */
-  short user_number;
+  rule_number_t user_number;
 
   /* The index in RULES.  Usually the rule number in the source,
      except if some rules are useless.  */
-  short number;
+  rule_number_t number;
 
   symbol_t *lhs;
   item_number_t *rhs;
@@ -199,7 +211,8 @@ size_t ritem_longest_rhs PARAMS ((void));
 /* Print the grammar's rules numbers from BEGIN (inclusive) to END
    (exclusive) on OUT under TITLE.  */
 void grammar_rules_partial_print PARAMS ((FILE *out, const char *title,
-					  int begin, int end));
+					  rule_number_t begin,
+					  rule_number_t end));
 
 /* Print the grammar's rules on OUT.  */
 void grammar_rules_print PARAMS ((FILE *out));

src/lalr.c

@@ -291,7 +291,7 @@ initialize_F (void)
 
 
 static void
-add_lookback_edge (state_t *state, int ruleno, int gotono)
+add_lookback_edge (state_t *state, rule_number_t ruleno, int gotono)
 {
   int i;
   shorts *sp;
@@ -408,7 +408,7 @@ build_relations (void)
     {
       int nedges = 0;
       symbol_number_t symbol1 = states[to_state[i]]->accessing_symbol;
-      short *rulep;
+      rule_number_t *rulep;
 
       for (rulep = derives[symbol1]; *rulep > 0; rulep++)
 	{

src/nullable.c

@@ -46,7 +46,7 @@ nullable_print (FILE *out)
 void
 set_nullable (void)
 {
-  int ruleno;
+  rule_number_t ruleno;
   symbol_number_t *s1;
   symbol_number_t *s2;
   shorts *p;
@@ -71,19 +71,20 @@ set_nullable (void)
   for (ruleno = 1; ruleno < nrules + 1; ++ruleno)
     if (rules[ruleno].useful)
       {
-	if (rules[ruleno].rhs[0] >= 0)
+	rule_t *rule = &rules[ruleno];
+	if (rule->rhs[0] >= 0)
 	  {
 	    /* This rule has a non empty RHS. */
-	    item_number_t *r;
+	    item_number_t *r = NULL;
 	    int any_tokens = 0;
-	    for (r = rules[ruleno].rhs; *r >= 0; ++r)
+	    for (r = rule->rhs; *r >= 0; ++r)
 	      if (ISTOKEN (*r))
 		any_tokens = 1;
 
 	    /* This rule has only nonterminals: schedule it for the second
 	       pass.  */
 	    if (!any_tokens)
-	      for (r = rules[ruleno].rhs; *r >= 0; ++r)
+	      for (r = rule->rhs; *r >= 0; ++r)
 		{
 		  rcount[ruleno]++;
 		  p->next = rsets[*r];
@@ -95,11 +96,11 @@ set_nullable (void)
 	else
 	  {
 	    /* This rule has an empty RHS. */
-	    assert (rules[ruleno].rhs[0] == -ruleno);
+	    assert (rule_number_of_item_number (rule->rhs[0]) == ruleno);
-	    if (rules[ruleno].useful && !nullable[rules[ruleno].lhs->number])
+	    if (rule->useful && !nullable[rule->lhs->number])
 	      {
-		nullable[rules[ruleno].lhs->number] = 1;
+		nullable[rule->lhs->number] = 1;
-		*s2++ = rules[ruleno].lhs->number;
+		*s2++ = rule->lhs->number;
 	      }
 	  }
       }

src/output.c

@@ -294,7 +294,7 @@ prepare_tokens (void)
 static void
 prepare_rules (void)
 {
-  int r;
+  rule_number_t r;
   unsigned int i = 0;
   item_number_t *rhs = XMALLOC (item_number_t, nritems);
   unsigned int *prhs = XMALLOC (unsigned int, nrules + 1);
@@ -306,7 +306,7 @@ prepare_rules (void)
 
   for (r = 1; r < nrules + 1; ++r)
     {
-      item_number_t *rhsp;
+      item_number_t *rhsp = NULL;
       /* Index of rule R in RHS. */
       prhs[r] = i;
       /* RHS of the rule R. */
@@ -428,7 +428,7 @@ static int
 action_row (state_t *state)
 {
   int i;
-  int default_rule = 0;
+  rule_number_t default_rule = 0;
   reductions_t *redp = state->reductions;
   shifts_t *shiftp = state->shifts;
   errs_t *errp = state->errs;
@@ -504,8 +504,8 @@ action_row (state_t *state)
 	  for (i = 0; i < state->nlookaheads; i++)
 	    {
 	      int count = 0;
-	      int rule = -state->lookaheads_rule[i]->number;
+	      rule_number_t rule = -state->lookaheads_rule[i]->number;
-	      int j;
+	      symbol_number_t j;
 
 	      for (j = 0; j < ntokens; j++)
 		if (actrow[j] == rule)
@@ -638,21 +638,21 @@ token_actions (void)
 void
 actions_output (FILE *out)
 {
-  int rule;
+  rule_number_t r;
 
   fputs ("m4_define([b4_actions], \n[[", out);
-  for (rule = 1; rule < nrules + 1; ++rule)
+  for (r = 1; r < nrules + 1; ++r)
-    if (rules[rule].action)
+    if (rules[r].action)
       {
-	fprintf (out, "  case %d:\n", rule);
+	fprintf (out, "  case %d:\n", r);
 
 	if (!no_lines_flag)
 	  fprintf (out, muscle_find ("linef"),
-		   rules[rule].action_location.first_line,
+		   rules[r].action_location.first_line,
 		   quotearg_style (c_quoting_style,
 				   muscle_find ("filename")));
 	fprintf (out, "    %s\n    break;\n\n",
-		 rules[rule].action);
+		 rules[r].action);
       }
   fputs ("]])\n\n", out);
 }

src/print.c

@@ -354,7 +354,6 @@ static void
 print_grammar (FILE *out)
 {
   symbol_number_t i;
-  item_number_t *rule;
   char buffer[90];
   int column = 0;
 
@@ -366,7 +365,9 @@ print_grammar (FILE *out)
     if (token_translations[i] != undeftoken->number)
       {
 	const char *tag = symbol_tag_get (symbols[token_translations[i]]);
-	int r;
+	rule_number_t r;
+	item_number_t *rhsp;
+
 	buffer[0] = 0;
 	column = strlen (tag);
 	fputs (tag, out);
@@ -374,8 +375,8 @@ print_grammar (FILE *out)
 	sprintf (buffer, " (%d)", i);
 
 	for (r = 1; r < nrules + 1; r++)
-	  for (rule = rules[r].rhs; *rule >= 0; rule++)
+	  for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
-	    if (item_number_as_symbol_number (*rule) == token_translations[i])
+	    if (item_number_as_symbol_number (*rhsp) == token_translations[i])
 	      {
 		END_TEST (65);
 		sprintf (buffer + strlen (buffer), " %d", r - 1);
@@ -390,15 +391,16 @@ print_grammar (FILE *out)
   for (i = ntokens; i < nsyms; i++)
     {
       int left_count = 0, right_count = 0;
-      int r;
+      rule_number_t r;
       const char *tag = symbol_tag_get (symbols[i]);
 
       for (r = 1; r < nrules + 1; r++)
 	{
+	  item_number_t *rhsp;
 	  if (rules[r].lhs->number == i)
 	    left_count++;
-	  for (rule = rules[r].rhs; *rule >= 0; rule++)
+	  for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
-	    if (item_number_as_symbol_number (*rule) == i)
+	    if (item_number_as_symbol_number (*rhsp) == i)
 	      {
 		right_count++;
 		break;
@@ -432,8 +434,9 @@ print_grammar (FILE *out)
 	  sprintf (buffer + strlen (buffer), _(" on right:"));
 	  for (r = 1; r < nrules + 1; r++)
 	    {
-	      for (rule = rules[r].rhs; *rule >= 0; rule++)
+	      item_number_t *rhsp;
-		if (item_number_as_symbol_number (*rule) == i)
+	      for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
+		if (item_number_as_symbol_number (*rhsp) == i)
 		  {
 		    END_TEST (65);
 		    sprintf (buffer + strlen (buffer), " %d", r - 1);

src/print_graph.c

@@ -63,14 +63,14 @@ print_core (struct obstack *oout, state_t *state)
     {
       item_number_t *sp;
       item_number_t *sp1;
-      int rule;
+      rule_number_t rule;
 
       sp1 = sp = ritem + sitems[i];
 
       while (*sp >= 0)
 	sp++;
 
-      rule = -(*sp);
+      rule = rule_number_of_item_number (*sp);
 
       if (i)
 	obstack_1grow (oout, '\n');

src/reader.c

@@ -403,17 +403,13 @@ grammar_current_rule_action_append (const char *action, location_t location)
 static void
 packgram (void)
 {
-  unsigned int itemno;
+  unsigned int itemno = 0;
-  int ruleno;
+  rule_number_t ruleno = 1;
-  symbol_list_t *p;
+  symbol_list_t *p = grammar;
 
   ritem = XCALLOC (item_number_t, nritems);
   rules = XCALLOC (rule_t, nrules) - 1;
 
-  itemno = 0;
-  ruleno = 1;
-
-  p = grammar;
   while (p)
     {
       symbol_t *ruleprec = p->ruleprec;

src/reduce.c

@@ -50,10 +50,10 @@ static bitset V;
    `useless', but no warning should be issued).  */
 static bitset V1;
 
-static int nuseful_productions;
+static rule_number_t nuseful_productions;
-int nuseless_productions;
+rule_number_t nuseless_productions;
 static int nuseful_nonterminals;
-int nuseless_nonterminals;
+symbol_number_t nuseless_nonterminals;
 
 /*-------------------------------------------------------------------.
 | Another way to do this would be with a set for each production and |
@@ -62,16 +62,15 @@ int nuseless_nonterminals;
 `-------------------------------------------------------------------*/
 
 static bool
-useful_production (int i, bitset N0)
+useful_production (rule_number_t r, bitset N0)
 {
-  item_number_t *r;
+  item_number_t *rhsp;
-  short n;
 
   /* A production is useful if all of the nonterminals in its appear
      in the set of useful nonterminals.  */
 
-  for (r = rules[i].rhs; *r >= 0; r++)
+  for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
-    if (ISVAR (n = *r) && !bitset_test (N0, n - ntokens))
+    if (ISVAR (*rhsp) && !bitset_test (N0, *rhsp - ntokens))
       return FALSE;
   return TRUE;
 }
@@ -85,7 +84,7 @@ static void
 useless_nonterminals (void)
 {
   bitset Np, Ns;
-  int i;
+  rule_number_t r;
 
   /* N is set as built.  Np is set being built this iteration. P is
      set of all productions which have a RHS all in N.  */
@@ -112,12 +111,12 @@ useless_nonterminals (void)
   while (1)
     {
       bitset_copy (Np, N);
-      for (i = 1; i < nrules + 1; i++)
+      for (r = 1; r < nrules + 1; r++)
-	if (!bitset_test (P, i)
+	if (!bitset_test (P, r)
-	    && useful_production (i, N))
+	    && useful_production (r, N))
 	  {
-	    bitset_set (Np, rules[i].lhs->number - ntokens);
+	    bitset_set (Np, rules[r].lhs->number - ntokens);
-	    bitset_set (P, i);
+	    bitset_set (P, r);
 	  }
       if (bitset_equal_p (N, Np))
 	break;
@@ -134,9 +133,6 @@ static void
 inaccessable_symbols (void)
 {
   bitset Vp, Vs, Pp;
-  int i;
-  short t;
-  item_number_t *r;
 
   /* Find out which productions are reachable and which symbols are
      used.  Starting with an empty set of productions and a set of
@@ -171,17 +167,19 @@ inaccessable_symbols (void)
 
       while (1)
 	{
+	  rule_number_t r;
 	  bitset_copy (Vp, V);
-	  for (i = 1; i < nrules + 1; i++)
+	  for (r = 1; r < nrules + 1; r++)
 	    {
-	      if (!bitset_test (Pp, i)
+	      if (!bitset_test (Pp, r)
-		  && bitset_test (P, i)
+		  && bitset_test (P, r)
-		  && bitset_test (V, rules[i].lhs->number))
+		  && bitset_test (V, rules[r].lhs->number))
 		{
-		  for (r = rules[i].rhs; *r >= 0; r++)
+		  item_number_t *rhsp;
-		    if (ISTOKEN (t = *r) || bitset_test (N, t - ntokens))
+		  for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
-		      bitset_set (Vp, t);
+		    if (ISTOKEN (*rhsp) || bitset_test (N, *rhsp - ntokens))
-		  bitset_set (Pp, i);
+		      bitset_set (Vp, *rhsp);
+		  bitset_set (Pp, r);
 		}
 	    }
 	  if (bitset_equal_p (V, Vp))
@@ -207,15 +205,21 @@ inaccessable_symbols (void)
   nuseless_productions = nrules - nuseful_productions;
 
   nuseful_nonterminals = 0;
-  for (i = ntokens; i < nsyms; i++)
+  {
-    if (bitset_test (V, i))
+    symbol_number_t i;
-      nuseful_nonterminals++;
+    for (i = ntokens; i < nsyms; i++)
+      if (bitset_test (V, i))
+	nuseful_nonterminals++;
+  }
   nuseless_nonterminals = nvars - nuseful_nonterminals;
 
   /* A token that was used in %prec should not be warned about.  */
-  for (i = 1; i < nrules + 1; i++)
+  {
-    if (rules[i].precsym != 0)
+    rule_number_t i;
-      bitset_set (V1, rules[i].precsym->number);
+    for (i = 1; i < nrules + 1; i++)
+      if (rules[i].precsym != 0)
+	bitset_set (V1, rules[i].precsym->number);
+  }
 }
 
 
@@ -229,7 +233,7 @@ reduce_grammar_tables (void)
 {
   /* Report and flag useless productions.  */
   {
-    int r;
+    rule_number_t r;
     for (r = 1; r < nrules + 1; r++)
       {
 	rules[r].useful = bitset_test (P, r);
@@ -248,20 +252,20 @@ reduce_grammar_tables (void)
     int useful = 1;
     int useless = nrules + 1 - nuseless_productions;
     rule_t *rules_sorted = XMALLOC (rule_t, nrules + 1) - 1;
-    int i;
+    rule_number_t r;
-    for (i = 1; i < nrules + 1; ++i)
+    for (r = 1; r < nrules + 1; ++r)
-      rules_sorted[rules[i].useful ? useful++ : useless++] = rules[i];
+      rules_sorted[rules[r].useful ? useful++ : useless++] = rules[r];
     free (rules + 1);
     rules = rules_sorted;
 
     /* Renumber the rules markers in RITEMS.  */
-    for (i = 1; i < nrules + 1; ++i)
+    for (r = 1; r < nrules + 1; ++r)
       {
-	item_number_t *rhsp = rules[i].rhs;
+	item_number_t *rhsp = rules[r].rhs;
 	for (/* Nothing. */; *rhsp >= 0; ++rhsp)
 	  /* Nothing. */;
-	*rhsp = -i;
+	*rhsp = item_number_of_rule_number (r);
-	rules[i].number = i;
+	rules[r].number = r;
       }
     nrules -= nuseless_productions;
   }
@@ -321,7 +325,7 @@ nonterminals_reduce (void)
   }
 
   {
-    int r;
+    rule_number_t r;
     for (r = 1; r < nrules + 1; ++r)
       {
 	item_number_t *rhsp;

src/reduce.h

@@ -25,6 +25,6 @@ void reduce_grammar PARAMS ((void));
 void reduce_output PARAMS ((FILE *out));
 void reduce_free PARAMS ((void));
 
-extern int nuseless_nonterminals;
+extern symbol_number_t nuseless_nonterminals;
-extern int nuseless_productions;
+extern rule_number_t nuseless_productions;
 #endif /* !REDUCE_H_ */