* src/conflicts.c (log_resolution): Accept the rule involved in

the sr conflicts instead of the lookahead number that points to
that rule.
(flush_reduce): Accept the current lookahead vector as argument,
instead of the index in LA.
(resolve_sr_conflict): Accept the current number of lookahead
bitset to consider for the STATE, instead of the index in LA.
(set_conflicts): Adjust.
* src/lalr.c, src/lalr.h, src/state.h: Comment changes.

diff --git a/ChangeLog b/ChangeLog
index ec64bd63727d8e48c6cea584b752b5aeff075f9f..b61837f5eaa84112e26cba6f84343d178eb17948 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
+2002-06-15  Akim Demaille  <akim@epita.fr>
+
+       * src/conflicts.c (log_resolution): Accept the rule involved in
+       the sr conflicts instead of the lookahead number that points to
+       that rule.
+       (flush_reduce): Accept the current lookahead vector as argument,
+       instead of the index in LA.
+       (resolve_sr_conflict): Accept the current number of lookahead
+       bitset to consider for the STATE, instead of the index in LA.
+       (set_conflicts): Adjust.
+       * src/lalr.c, src/lalr.h, src/state.h: Comment changes.
+
+       

 2002-06-15  Akim Demaille  <akim@epita.fr>
 
        * src/state.h (state_t): Replace the `lookaheadsp' member, a
 2002-06-15  Akim Demaille  <akim@epita.fr>
 
        * src/state.h (state_t): Replace the `lookaheadsp' member, a

diff --git a/src/conflicts.c b/src/conflicts.c
index 2cf6ce28b5d2df9191e7db80b406f8ea6a458822..e09b6d8772b6796b459417d57452d55d77973f57 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -52,8 +52,13 @@ enum conflict_resolution_e
   };
 
 
   };
 
 

+/*----------------------------------------------------------------.
+| Explain how an SR conflict between TOKEN and RULE was resolved: |
+| RESOLUTION.                                                     |
+`----------------------------------------------------------------*/
+

 static inline void
 static inline void

-log_resolution (int lookahead, int token,
+log_resolution (rule_t *rule, int token,

                enum conflict_resolution_e resolution)
 {
   if (report_flag & report_solved_conflicts)
                enum conflict_resolution_e resolution)
 {
   if (report_flag & report_solved_conflicts)


@@ -66,7 +71,7 @@ log_resolution (int lookahead, int token,
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as shift"),
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as shift"),

-                         LArule[lookahead]->number,
+                         rule->number,

                          symbols[token]->tag);
          break;
        case reduce_resolution:
                          symbols[token]->tag);
          break;
        case reduce_resolution:


@@ -74,14 +79,14 @@ log_resolution (int lookahead, int token,
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as reduce"),
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as reduce"),

-                         LArule[lookahead]->number,
+                         rule->number,

                          symbols[token]->tag);
          break;
        case nonassoc_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as an error"),
                          symbols[token]->tag);
          break;
        case nonassoc_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as an error"),

-                         LArule[lookahead]->number,
+                         rule->number,

                          symbols[token]->tag);
          break;
        }
                          symbols[token]->tag);
          break;
        }


@@ -92,7 +97,7 @@ log_resolution (int lookahead, int token,
        case shift_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
        case shift_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",

-                         LArule[lookahead]->prec->tag,
+                         rule->prec->tag,

                          symbols[token]->tag);
          break;
 
                          symbols[token]->tag);
          break;
 


@@ -100,7 +105,7 @@ log_resolution (int lookahead, int token,
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
                          symbols[token]->tag,
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
                          symbols[token]->tag,

-                         LArule[lookahead]->prec->tag);
+                         rule->prec->tag);

          break;
 
        case left_resolution:
          break;
 
        case left_resolution:


@@ -151,9 +156,9 @@ flush_shift (state_t *state, int token)
 `-------------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------------*/
 
 static void

-flush_reduce (int lookahead, int token)
+flush_reduce (bitset lookaheads, int token)

 {
 {

-  bitset_reset (LA[lookahead], token);
+  bitset_reset (lookaheads, token);

 }
 
 
 }
 
 


@@ -162,19 +167,23 @@ flush_reduce (int lookahead, int token)
 | precedence declarations.  It has already been checked that the    |
 | rule has a precedence.  A conflict is resolved by modifying the   |
 | shift or reduce tables so that there is no longer a conflict.     |
 | precedence declarations.  It has already been checked that the    |
 | rule has a precedence.  A conflict is resolved by modifying the   |
 | shift or reduce tables so that there is no longer a conflict.     |

+|                                                                   |
+| LOOKAHEAD is the number of the lookahead bitset to consider.      |

 `------------------------------------------------------------------*/
 
 static void
 resolve_sr_conflict (state_t *state, int lookahead)
 {
   int i;
 `------------------------------------------------------------------*/
 
 static void
 resolve_sr_conflict (state_t *state, int lookahead)
 {
   int i;

-  /* find the rule to reduce by to get precedence of reduction  */
-  int redprec = LArule[lookahead]->prec->prec;
+  /* Find the rule to reduce by to get precedence of reduction.  */
+  rule_t *redrule = state->lookaheads_rule[lookahead];
+  int redprec = redrule->prec->prec;
+  bitset lookaheads = state->lookaheads[lookahead];

   errs *errp = errs_new (ntokens + 1);
   errp->nerrs = 0;
 
   for (i = 0; i < ntokens; i++)
   errs *errp = errs_new (ntokens + 1);
   errp->nerrs = 0;
 
   for (i = 0; i < ntokens; i++)

-    if (bitset_test (LA[lookahead], i)
+    if (bitset_test (lookaheads, i)

        && bitset_test (lookaheadset, i)
        && symbols[i]->prec)
       {
        && bitset_test (lookaheadset, i)
        && symbols[i]->prec)
       {


@@ -183,13 +192,13 @@ resolve_sr_conflict (state_t *state, int lookahead)
           The precedence of shifting is that of token i.  */
        if (symbols[i]->prec < redprec)
          {
           The precedence of shifting is that of token i.  */
        if (symbols[i]->prec < redprec)
          {

-           log_resolution (lookahead, i, reduce_resolution);
+           log_resolution (redrule, i, reduce_resolution);

            flush_shift (state, i);
          }
        else if (symbols[i]->prec > redprec)
          {
            flush_shift (state, i);
          }
        else if (symbols[i]->prec > redprec)
          {

-           log_resolution (lookahead, i, shift_resolution);
-           flush_reduce (lookahead, i);
+           log_resolution (redrule, i, shift_resolution);
+           flush_reduce (lookaheads, i);

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


@@ -200,19 +209,19 @@ resolve_sr_conflict (state_t *state, int lookahead)
          switch (symbols[i]->assoc)
            {
            case right_assoc:
          switch (symbols[i]->assoc)
            {
            case right_assoc:

-             log_resolution (lookahead, i, right_resolution);
-             flush_reduce (lookahead, i);
+             log_resolution (redrule, i, right_resolution);
+             flush_reduce (lookaheads, i);

              break;
 
            case left_assoc:
              break;
 
            case left_assoc:

-             log_resolution (lookahead, i, left_resolution);
+             log_resolution (redrule, i, left_resolution);

              flush_shift (state, i);
              break;
 
            case non_assoc:
              flush_shift (state, i);
              break;
 
            case non_assoc:

-             log_resolution (lookahead, i, nonassoc_resolution);
+             log_resolution (redrule, i, nonassoc_resolution);

              flush_shift (state, i);
              flush_shift (state, i);

-             flush_reduce (lookahead, i);
+             flush_reduce (lookaheads, i);

              /* Record an explicit error for this token.  */
              errp->errs[errp->nerrs++] = i;
              break;
              /* Record an explicit error for this token.  */
              errp->errs[errp->nerrs++] = i;
              break;


@@ -254,13 +263,13 @@ set_conflicts (state_t *state)
 
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
 
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using

-     precedence */
+     precedence.  */

   for (i = 0; i < state->nlookaheads; ++i)
     if (state->lookaheads_rule[i]->prec
        && state->lookaheads_rule[i]->prec->prec
        && !bitset_disjoint_p (state->lookaheads[i], lookaheadset))
       {
   for (i = 0; i < state->nlookaheads; ++i)
     if (state->lookaheads_rule[i]->prec
        && state->lookaheads_rule[i]->prec->prec
        && !bitset_disjoint_p (state->lookaheads[i], lookaheadset))
       {

-       resolve_sr_conflict (state, (state->lookaheads - LA) + i);
+       resolve_sr_conflict (state, i);

        break;
       }
 
        break;
       }
 

diff --git a/src/lalr.c b/src/lalr.c
index 6d7b34ffe9bf529550e7528be4c2840ad10ff3ef..14a3e2318537301d4da4e722aa862fa59d4db3cc 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -559,8 +559,8 @@ states_lookaheads_initialize (void)
   bitsetv pLA = LA;
   rule_t **pLArule = LArule;
 
   bitsetv pLA = LA;
   rule_t **pLArule = LArule;
 

-  /* Count the number of lookaheads required for each state
-     (NLOOKAHEADS member).  */
+  /* Initialize the members LOOKAHEADS and LOOKAHEADS_RULE for each
+     state.  */

   for (i = 0; i < nstates; i++)
     {
       states[i]->lookaheads = pLA;
   for (i = 0; i < nstates; i++)
     {
       states[i]->lookaheads = pLA;

diff --git a/src/lalr.h b/src/lalr.h
index 609310527230c4a35934bb6df2cc24b96d11f89b..ab1c8ba1a8911e291dee440d26839f3959316a62 100644 (file)
--- a/src/lalr.h
+++ b/src/lalr.h
@@ -63,7 +63,7 @@ extern short *to_state;
 
 extern rule_t **LArule;
 
 
 extern rule_t **LArule;
 

-/* LA is a lr by ntokens matrix of bits.  LA[l, i] is 1 if the rule
+/* LA is a LR by NTOKENS matrix of bits.  LA[l, i] is 1 if the rule

    LAruleno[l] is applicable in the appropriate state when the next
    token is symbol i.  If LA[l, i] and LA[l, j] are both 1 for i != j,
    it is a conflict.  */
    LAruleno[l] is applicable in the appropriate state when the next
    token is symbol i.  If LA[l, i] and LA[l, j] are both 1 for i != j,
    it is a conflict.  */

diff --git a/src/state.h b/src/state.h
index 7f578bdc004fe7f2988d886f1c646daea16b1283..239a367d91fb65e619f01c672bcff09b6e837e51 100644 (file)
--- a/src/state.h
+++ b/src/state.h
@@ -30,19 +30,19 @@
    state.  These symbols at these items are the allowable inputs that
    can follow now.
 
    state.  These symbols at these items are the allowable inputs that
    can follow now.
 

-   A core represents one state.  States are numbered in the number
+   A core represents one state.  States are numbered in the NUMBER

    field.  When generate_states is finished, the starting state is
    field.  When generate_states is finished, the starting state is

-   state 0 and nstates is the number of states.  (A transition to a
-   state whose state number is nstates indicates termination.)  All
-   the cores are chained together and first_state points to the first
-   one (state 0).
+   state 0 and NSTATES is the number of states.  (FIXME: This sentence
+   is no longer true: A transition to a state whose state number is
+   NSTATES indicates termination.)  All the cores are chained together
+   and FIRST_STATE points to the first one (state 0).

 
    For each state there is a particular symbol which must have been
    the last thing accepted to reach that state.  It is the
 
    For each state there is a particular symbol which must have been
    the last thing accepted to reach that state.  It is the

-   accessing_symbol of the core.
+   ACCESSING_SYMBOL of the core.

 
    Each core contains a vector of NITEMS items which are the indices
 
    Each core contains a vector of NITEMS items which are the indices

-   in the ritems vector of the items that are selected in this state.
+   in the RITEMS vector of the items that are selected in this state.

 
    The link field is used for chaining symbols that hash states by
    their itemsets.  This is for recognizing equivalent states and
 
    The link field is used for chaining symbols that hash states by
    their itemsets.  This is for recognizing equivalent states and