src/print_graph.c

   1 /* Output a VCG description on generated parser, for Bison,
   2    Copyright 2001 Free Software Foundation, Inc.
   3
   4    This file is part of Bison, the GNU Compiler Compiler.
   5
   6    Bison is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    Bison is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with Bison; see the file COPYING.  If not, write to
  18    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "system.h"
  22 #include "files.h"
  23 #include "gram.h"
  24 #include "LR0.h"
  25 #include "lalr.h"
  26 #include "conflicts.h"
  27 #include "complain.h"
  28 #include "getargs.h"
  29 #include "state.h"
  30 #include "reader.h"
  31 #include "obstack.h"
  32 #include "print_graph.h"
  33 #include "vcg.h"
  34
  35 static graph_t graph;
  36 static FILE *fgraph = NULL;
  37
  38 /* This part will construct the label of nodes. */
  39 static void
  40 print_core (int state, struct obstack *node_obstack)
  41 {
  42   int i;
  43   state_t *statep = state_table[state];
  44
  45   if (!statep->nitems)
  46     return;
  47
  48   for (i = 0; i < statep->nitems; i++)
  49     {
  50       short *sp;
  51       short *sp1;
  52       int rule;
  53
  54       sp1 = sp = ritem + statep->items[i];
  55
  56       while (*sp > 0)
  57         sp++;
  58
  59       rule = -(*sp);
  60
  61       if (i)
  62         obstack_1grow (node_obstack, '\n');
  63       obstack_fgrow1 (node_obstack, "%d: ", rule);
  64       obstack_fgrow1 (node_obstack, " %s  ->  ",
  65                       tags[rule_table[rule].lhs]);
  66
  67       for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
  68         obstack_fgrow1 (node_obstack, "%s ", tags[*sp]);
  69
  70       obstack_1grow (node_obstack, '.');
  71
  72       for (/* Nothing */; *sp > 0; ++sp)
  73         obstack_fgrow1 (node_obstack, " %s", tags[*sp]);
  74     }
  75 }
  76
  77
  78 /*---------------------------------------------------------------.
  79 | Output in graph_obstack edges specifications in incidence with |
  80 | current node.                                                  |
  81 `---------------------------------------------------------------*/
  82
  83 static void
  84 print_actions (int state, const char *node_name)
  85 {
  86   int i;
  87
  88   shifts   *shiftp = state_table[state]->shifts;
  89   reductions *redp = state_table[state]->reductions;
  90 #if 0
  91   errs       *errp = state_table[state]->errs;
  92 #endif
  93
  94   static char buff[10];
  95   edge_t edge;
  96
  97   if (!shiftp->nshifts && !redp)
  98     {
  99 #if 0
 100       if (final_state == state)
 101         obstack_sgrow (node_obstack, "$default: accept");
 102       else
 103         obstack_sgrow (node_obstack, "NO ACTIONS");
 104 #endif
 105       return;
 106     }
 107
 108   for (i = 0; i < shiftp->nshifts; i++)
 109     if (!SHIFT_IS_DISABLED (shiftp, i))
 110       {
 111         int state1 = shiftp->shifts[i];
 112         int symbol = state_table[state1]->accessing_symbol;
 113
 114         new_edge (&edge);
 115
 116         if (state > state1)
 117           edge.type = back_edge;
 118         open_edge (&edge, fgraph);
 119         /* The edge source is the current node.  */
 120         edge.sourcename = node_name;
 121         sprintf (buff, "%d", state1);
 122         edge.targetname = buff;
 123         edge.color = (symbol == 0) ? red : blue;
 124         edge.label = tags[symbol];
 125         output_edge (&edge, fgraph);
 126         close_edge (fgraph);
 127       }
 128
 129 #if 0
 130   if (errp)
 131     {
 132       int j, nerrs;
 133
 134       nerrs = errp->nerrs;
 135
 136       for (j = 0; j < nerrs; j++)
 137         {
 138           if (!errp->errs[j])
 139             continue;
 140           symbol = errp->errs[j];
 141           /* If something has been added in the NODE_OBSTACK after
 142              the declaration of the label, then we need a `\n'.
 143           if (obstack_object_size (node_obstack) > node_output_size)
 144             obstack_sgrow (node_obstack, "\n");
 145             */
 146           obstack_fgrow1 (node_obstack, _("%-4s\terror (nonassociative)"),
 147                           tags[symbol]);
 148         }
 149       if (j > 0)
 150         obstack_1grow (node_obstack, '\n');
 151     }
 152
 153   if (state_table[state]->consistent && redp)
 154     {
 155       rule = redp->rules[0];
 156       symbol = rule_table[rule].lhs;
 157       /*
 158       if (obstack_object_size (node_obstack) > node_output_size)
 159         obstack_sgrow (node_obstack, "\n");
 160         */
 161       obstack_fgrow2 (node_obstack, _("$default\treduce using rule %d (%s)"),
 162                       rule, tags[symbol]);
 163     }
 164 #endif
 165
 166   if (i < shiftp->nshifts)
 167     for (; i < shiftp->nshifts; i++)
 168       if (!SHIFT_IS_DISABLED (shiftp, i))
 169         {
 170           int state1 = shiftp->shifts[i];
 171           int symbol = state_table[state1]->accessing_symbol;
 172
 173           new_edge (&edge);
 174           open_edge (&edge, fgraph);
 175           edge.sourcename = node_name;
 176           sprintf (buff, "%d", state1);
 177           edge.targetname = buff;
 178           edge.color = red;
 179           edge.label = tags[symbol];
 180           output_edge (&edge, fgraph);
 181           close_edge (fgraph);
 182         }
 183 }
 184
 185
 186 /*-------------------------------------------------------------.
 187 | Output in FGRAPH the current node specifications and exiting |
 188 | edges.                                                       |
 189 `-------------------------------------------------------------*/
 190
 191 static void
 192 print_state (int state)
 193 {
 194   static char name[10];
 195   struct obstack node_obstack;
 196   node_t node;
 197
 198   /* The labels of the nodes are their the items.  */
 199   obstack_init (&node_obstack);
 200   new_node (&node);
 201   sprintf (name, "%d", state);
 202   node.title = name;
 203   print_core (state, &node_obstack);
 204   obstack_1grow (&node_obstack, '\0');
 205   node.label = obstack_finish (&node_obstack);
 206
 207   open_node (fgraph);
 208   output_node (&node, fgraph);
 209   close_node (fgraph);
 210
 211   /* Output the edges.  */
 212   print_actions (state, name);
 213
 214   obstack_free (&node_obstack, 0);
 215 }
 216 \f
 217
 218 void
 219 print_graph (void)
 220 {
 221   int i;
 222
 223   if (!graph_flag)
 224     return;
 225
 226   /* Output file.  */
 227   fgraph = xfopen (spec_graph_file, "w");
 228
 229   new_graph (&graph);
 230
 231 #if 0
 232   graph.smanhattan_edges = yes;
 233   graph.manhattan_edges = yes;
 234 #endif
 235
 236   graph.display_edge_labels = yes;
 237   graph.layoutalgorithm = normal;
 238
 239   graph.port_sharing = no;
 240   graph.finetuning = yes;
 241   graph.straight_phase = yes;
 242   graph.priority_phase = yes;
 243   graph.splines = yes;
 244
 245   graph.crossing_weight = median;
 246
 247   /* Output graph options. */
 248   open_graph (fgraph);
 249   output_graph (&graph, fgraph);
 250
 251   /* Output nodes and edges. */
 252   for (i = 0; i < nstates; i++)
 253     print_state (i);
 254
 255   /* Close graph. */
 256   close_graph (&graph, fgraph);
 257   xfclose (fgraph);
 258 }