* src/conflicts.c (log_resolution, flush_shift)

(resolve_sr_conflict, set_conflicts, solve_conflicts)
(count_sr_conflicts, count_rr_conflicts, conflicts_output)
(conflicts_print, print_reductions): Use a state_t instead of an
integer when referring to a state.
As much as possible, depend upon nlookaheads, instead of the
`lookaheadsp' member of the following state (since lookaheads of
successive states are successive, the difference between state n + 1
and n served as the number of lookaheads for state n).
* src/lalr.c (add_lookback_edge): Likewise.
* src/print.c (print_core, print_actions, print_state)
(print_results): Likewise.
* src/print_graph.c (print_core, print_actions, print_state)
(print_graph): Likewise.
* src/conflicts.h: Adjust.

ChangeLog

@@ -1,3 +1,21 @@
+2001-12-27  Akim Demaille  <akim@epita.fr>
+
+	* src/conflicts.c (log_resolution, flush_shift)
+	(resolve_sr_conflict, set_conflicts, solve_conflicts)
+	(count_sr_conflicts, count_rr_conflicts, conflicts_output)
+	(conflicts_print, print_reductions): Use a state_t instead of an
+	integer when referring to a state.
+	As much as possible, depend upon nlookaheads, instead of the
+	`lookaheadsp' member of the following state (since lookaheads of
+	successive states are successive, the difference between state n + 1
+	and n served as the number of lookaheads for state n).
+	* src/lalr.c (add_lookback_edge): Likewise.
+	* src/print.c (print_core, print_actions, print_state)
+	(print_results): Likewise.
+	* src/print_graph.c (print_core, print_actions, print_state)
+	(print_graph): Likewise.
+	* src/conflicts.h: Adjust.
+
 2001-12-27  Akim Demaille  <akim@epita.fr>
 
 	* src/bison.hairy: Formatting/comment changes.

src/conflicts.c

@@ -38,13 +38,13 @@ static unsigned *lookaheadset = NULL;
 
 
 static inline void
-log_resolution (int state, int LAno, int token, char *resolution)
+log_resolution (state_t *state, int LAno, int token, char *resolution)
 {
   if (verbose_flag)
     obstack_fgrow4 (&output_obstack,
 		    _("\
 Conflict in state %d between rule %d and token %s resolved as %s.\n"),
-		    state, LAruleno[LAno], tags[token], resolution);
+		    state->number, LAruleno[LAno], tags[token], resolution);
 }
 
 
@@ -55,9 +55,9 @@ Conflict in state %d between rule %d and token %s resolved as %s.\n"),
 `------------------------------------------------------------------*/
 
 static void
-flush_shift (int state, int token)
+flush_shift (state_t *state, int token)
 {
-  shifts *shiftp = state_table[state]->shifts;
+  shifts *shiftp = state->shifts;
   int i;
 
   RESETBIT (lookaheadset, token);
@@ -88,7 +88,7 @@ flush_reduce (int lookahead, int token)
 `------------------------------------------------------------------*/
 
 static void
-resolve_sr_conflict (int state, int lookahead)
+resolve_sr_conflict (state_t *state, int lookahead)
 {
   int i;
   /* find the rule to reduce by to get precedence of reduction  */
@@ -146,25 +146,25 @@ resolve_sr_conflict (int state, int lookahead)
   /* Some tokens have been explicitly made errors.  Allocate a
      permanent errs structure for this state, to record them.  */
   i = (char *) errtokens - (char *) errp;
-  state_table[state]->errs = ERRS_ALLOC (i + 1);
+  state->errs = ERRS_ALLOC (i + 1);
-  memcpy (state_table[state]->errs, errp, i);
+  memcpy (state->errs, errp, i);
   free (errp);
 }
 
 
 static void
-set_conflicts (int state)
+set_conflicts (state_t *state)
 {
   int i, j;
   shifts *shiftp;
 
-  if (state_table[state]->consistent)
+  if (state->consistent)
     return;
 
   for (i = 0; i < tokensetsize; i++)
     lookaheadset[i] = 0;
 
-  shiftp = state_table[state]->shifts;
+  shiftp = state->shifts;
   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, i));
@@ -172,30 +172,26 @@ set_conflicts (int state)
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
      precedence */
-  for (i = state_table[state]->lookaheadsp;
+  for (i = 0; i < state->nlookaheads; ++i)
-       i < state_table[state + 1]->lookaheadsp;
+    if (rule_table[LAruleno[state->lookaheadsp + i]].prec)
-       ++i)
-    if (rule_table[LAruleno[i]].prec)
       for (j = 0; j < tokensetsize; ++j)
-	if (LA (i)[j] & lookaheadset[j])
+	if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
 	  {
-	    resolve_sr_conflict (state, i);
+	    resolve_sr_conflict (state, state->lookaheadsp + i);
 	    break;
 	  }
 
 
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.  */
-  for (i = state_table[state]->lookaheadsp;
+  for (i = 0; i < state->nlookaheads; ++i)
-       i < state_table[state + 1]->lookaheadsp;
-       ++i)
     {
       for (j = 0; j < tokensetsize; ++j)
-	if (LA (i)[j] & lookaheadset[j])
+	if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
-	  conflicts[state] = 1;
+	  conflicts[state->number] = 1;
 
       for (j = 0; j < tokensetsize; ++j)
-	lookaheadset[j] |= LA (i)[j];
+	lookaheadset[j] |= LA (state->lookaheadsp + i)[j];
     }
 }
 
@@ -209,7 +205,7 @@ solve_conflicts (void)
   lookaheadset = XCALLOC (unsigned, tokensetsize);
 
   for (i = 0; i < nstates; i++)
-    set_conflicts (i);
+    set_conflicts (state_table[i]);
 }
 
 
@@ -218,11 +214,11 @@ solve_conflicts (void)
 `---------------------------------------------*/
 
 static int
-count_sr_conflicts (int state)
+count_sr_conflicts (state_t *state)
 {
   int i, k;
   int src_count = 0;
-  shifts *shiftp = state_table[state]->shifts;
+  shifts *shiftp = state->shifts;
 
   if (!shiftp)
     return 0;
@@ -237,11 +233,9 @@ count_sr_conflicts (int state)
     if (!SHIFT_IS_DISABLED (shiftp, i))
       SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
 
-  for (i = state_table[state]->lookaheadsp;
+  for (i = 0; i < state->nlookaheads; ++i)
-       i < state_table[state + 1]->lookaheadsp;
-       ++i)
     for (k = 0; k < tokensetsize; ++k)
-      lookaheadset[k] |= LA (i)[k];
+      lookaheadset[k] |= LA (state->lookaheadsp + i)[k];
 
   for (k = 0; k < tokensetsize; ++k)
     lookaheadset[k] &= shiftset[k];
@@ -259,23 +253,20 @@ count_sr_conflicts (int state)
 `----------------------------------------------*/
 
 static int
-count_rr_conflicts (int state)
+count_rr_conflicts (state_t *state)
 {
   int i;
   int rrc_count = 0;
 
-  int m = state_table[state]->lookaheadsp;
+  if (state->nlookaheads < 2)
-  int n = state_table[state + 1]->lookaheadsp;
-
-  if (n - m < 2)
     return 0;
 
   for (i = 0; i < ntokens; i++)
     {
       int count = 0;
       int j;
-      for (j = m; j < n; j++)
+      for (j = 0; j < state->nlookaheads; ++j)
-	if (BITISSET (LA (m), j))
+	if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j))
 	  count++;
 
       if (count >= 2)
@@ -337,8 +328,8 @@ conflicts_output (FILE *out)
     if (conflicts[i])
       {
 	fprintf (out, _("State %d contains "), i);
-	fputs (conflict_report (count_sr_conflicts (i),
+	fputs (conflict_report (count_sr_conflicts (state_table[i]),
-				count_rr_conflicts (i)), out);
+				count_rr_conflicts (state_table[i])), out);
 	printed_sth = TRUE;
       }
   if (printed_sth)
@@ -367,8 +358,8 @@ conflicts_print (void)
   for (i = 0; i < nstates; i++)
     if (conflicts[i])
       {
-	src_total += count_sr_conflicts (i);
+	src_total += count_sr_conflicts (state_table[i]);
-	rrc_total += count_rr_conflicts (i);
+	rrc_total += count_rr_conflicts (state_table[i]);
       }
 
   src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);
@@ -410,13 +401,11 @@ conflicts_print (void)
 
 
 void
-print_reductions (FILE *out, int state)
+print_reductions (FILE *out, state_t *state)
 {
   int i;
-  int m = state_table[state]->lookaheadsp;
+  shifts *shiftp = state->shifts;
-  int n = state_table[state + 1]->lookaheadsp;
+  errs *errp = state->errs;
-  shifts *shiftp = state_table[state]->shifts;
-  errs *errp = state_table[state]->errs;
   int nodefault = 0;
 
   for (i = 0; i < tokensetsize; i++)
@@ -437,13 +426,13 @@ print_reductions (FILE *out, int state)
       if (errp->errs[i])
 	SETBIT (shiftset, errp->errs[i]);
 
-  if (n - m == 1 && !nodefault)
+  if (state->nlookaheads == 1 && !nodefault)
     {
       int k;
-      int default_rule = LAruleno[m];
+      int default_rule = LAruleno[state->lookaheadsp];
 
       for (k = 0; k < tokensetsize; ++k)
-	lookaheadset[k] = LA (m)[k] & shiftset[k];
+	lookaheadset[k] = LA (state->lookaheadsp)[k] & shiftset[k];
 
       for (i = 0; i < ntokens; i++)
 	if (BITISSET (lookaheadset, i))
@@ -454,20 +443,20 @@ print_reductions (FILE *out, int state)
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
 	       default_rule, tags[rule_table[default_rule].lhs]);
     }
-  else if (n - m >= 1)
+  else if (state->nlookaheads >= 1)
     {
       int cmax = 0;
       int default_LA = -1;
       int default_rule = 0;
 
       if (!nodefault)
-	for (i = m; i < n; i++)
+	for (i = 0; i < state->nlookaheads; ++i)
 	  {
 	    int count = 0;
 	    int j, k;
 
 	    for (k = 0; k < tokensetsize; ++k)
-	      lookaheadset[k] = LA (i)[k] & ~shiftset[k];
+	      lookaheadset[k] = LA (state->lookaheadsp + i)[k] & ~shiftset[k];
 
 	    for (j = 0; j < ntokens; j++)
 	      if (BITISSET (lookaheadset, j))
@@ -476,8 +465,8 @@ print_reductions (FILE *out, int state)
 	    if (count > cmax)
 	      {
 		cmax = count;
-		default_LA = i;
+		default_LA = state->lookaheadsp + i;
-		default_rule = LAruleno[i];
+		default_rule = LAruleno[state->lookaheadsp + i];
 	      }
 
 	    for (k = 0; k < tokensetsize; ++k)
@@ -497,18 +486,18 @@ print_reductions (FILE *out, int state)
 	  int defaulted = 0;
 	  int count = BITISSET (shiftset, i);
 
-	  for (j = m; j < n; j++)
+	  for (j = 0; j < state->nlookaheads; ++j)
 	    {
-	      if (BITISSET (LA (j), i))
+	      if (BITISSET (LA (state->lookaheadsp + j), i))
 		{
 		  if (count == 0)
 		    {
-		      if (j != default_LA)
+		      if (state->lookaheadsp + j != default_LA)
 			fprintf (out,
 				 _("    %-4s\treduce using rule %d (%s)\n"),
 				 tags[i],
-				 LAruleno[j],
+				 LAruleno[state->lookaheadsp + j],
-				 tags[rule_table[LAruleno[j]].lhs]);
+				 tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs]);
 		      else
 			defaulted = 1;
 
@@ -526,8 +515,8 @@ print_reductions (FILE *out, int state)
 		      fprintf (out,
 			       _("    %-4s\t[reduce using rule %d (%s)]\n"),
 			       tags[i],
-			       LAruleno[j],
+			       LAruleno[state->lookaheadsp + j],
-			       tags[rule_table[LAruleno[j]].lhs]);
+			       tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs]);
 		    }
 		}
 	    }

src/conflicts.h

@@ -25,7 +25,7 @@
 void solve_conflicts PARAMS ((void));
 void conflicts_print PARAMS ((void));
 void conflicts_output PARAMS ((FILE *out));
-void print_reductions PARAMS ((FILE*out, int state));
+void print_reductions PARAMS ((FILE*out, state_t *state));
 void free_conflicts PARAMS ((void));
 
 /* Were there conflicts? */

src/lalr.c

@@ -310,27 +310,18 @@ static void
 add_lookback_edge (int stateno, int ruleno, int gotono)
 {
   int i;
-  int k;
-  int found;
   shorts *sp;
 
-  i = state_table[stateno]->lookaheadsp;
+  for (i = 0; i < state_table[stateno]->nlookaheads; ++i)
-  k = state_table[stateno + 1]->lookaheadsp;
+    if (LAruleno[state_table[stateno]->lookaheadsp + i] == ruleno)
-  found = 0;
+      break;
-  while (!found && i < k)
-    {
-      if (LAruleno[i] == ruleno)
-	found = 1;
-      else
-	i++;
-    }
 
-  assert (found);
+  assert (LAruleno[state_table[stateno]->lookaheadsp + i] == ruleno);
 
   sp = XCALLOC (shorts, 1);
-  sp->next = lookback[i];
+  sp->next = lookback[state_table[stateno]->lookaheadsp + i];
   sp->value = gotono;
-  lookback[i] = sp;
+  lookback[state_table[stateno]->lookaheadsp + i] = sp;
 }
 
 

src/print.c

@@ -46,11 +46,11 @@ print_token (int extnum, int token)
 `--------------------------------*/
 
 static void
-print_core (FILE *out, int state)
+print_core (FILE *out, state_t *state)
 {
   int i;
-  short *sitems = state_table[state]->items;
+  short *sitems = state->items;
-  int snitems   = state_table[state]->nitems;
+  int snitems   = state->nitems;
 
   /* New experimental feature: if TRACE_FLAGS output all the items of
      a state, not only its kernel.  */
@@ -94,17 +94,17 @@ print_core (FILE *out, int state)
 }
 
 static void
-print_actions (FILE *out, int state)
+print_actions (FILE *out, state_t *state)
 {
   int i;
 
-  shifts   *shiftp = state_table[state]->shifts;
+  shifts   *shiftp = state->shifts;
-  reductions *redp = state_table[state]->reductions;
+  reductions *redp = state->reductions;
-  errs       *errp = state_table[state]->errs;
+  errs       *errp = state->errs;
 
   if (!shiftp->nshifts && !redp)
     {
-      if (final_state == state)
+      if (final_state == state->number)
 	fprintf (out, _("    $default\taccept\n"));
       else
 	fprintf (out, _("    NO ACTIONS\n"));
@@ -140,7 +140,7 @@ print_actions (FILE *out, int state)
 	fputc ('\n', out);
     }
 
-  if (state_table[state]->consistent && redp)
+  if (state->consistent && redp)
     {
       int rule = redp->rules[0];
       int symbol = rule_table[rule].lhs;
@@ -168,9 +168,9 @@ print_actions (FILE *out, int state)
 }
 
 static void
-print_state (FILE *out, int state)
+print_state (FILE *out, state_t *state)
 {
-  fprintf (out, _("state %d"), state);
+  fprintf (out, _("state %d"), state->number);
   fputs ("\n\n", out);
   print_core (out, state);
   print_actions (out, state);
@@ -331,7 +331,7 @@ print_results (void)
   if (trace_flag)
     new_closure (nitems);
   for (i = 0; i < nstates; i++)
-    print_state (out, i);
+    print_state (out, state_table[i]);
   if (trace_flag)
     free_closure ();
 

src/print_graph.c

@@ -38,18 +38,18 @@ static FILE *fgraph = NULL;
 
 /* This part will construct the label of nodes. */
 static void
-print_core (int state, struct obstack *node_obstack)
+print_core (state_t *state, struct obstack *node_obstack)
 {
   int i;
-  short *sitems = state_table[state]->items;
+  short *sitems = state->items;
-  int snitems   = state_table[state]->nitems;
+  int snitems   = state->nitems;
 
   /* Output all the items of a state, not only its kernel.  */
   closure (sitems, snitems);
   sitems = itemset;
   snitems = nitemset;
 
-  obstack_fgrow1 (node_obstack, "%2d: ", state);
+  obstack_fgrow1 (node_obstack, "%2d: ", state->number);
   for (i = 0; i < snitems; i++)
     {
       short *sp;
@@ -65,7 +65,7 @@ print_core (int state, struct obstack *node_obstack)
 
       if (i)
 	obstack_sgrow (node_obstack, "\n    ");
-      obstack_fgrow1 (node_obstack, " %s  ->  ",
+      obstack_fgrow1 (node_obstack, " %s -> ",
 		      tags[rule_table[rule].lhs]);
 
       for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
@@ -85,14 +85,14 @@ print_core (int state, struct obstack *node_obstack)
 `---------------------------------------------------------------*/
 
 static void
-print_actions (int state, const char *node_name)
+print_actions (state_t *state, const char *node_name)
 {
   int i;
 
-  shifts   *shiftp = state_table[state]->shifts;
+  shifts   *shiftp = state->shifts;
-  reductions *redp = state_table[state]->reductions;
+  reductions *redp = state->reductions;
 #if 0
-  errs       *errp = state_table[state]->errs;
+  errs       *errp = state->errs;
 #endif
 
   static char buff[10];
@@ -117,7 +117,7 @@ print_actions (int state, const char *node_name)
 
 	new_edge (&edge);
 
-	if (state > state1)
+	if (state->number > state1)
 	  edge.type = back_edge;
 	open_edge (&edge, fgraph);
 	/* The edge source is the current node.  */
@@ -155,7 +155,7 @@ print_actions (int state, const char *node_name)
 	obstack_1grow (node_obstack, '\n');
     }
 
-  if (state_table[state]->consistent && redp)
+  if (state->consistent && redp)
     {
       rule = redp->rules[0];
       symbol = rule_table[rule].lhs;
@@ -176,7 +176,7 @@ print_actions (int state, const char *node_name)
 `-------------------------------------------------------------*/
 
 static void
-print_state (int state)
+print_state (state_t *state)
 {
   static char name[10];
   struct obstack node_obstack;
@@ -185,7 +185,7 @@ print_state (int state)
   /* The labels of the nodes are their the items.  */
   obstack_init (&node_obstack);
   new_node (&node);
-  sprintf (name, "%d", state);
+  sprintf (name, "%d", state->number);
   node.title = name;
   print_core (state, &node_obstack);
   obstack_1grow (&node_obstack, '\0');
@@ -235,7 +235,7 @@ print_graph (void)
   /* Output nodes and edges. */
   new_closure (nitems);
   for (i = 0; i < nstates; i++)
-    print_state (i);
+    print_state (state_table[i]);
   free_closure ();
 
   /* Close graph. */