05-display-lookaheads.patch

[Akim Demaille]

Index: ChangeLog
from  Akim Demaille  <address@hidden>

        New experimental feature: display the lookaheads in the report and
        graph.

        * src/print (print_core): When --trace-flag, display the rules
        lookaheads.
        * src/print_graph.c (print_core): Likewise.
        Swap the arguments.
        Adjust caller.

Index: TODO
--- TODO Sat, 04 May 2002 10:44:42 +0200 akim
+++ TODO Sun, 05 May 2002 13:43:04 +0200 akim
@@ -21,6 +21,110 @@
          char *sval;
        }

+* Experimental report features
+Decide whether they should be enabled, or optional.  For instance, on:
+
+       input:
+         exp
+       | input exp
+       ;
+
+       exp:
+         token1 "1"
+       | token2 "2"
+       | token3 "3"
+       ;
+
+       token1: token;
+       token2: token;
+       token3: token;
+
+the traditional Bison reports:
+
+       state 0
+
+           $axiom  ->  . input $   (rule 0)
+
+           token       shift, and go to state 1
+
+           input       go to state 2
+           exp         go to state 3
+           token1      go to state 4
+           token2      go to state 5
+           token3      go to state 6
+
+       state 1
+
+           token1  ->  token .   (rule 6)
+           token2  ->  token .   (rule 7)
+           token3  ->  token .   (rule 8)
+
+           "2"         reduce using rule 7 (token2)
+           "3"         reduce using rule 8 (token3)
+           $default    reduce using rule 6 (token1)
+
+while with --trace, i.e., when enabling both the display of non-core
+item sets and the display of lookaheads, Bison now displays:
+
+       state 0
+
+           $axiom  ->  . input $   (rule 0)
+           input  ->  . exp   (rule 1)
+           input  ->  . input exp   (rule 2)
+           exp  ->  . token1 "1"   (rule 3)
+           exp  ->  . token2 "2"   (rule 4)
+           exp  ->  . token3 "3"   (rule 5)
+           token1  ->  . token   (rule 6)
+           token2  ->  . token   (rule 7)
+           token3  ->  . token   (rule 8)
+
+           token       shift, and go to state 1
+
+           input       go to state 2
+           exp         go to state 3
+           token1      go to state 4
+           token2      go to state 5
+           token3      go to state 6
+
+       state 1
+
+           token1  ->  token .  ["1"]   (rule 6)
+           token2  ->  token .  ["2"]   (rule 7)
+           token3  ->  token .  ["3"]   (rule 8)
+
+           "2"         reduce using rule 7 (token2)
+           "3"         reduce using rule 8 (token3)
+           $default    reduce using rule 6 (token1)
+
+so decide whether this should be an option, or always enabled.  I'm in
+favor of making it the default, but maybe we should tune the output to
+distinguish core item sets from non core:
+
+       state 0
+           Core:
+           $axiom  ->  . input $   (rule 0)
+
+           Derived:
+           input  ->  . exp   (rule 1)
+           input  ->  . input exp   (rule 2)
+           exp  ->  . token1 "1"   (rule 3)
+           exp  ->  . token2 "2"   (rule 4)
+           exp  ->  . token3 "3"   (rule 5)
+           token1  ->  . token   (rule 6)
+           token2  ->  . token   (rule 7)
+           token3  ->  . token   (rule 8)
+
+           token       shift, and go to state 1
+
+           input       go to state 2
+           exp         go to state 3
+           token1      go to state 4
+           token2      go to state 5
+           token3      go to state 6
+
+
+Note that the same questions applies to --graph.
+
 * Coding system independence
 Paul notes:

Index: src/print.c
--- src/print.c Wed, 10 Apr 2002 23:20:06 +0200 akim
+++ src/print.c Sun, 05 May 2002 12:08:42 +0200 akim
@@ -105,6 +105,32 @@
          for (/* Nothing */; *sp >= 0; ++sp)
            fprintf (out, " %s", escape (symbols[*sp]->tag));

+         /* Experimental feature: display the lookaheads. */
+         if (trace_flag && state->nlookaheads)
+           {
+             int j, k;
+             int nlookaheads = 0;
+             /* Look for lookaheads corresponding to this rule. */
+             for (j = 0; j < state->nlookaheads; ++j)
+               for (k = 0; k < ntokens; ++k)
+                 if (bitset_test (LA[state->lookaheadsp + j], k)
+                     && LArule[state->lookaheadsp + j]->number == rule)
+                   nlookaheads++;
+             if (nlookaheads)
+               {
+                 fprintf (out, "  [");
+                 for (j = 0; j < state->nlookaheads; ++j)
+                   for (k = 0; k < ntokens; ++k)
+                     if (bitset_test (LA[state->lookaheadsp + j], k)
+                         && LArule[state->lookaheadsp + j]->number == rule)
+                       fprintf (out, "%s%s",
+                                quotearg_style (escape_quoting_style,
+                                                symbols[k]->tag),
+                                --nlookaheads ? ", " : "");
+                 fprintf (out, "]");
+               }
+           }
+
          fprintf (out, _("   (rule %d)"), rule - 1);
          fputc ('\n', out);
        }
Index: src/print_graph.c
--- src/print_graph.c Wed, 10 Apr 2002 23:20:06 +0200 akim
+++ src/print_graph.c Sun, 05 May 2002 12:15:58 +0200 akim
@@ -47,7 +47,7 @@

 /* This part will construct the label of nodes. */
 static void
-print_core (state_t *state, struct obstack *node_obstack)
+print_core (struct obstack *oout, state_t *state)
 {
   int i;
   item_number_t *sitems = state->items;
@@ -61,7 +61,7 @@
       snritems = nritemset;
     }

-  obstack_fgrow1 (node_obstack, "state %2d\n", state->number);
+  obstack_fgrow1 (oout, "state %2d\n", state->number);
   for (i = 0; i < snritems; i++)
     {
       item_number_t *sp;
@@ -76,17 +76,43 @@
       rule = -(*sp);

       if (i)
-       obstack_1grow (node_obstack, '\n');
-      obstack_fgrow1 (node_obstack, " %s -> ",
+       obstack_1grow (oout, '\n');
+      obstack_fgrow1 (oout, " %s -> ",
                      escape (rules[rule].lhs->tag));

       for (sp = rules[rule].rhs; sp < sp1; sp++)
-       obstack_fgrow1 (node_obstack, "%s ", escape (symbols[*sp]->tag));
+       obstack_fgrow1 (oout, "%s ", escape (symbols[*sp]->tag));

-      obstack_1grow (node_obstack, '.');
+      obstack_1grow (oout, '.');

       for (/* Nothing */; *sp >= 0; ++sp)
-       obstack_fgrow1 (node_obstack, " %s", escape (symbols[*sp]->tag));
+       obstack_fgrow1 (oout, " %s", escape (symbols[*sp]->tag));
+
+      /* Experimental feature: display the lookaheads. */
+      if (trace_flag && state->nlookaheads)
+       {
+         int j, k;
+         int nlookaheads = 0;
+         /* Look for lookaheads corresponding to this rule. */
+         for (j = 0; j < state->nlookaheads; ++j)
+           for (k = 0; k < ntokens; ++k)
+             if (bitset_test (LA[state->lookaheadsp + j], k)
+                 && LArule[state->lookaheadsp + j]->number == rule)
+               nlookaheads++;
+         if (nlookaheads)
+           {
+             obstack_sgrow (oout, "  [");
+             for (j = 0; j < state->nlookaheads; ++j)
+               for (k = 0; k < ntokens; ++k)
+                 if (bitset_test (LA[state->lookaheadsp + j], k)
+                     && LArule[state->lookaheadsp + j]->number == rule)
+                   obstack_fgrow2 (oout, "%s%s",
+                                   quotearg_style (escape_quoting_style,
+                                                   symbols[k]->tag),
+                                   --nlookaheads ? ", " : "");
+             obstack_sgrow (oout, "]");
+           }
+       }
     }
 }

@@ -154,7 +180,7 @@
   new_node (&node);
   sprintf (name, "%d", state->number);
   node.title = name;
-  print_core (state, &node_obstack);
+  print_core (&node_obstack, state);
   obstack_1grow (&node_obstack, '\0');
   node.label = obstack_finish (&node_obstack);