* src/scan-gram.l: Move the "add a trailing ; to actions" code

[bison.git] / src / print_graph.c

diff --git a/src/print_graph.c b/src/print_graph.c
index d187480ce0ce6e6aa6601b272e44ed1477b0036b..9580f3f145ab9d204fc391bf63d0df6ea8382b98 100644 (file)
--- a/src/print_graph.c
+++ b/src/print_graph.c
@@ -1,5 +1,6 @@
 /* Output a VCG description on generated parser, for Bison,
 /* Output a VCG description on generated parser, for Bison,

-   Copyright 2001 Free Software Foundation, Inc.
+
+   Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -15,66 +16,100 @@
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to

-   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */

 
 

+#include <config.h>

 #include "system.h"
 #include "system.h"

-#include "files.h"
-#include "gram.h"
+
+#include <quotearg.h>
+

 #include "LR0.h"
 #include "LR0.h"

-#include "lalr.h"
-#include "conflicts.h"
+#include "closure.h"

 #include "complain.h"
 #include "complain.h"

+#include "conflicts.h"
+#include "files.h"

 #include "getargs.h"
 #include "getargs.h"

-#include "state.h"
-#include "reader.h"
-#include "closure.h"
-#include "obstack.h"
+#include "gram.h"
+#include "lalr.h"

 #include "print_graph.h"
 #include "print_graph.h"

+#include "reader.h"
+#include "state.h"
+#include "symtab.h"

 #include "vcg.h"
 
 #include "vcg.h"
 

-static graph_t graph;
+static graph static_graph;

 static FILE *fgraph = NULL;
 
 static FILE *fgraph = NULL;
 

-/* This part will construct the label of nodes. */
+
+/*----------------------------.
+| Construct the node labels.  |
+`----------------------------*/
+

 static void
 static void

-print_core (int state, struct obstack *node_obstack)
+print_core (struct obstack *oout, state *s)

 {
 {

-  int i;
-  short *sitems = state_table[state]->items;
-  int snitems   = state_table[state]->nitems;
+  size_t i;
+  item_number *sitems = s->items;
+  size_t snritems = s->nitems;

 
   /* Output all the items of a state, not only its kernel.  */
 
   /* Output all the items of a state, not only its kernel.  */

-  closure (sitems, snitems);
-  sitems = itemset;
-  snitems = nitemset;
+  if (report_flag & report_itemsets)
+    {
+      closure (sitems, snritems);
+      sitems = itemset;
+      snritems = nritemset;
+    }

 
 

-  obstack_fgrow1 (node_obstack, "%2d: ", state);
-  for (i = 0; i < snitems; i++)
+  obstack_fgrow1 (oout, "state %2d\n", s->number);
+  for (i = 0; i < snritems; i++)

     {
     {

-      short *sp;
-      short *sp1;
-      int rule;
+      item_number *sp;
+      item_number *sp1;
+      rule_number r;

 
       sp1 = sp = ritem + sitems[i];
 
 
       sp1 = sp = ritem + sitems[i];
 

-      while (*sp > 0)
+      while (*sp >= 0)

        sp++;
 
        sp++;
 

-      rule = -(*sp);
+      r = item_number_as_rule_number (*sp);

 
       if (i)
 
       if (i)

-       obstack_sgrow (node_obstack, "\n    ");
-      obstack_fgrow1 (node_obstack, " %s  ->  ",
-                     tags[rule_table[rule].lhs]);
+       obstack_1grow (oout, '\n');
+      obstack_fgrow1 (oout, " %s -> ",
+                     rules[r].lhs->tag);
+
+      for (sp = rules[r].rhs; sp < sp1; sp++)
+       obstack_fgrow1 (oout, "%s ", symbols[*sp]->tag);

 
 

-      for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
-       obstack_fgrow1 (node_obstack, "%s ", tags[*sp]);
+      obstack_1grow (oout, '.');

 
 

-      obstack_1grow (node_obstack, '.');
+      for (/* Nothing */; *sp >= 0; ++sp)
+       obstack_fgrow1 (oout, " %s", symbols[*sp]->tag);

 
 

-      for (/* Nothing */; *sp > 0; ++sp)
-       obstack_fgrow1 (node_obstack, " %s", tags[*sp]);
+      /* Experimental feature: display the look-ahead tokens. */
+      if (report_flag & report_look_ahead_tokens)
+       {
+         /* Find the reduction we are handling.  */
+         reductions *reds = s->reductions;
+         int redno = state_reduction_find (s, &rules[r]);
+
+         /* Print them if there are.  */
+         if (reds->look_ahead_tokens && redno != -1)
+           {
+             bitset_iterator biter;
+             int k;
+             char const *sep = "";
+             obstack_sgrow (oout, "[");
+             BITSET_FOR_EACH (biter, reds->look_ahead_tokens[redno], k, 0)
+               {
+                 obstack_fgrow2 (oout, "%s%s", sep, symbols[k]->tag);
+                 sep = ", ";
+               }
+             obstack_sgrow (oout, "]");
+           }
+       }

     }
 }
 
     }
 }
 


@@ -85,88 +120,43 @@ print_core (int state, struct obstack *node_obstack)
 `---------------------------------------------------------------*/
 
 static void
 `---------------------------------------------------------------*/
 
 static void

-print_actions (int state, const char *node_name)
+print_actions (state *s, const char *node_name)

 {
   int i;
 
 {
   int i;
 

-  shifts   *shiftp = state_table[state]->shifts;
-  reductions *redp = state_table[state]->reductions;
-#if 0
-  errs       *errp = state_table[state]->errs;
-#endif
+  transitions *trans = s->transitions;
+  reductions *reds = s->reductions;

 
   static char buff[10];
 
   static char buff[10];

-  edge_t edge;
+  edge e;

 
 

-  if (!shiftp->nshifts && !redp)
-    {
-#if 0
-      if (final_state == state)
-       obstack_sgrow (node_obstack, "$default: accept");
-      else
-       obstack_sgrow (node_obstack, "NO ACTIONS");
-#endif
-      return;
-    }
+  if (!trans->num && !reds)
+    return;

 
 

-  for (i = 0; i < shiftp->nshifts; i++)
-    if (!SHIFT_IS_DISABLED (shiftp, i))
+  for (i = 0; i < trans->num; i++)
+    if (!TRANSITION_IS_DISABLED (trans, i))

       {
       {

-       int state1 = shiftp->shifts[i];
-       int symbol = state_table[state1]->accessing_symbol;
+       state *s1 = trans->states[i];
+       symbol_number sym = s1->accessing_symbol;

 
 

-       new_edge (&edge);
+       new_edge (&e);

 
 

-       if (state > state1)
-         edge.type = back_edge;
-       open_edge (&edge, fgraph);
+       if (s->number > s1->number)
+         e.type = back_edge;
+       open_edge (&e, fgraph);

        /* The edge source is the current node.  */
        /* The edge source is the current node.  */

-       edge.sourcename = node_name;
-       sprintf (buff, "%d", state1);
-       edge.targetname = buff;
-       /* Shifts are blue, gotos are red. */
-       edge.color = SHIFT_IS_SHIFT(shiftp, i) ? blue : red;
-       edge.label = tags[symbol];
-       output_edge (&edge, fgraph);
+       e.sourcename = node_name;
+       sprintf (buff, "%d", s1->number);
+       e.targetname = buff;
+       /* Shifts are blue, gotos are green, and error is red. */
+       if (TRANSITION_IS_ERROR (trans, i))
+         e.color = red;
+       else
+         e.color = TRANSITION_IS_SHIFT (trans, i) ? blue : green;
+       e.label = symbols[sym]->tag;
+       output_edge (&e, fgraph);

        close_edge (fgraph);
       }
        close_edge (fgraph);
       }

-
-#if 0
-  if (errp)
-    {
-      int j, nerrs;
-
-      nerrs = errp->nerrs;
-
-      for (j = 0; j < nerrs; j++)
-       {
-         if (!errp->errs[j])
-           continue;
-         symbol = errp->errs[j];
-         /* If something has been added in the NODE_OBSTACK after
-            the declaration of the label, then we need a `\n'.
-         if (obstack_object_size (node_obstack) > node_output_size)
-           obstack_sgrow (node_obstack, "\n");
-           */
-         obstack_fgrow1 (node_obstack, _("%-4s\terror (nonassociative)"),
-                         tags[symbol]);
-       }
-      if (j > 0)
-       obstack_1grow (node_obstack, '\n');
-    }
-
-  if (state_table[state]->consistent && redp)
-    {
-      rule = redp->rules[0];
-      symbol = rule_table[rule].lhs;
-      /*
-      if (obstack_object_size (node_obstack) > node_output_size)
-       obstack_sgrow (node_obstack, "\n");
-       */
-      obstack_fgrow2 (node_obstack, _("$default\treduce using rule %d (%s)"),
-                     rule, tags[symbol]);
-    }
-#endif

 }
 
 
 }
 
 


@@ -176,27 +166,27 @@ print_actions (int state, const char *node_name)
 `-------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------*/
 
 static void

-print_state (int state)
+print_state (state *s)

 {
   static char name[10];
   struct obstack node_obstack;
 {
   static char name[10];
   struct obstack node_obstack;

-  node_t node;
+  node n;

 
   /* The labels of the nodes are their the items.  */
   obstack_init (&node_obstack);
 
   /* The labels of the nodes are their the items.  */
   obstack_init (&node_obstack);

-  new_node (&node);
-  sprintf (name, "%d", state);
-  node.title = name;
-  print_core (state, &node_obstack);
+  new_node (&n);
+  sprintf (name, "%d", s->number);
+  n.title = name;
+  print_core (&node_obstack, s);

   obstack_1grow (&node_obstack, '\0');
   obstack_1grow (&node_obstack, '\0');

-  node.label = obstack_finish (&node_obstack);
+  n.label = obstack_finish (&node_obstack);

 
   open_node (fgraph);
 
   open_node (fgraph);

-  output_node (&node, fgraph);
+  output_node (&n, fgraph);

   close_node (fgraph);
 
   /* Output the edges.  */
   close_node (fgraph);
 
   /* Output the edges.  */

-  print_actions (state, name);
+  print_actions (s, name);

 
   obstack_free (&node_obstack, 0);
 }
 
   obstack_free (&node_obstack, 0);
 }


@@ -205,40 +195,33 @@ print_state (int state)
 void
 print_graph (void)
 {
 void
 print_graph (void)
 {

-  int i;
+  state_number i;

 
   /* Output file.  */
   fgraph = xfopen (spec_graph_file, "w");
 
 
   /* Output file.  */
   fgraph = xfopen (spec_graph_file, "w");
 

-  new_graph (&graph);
-
-#if 0
-  graph.smanhattan_edges = yes;
-  graph.manhattan_edges = yes;
-#endif
+  new_graph (&static_graph);

 
 

-  graph.display_edge_labels = yes;
-  graph.layoutalgorithm = normal;
+  static_graph.display_edge_labels = yes;

 
 

-  graph.port_sharing = no;
-  graph.finetuning = yes;
-  graph.straight_phase = yes;
-  graph.priority_phase = yes;
-  graph.splines = yes;
+  static_graph.port_sharing = no;
+  static_graph.finetuning = yes;
+  static_graph.priority_phase = yes;
+  static_graph.splines = yes;

 
 

-  graph.crossing_weight = median;
+  static_graph.crossing_weight = median;

 
   /* Output graph options. */
   open_graph (fgraph);
 
   /* Output graph options. */
   open_graph (fgraph);

-  output_graph (&graph, fgraph);
+  output_graph (&static_graph, fgraph);

 
   /* Output nodes and edges. */
 
   /* Output nodes and edges. */

-  new_closure (nitems);
+  new_closure (nritems);

   for (i = 0; i < nstates; i++)
   for (i = 0; i < nstates; i++)

-    print_state (i);
+    print_state (states[i]);

   free_closure ();
 
   /* Close graph. */
   free_closure ();
 
   /* Close graph. */

-  close_graph (&graph, fgraph);
+  close_graph (&static_graph, fgraph);

   xfclose (fgraph);
 }
   xfclose (fgraph);
 }