2007-01-30 Paolo Bonzini <bonzini@gnu.org>

[bison.git] / src / conflicts.c

diff --git a/src/conflicts.c b/src/conflicts.c
index a0296d6735b33acb93c7ae4fc7f4fe63a66f89cd..7bb3e08ee585e74ec236ee381923372e1ea7f106 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -1,6 +1,6 @@
-/* Find and resolve or report look-ahead conflicts for bison,
+/* Find and resolve or report lookahead conflicts for bison,

 
 

-   Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003, 2004, 2005
+   Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002, 2003, 2004, 2005, 2006

    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.


@@ -40,10 +40,10 @@
 int expected_sr_conflicts = -1;
 int expected_rr_conflicts = -1;
 static char *conflicts;
 int expected_sr_conflicts = -1;
 int expected_rr_conflicts = -1;
 static char *conflicts;

-struct obstack solved_conflicts_obstack;
+static struct obstack solved_conflicts_obstack;

 
 static bitset shift_set;
 
 static bitset shift_set;

-static bitset look_ahead_set;
+static bitset lookahead_set;

 
 \f
 
 
 \f
 


@@ -147,7 +147,7 @@ flush_shift (state *s, int token)
   transitions *trans = s->transitions;
   int i;
 
   transitions *trans = s->transitions;
   int i;
 

-  bitset_reset (look_ahead_set, token);
+  bitset_reset (lookahead_set, token);

   for (i = 0; i < trans->num; i++)
     if (!TRANSITION_IS_DISABLED (trans, i)
        && TRANSITION_SYMBOL (trans, i) == token)
   for (i = 0; i < trans->num; i++)
     if (!TRANSITION_IS_DISABLED (trans, i)
        && TRANSITION_SYMBOL (trans, i) == token)


@@ -157,14 +157,14 @@ flush_shift (state *s, int token)
 
 /*--------------------------------------------------------------------.
 | Turn off the reduce recorded for the specified token for the        |
 
 /*--------------------------------------------------------------------.
 | Turn off the reduce recorded for the specified token for the        |

-| specified look-ahead.  Used when we resolve a shift-reduce conflict |
+| specified lookahead.  Used when we resolve a shift-reduce conflict  |

 | in favor of the shift.                                              |
 `--------------------------------------------------------------------*/
 
 static void
 | in favor of the shift.                                              |
 `--------------------------------------------------------------------*/
 
 static void

-flush_reduce (bitset look_ahead_tokens, int token)
+flush_reduce (bitset lookahead_tokens, int token)

 {
 {

-  bitset_reset (look_ahead_tokens, token);
+  bitset_reset (lookahead_tokens, token);

 }
 
 
 }
 
 


@@ -174,7 +174,7 @@ flush_reduce (bitset look_ahead_tokens, int token)
 | rule has a precedence.  A conflict is resolved by modifying the   |
 | shift or reduce tables so that there is no longer a conflict.     |
 |                                                                   |
 | rule has a precedence.  A conflict is resolved by modifying the   |
 | shift or reduce tables so that there is no longer a conflict.     |
 |                                                                   |

-| RULENO is the number of the look-ahead bitset to consider.      |
+| RULENO is the number of the lookahead bitset to consider.         |

 |                                                                   |
 | ERRORS can be used to store discovered explicit errors.           |
 `------------------------------------------------------------------*/
 |                                                                   |
 | ERRORS can be used to store discovered explicit errors.           |
 `------------------------------------------------------------------*/


@@ -187,12 +187,12 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
   /* Find the rule to reduce by to get precedence of reduction.  */
   rule *redrule = reds->rules[ruleno];
   int redprec = redrule->prec->prec;
   /* Find the rule to reduce by to get precedence of reduction.  */
   rule *redrule = reds->rules[ruleno];
   int redprec = redrule->prec->prec;

-  bitset look_ahead_tokens = reds->look_ahead_tokens[ruleno];
+  bitset lookahead_tokens = reds->lookahead_tokens[ruleno];

   int nerrs = 0;
 
   for (i = 0; i < ntokens; i++)
   int nerrs = 0;
 
   for (i = 0; i < ntokens; i++)

-    if (bitset_test (look_ahead_tokens, i)
-       && bitset_test (look_ahead_set, i)
+    if (bitset_test (lookahead_tokens, i)
+       && bitset_test (lookahead_set, i)

        && symbols[i]->prec)
       {
        /* Shift-reduce conflict occurs for token number i
        && symbols[i]->prec)
       {
        /* Shift-reduce conflict occurs for token number i


@@ -206,7 +206,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
        else if (symbols[i]->prec > redprec)
          {
            log_resolution (redrule, i, shift_resolution);
        else if (symbols[i]->prec > redprec)
          {
            log_resolution (redrule, i, shift_resolution);

-           flush_reduce (look_ahead_tokens, i);
+           flush_reduce (lookahead_tokens, i);

          }
        else
          /* Matching precedence levels.
          }
        else
          /* Matching precedence levels.


@@ -216,9 +216,12 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
 
          switch (symbols[i]->assoc)
            {
 
          switch (symbols[i]->assoc)
            {

+           default:
+             abort ();
+

            case right_assoc:
              log_resolution (redrule, i, right_resolution);
            case right_assoc:
              log_resolution (redrule, i, right_resolution);

-             flush_reduce (look_ahead_tokens, i);
+             flush_reduce (lookahead_tokens, i);

              break;
 
            case left_assoc:
              break;
 
            case left_assoc:


@@ -229,13 +232,10 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
            case non_assoc:
              log_resolution (redrule, i, nonassoc_resolution);
              flush_shift (s, i);
            case non_assoc:
              log_resolution (redrule, i, nonassoc_resolution);
              flush_shift (s, i);

-             flush_reduce (look_ahead_tokens, i);
+             flush_reduce (lookahead_tokens, i);

              /* Record an explicit error for this token.  */
              errors[nerrs++] = symbols[i];
              break;
              /* Record an explicit error for this token.  */
              errors[nerrs++] = symbols[i];
              break;

-
-           case undef_assoc:
-             abort ();

            }
       }
 
            }
       }
 


@@ -258,7 +258,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors)
 | Solve the S/R conflicts of state S using the                       |
 | precedence/associativity, and flag it inconsistent if it still has |
 | conflicts.  ERRORS can be used as storage to compute the list of   |
 | Solve the S/R conflicts of state S using the                       |
 | precedence/associativity, and flag it inconsistent if it still has |
 | conflicts.  ERRORS can be used as storage to compute the list of   |

-| look-ahead tokens on which S raises a syntax error (%nonassoc).    |
+| lookahead tokens on which S raises a syntax error (%nonassoc).     |

 `-------------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------------*/
 
 static void


@@ -271,27 +271,27 @@ set_conflicts (state *s, symbol **errors)
   if (s->consistent)
     return;
 
   if (s->consistent)
     return;
 

-  bitset_zero (look_ahead_set);
+  bitset_zero (lookahead_set);

 
   FOR_EACH_SHIFT (trans, i)
 
   FOR_EACH_SHIFT (trans, i)

-    bitset_set (look_ahead_set, TRANSITION_SYMBOL (trans, i));
+    bitset_set (lookahead_set, TRANSITION_SYMBOL (trans, i));

 
 

-  /* Loop over all rules which require look-ahead in this state.  First
+  /* Loop over all rules which require lookahead in this state.  First

      check for shift-reduce conflict, and try to resolve using
      precedence.  */
   for (i = 0; i < reds->num; ++i)
     if (reds->rules[i]->prec && reds->rules[i]->prec->prec
      check for shift-reduce conflict, and try to resolve using
      precedence.  */
   for (i = 0; i < reds->num; ++i)
     if (reds->rules[i]->prec && reds->rules[i]->prec->prec

-       && !bitset_disjoint_p (reds->look_ahead_tokens[i], look_ahead_set))
+       && !bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))

       resolve_sr_conflict (s, i, errors);
 
       resolve_sr_conflict (s, i, errors);
 

-  /* Loop over all rules which require look-ahead in this state.  Check
+  /* Loop over all rules which require lookahead in this state.  Check

      for conflicts not resolved above.  */
   for (i = 0; i < reds->num; ++i)
     {
      for conflicts not resolved above.  */
   for (i = 0; i < reds->num; ++i)
     {

-      if (!bitset_disjoint_p (reds->look_ahead_tokens[i], look_ahead_set))
+      if (!bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))

        conflicts[s->number] = 1;
 
        conflicts[s->number] = 1;
 

-      bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]);
+      bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]);

     }
 }
 
     }
 }
 


@@ -305,12 +305,12 @@ void
 conflicts_solve (void)
 {
   state_number i;
 conflicts_solve (void)
 {
   state_number i;

-  /* List of look-ahead tokens on which we explicitly raise a syntax error.  */
+  /* List of lookahead tokens on which we explicitly raise a syntax error.  */

   symbol **errors = xnmalloc (ntokens + 1, sizeof *errors);
 
   conflicts = xcalloc (nstates, sizeof *conflicts);
   shift_set = bitset_create (ntokens, BITSET_FIXED);
   symbol **errors = xnmalloc (ntokens + 1, sizeof *errors);
 
   conflicts = xcalloc (nstates, sizeof *conflicts);
   shift_set = bitset_create (ntokens, BITSET_FIXED);

-  look_ahead_set = bitset_create (ntokens, BITSET_FIXED);
+  lookahead_set = bitset_create (ntokens, BITSET_FIXED);

   obstack_init (&solved_conflicts_obstack);
 
   for (i = 0; i < nstates; i++)
   obstack_init (&solved_conflicts_obstack);
 
   for (i = 0; i < nstates; i++)


@@ -342,18 +342,18 @@ count_sr_conflicts (state *s)
   if (!trans)
     return 0;
 
   if (!trans)
     return 0;
 

-  bitset_zero (look_ahead_set);
+  bitset_zero (lookahead_set);

   bitset_zero (shift_set);
 
   FOR_EACH_SHIFT (trans, i)
     bitset_set (shift_set, TRANSITION_SYMBOL (trans, i));
 
   for (i = 0; i < reds->num; ++i)
   bitset_zero (shift_set);
 
   FOR_EACH_SHIFT (trans, i)
     bitset_set (shift_set, TRANSITION_SYMBOL (trans, i));
 
   for (i = 0; i < reds->num; ++i)

-    bitset_or (look_ahead_set, look_ahead_set, reds->look_ahead_tokens[i]);
+    bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]);

 
 

-  bitset_and (look_ahead_set, look_ahead_set, shift_set);
+  bitset_and (lookahead_set, lookahead_set, shift_set);

 
 

-  src_count = bitset_count (look_ahead_set);
+  src_count = bitset_count (lookahead_set);

 
   return src_count;
 }
 
   return src_count;
 }


@@ -378,7 +378,7 @@ count_rr_conflicts (state *s, bool one_per_token)
       int count = 0;
       int j;
       for (j = 0; j < reds->num; ++j)
       int count = 0;
       int j;
       for (j = 0; j < reds->num; ++j)

-       if (bitset_test (reds->look_ahead_tokens[j], i))
+       if (bitset_test (reds->lookahead_tokens[j], i))

          count++;
 
       if (count >= 2)
          count++;
 
       if (count >= 2)


@@ -433,7 +433,7 @@ conflicts_output (FILE *out)
 /*--------------------------------------------------------.
 | Total the number of S/R and R/R conflicts.  Unlike the  |
 | code in conflicts_output, however, count EACH pair of   |
 /*--------------------------------------------------------.
 | Total the number of S/R and R/R conflicts.  Unlike the  |
 | code in conflicts_output, however, count EACH pair of   |

-| reductions for the same state and look-ahead as one     |
+| reductions for the same state and lookahead as one      |

 | conflict.                                              |
 `--------------------------------------------------------*/
 
 | conflict.                                              |
 `--------------------------------------------------------*/
 


@@ -530,6 +530,6 @@ conflicts_free (void)
 {
   free (conflicts);
   bitset_free (shift_set);
 {
   free (conflicts);
   bitset_free (shift_set);

-  bitset_free (look_ahead_set);
+  bitset_free (lookahead_set);

   obstack_free (&solved_conflicts_obstack, NULL);
 }
   obstack_free (&solved_conflicts_obstack, NULL);
 }