bison-patches
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

13-propagate-states-la.patch


From: Akim Demaille
Subject: 13-propagate-states-la.patch
Date: Sat, 15 Jun 2002 20:19:47 +0200

Index: ChangeLog
from  Akim Demaille  <address@hidden>
        * 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.
        
        
Index: src/conflicts.c
--- src/conflicts.c Sat, 15 Jun 2002 18:15:43 +0200 akim
+++ src/conflicts.c Sat, 15 Jun 2002 18:28:17 +0200 akim
@@ -52,8 +52,13 @@
   };
 
 
+/*----------------------------------------------------------------.
+| Explain how an SR conflict between TOKEN and RULE was resolved: |
+| RESOLUTION.                                                     |
+`----------------------------------------------------------------*/
+
 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)
@@ -66,7 +71,7 @@
          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:
@@ -74,14 +79,14 @@
          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"),
-                         LArule[lookahead]->number,
+                         rule->number,
                          symbols[token]->tag);
          break;
        }
@@ -92,7 +97,7 @@
        case shift_resolution:
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
-                         LArule[lookahead]->prec->tag,
+                         rule->prec->tag,
                          symbols[token]->tag);
          break;
 
@@ -100,7 +105,7 @@
          obstack_fgrow2 (&solved_conflicts_obstack,
                          " (%s < %s)",
                          symbols[token]->tag,
-                         LArule[lookahead]->prec->tag);
+                         rule->prec->tag);
          break;
 
        case left_resolution:
@@ -151,9 +156,9 @@
 `-------------------------------------------------------------------*/
 
 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 @@
 | 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;
-  /* 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++)
-    if (bitset_test (LA[lookahead], i)
+    if (bitset_test (lookaheads, i)
        && bitset_test (lookaheadset, i)
        && symbols[i]->prec)
       {
@@ -183,13 +192,13 @@
           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)
          {
-           log_resolution (lookahead, i, shift_resolution);
-           flush_reduce (lookahead, i);
+           log_resolution (redrule, i, shift_resolution);
+           flush_reduce (lookaheads, i);
          }
        else
          /* Matching precedence levels.
@@ -200,19 +209,19 @@
          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:
-             log_resolution (lookahead, i, left_resolution);
+             log_resolution (redrule, i, left_resolution);
              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_reduce (lookahead, i);
+             flush_reduce (lookaheads, i);
              /* Record an explicit error for this token.  */
              errp->errs[errp->nerrs++] = i;
              break;
@@ -254,13 +263,13 @@
 
   /* 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))
       {
-       resolve_sr_conflict (state, (state->lookaheads - LA) + i);
+       resolve_sr_conflict (state, i);
        break;
       }
 
Index: src/lalr.c
--- src/lalr.c Sat, 15 Jun 2002 18:15:43 +0200 akim
+++ src/lalr.c Sat, 15 Jun 2002 18:34:57 +0200 akim
@@ -559,8 +559,8 @@
   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;
Index: src/lalr.h
--- src/lalr.h Thu, 04 Apr 2002 19:48:42 +0200 akim
+++ src/lalr.h Sat, 15 Jun 2002 18:33:11 +0200 akim
@@ -63,7 +63,7 @@
 
 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.  */
Index: src/state.h
--- src/state.h Sat, 15 Jun 2002 18:15:43 +0200 akim
+++ src/state.h Sat, 15 Jun 2002 18:32:19 +0200 akim
@@ -30,19 +30,19 @@
    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
-   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
-   accessing_symbol of the core.
+   ACCESSING_SYMBOL of the core.
 
    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



reply via email to

[Prev in Thread] Current Thread [Next in Thread]