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   core *statep = state_table[state].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   int k;
  88   int state1;
  89   int symbol;
  90   shifts *shiftp;
  91   errs *errp;
  92   reductions *redp;
  93   static char buff[10];
  94   edge_t edge;
  95
  96   shiftp = state_table[state].shift_table;
  97   redp = state_table[state].reduction_table;
  98   errp = err_table[state];
  99
 100   if (!shiftp && !redp)
 101     {
 102 #if 0
 103       if (final_state == state)
 104         obstack_sgrow (node_obstack, "$default: accept");
 105       else
 106         obstack_sgrow (node_obstack, "NO ACTIONS");
 107 #endif
 108       return;
 109     }
 110
 111   if (shiftp)
 112     {
 113       k = shiftp->nshifts;
 114
 115       for (i = 0; i < k; i++)
 116         {
 117           if (!shiftp->shifts[i])
 118             continue;
 119           state1 = shiftp->shifts[i];
 120           symbol = state_table[state1].accessing_symbol;
 121
 122           if (ISVAR (symbol))
 123             break;
 124
 125           {
 126             new_edge (&edge);
 127
 128             if (state > state1)
 129               edge.type = back_edge;
 130             open_edge (&edge, fgraph);
 131             /* The edge source is the current node.  */
 132             edge.sourcename = node_name;
 133             sprintf (buff, "%d", state1);
 134             edge.targetname = buff;
 135             edge.color = (symbol == 0) ? red : blue;
 136             edge.label = tags[symbol];
 137             output_edge (&edge, fgraph);
 138             close_edge (fgraph);
 139           }
 140         }
 141     }
 142   else
 143     {
 144       i = 0;
 145       k = 0;
 146     }
 147
 148 #if 0
 149   if (errp)
 150     {
 151       int j, nerrs;
 152
 153       nerrs = errp->nerrs;
 154
 155       for (j = 0; j < nerrs; j++)
 156         {
 157           if (!errp->errs[j])
 158             continue;
 159           symbol = errp->errs[j];
 160           /* If something has been added in the NODE_OBSTACK after
 161              the declaration of the label, then we need a `\n'.
 162           if (obstack_object_size (node_obstack) > node_output_size)
 163             obstack_sgrow (node_obstack, "\n");
 164             */
 165           obstack_fgrow1 (node_obstack, _("%-4s\terror (nonassociative)"),
 166                           tags[symbol]);
 167         }
 168       if (j > 0)
 169         obstack_1grow (node_obstack, '\n');
 170     }
 171
 172   if (state_table[state].consistent && redp)
 173     {
 174       rule = redp->rules[0];
 175       symbol = rule_table[rule].lhs;
 176       /*
 177       if (obstack_object_size (node_obstack) > node_output_size)
 178         obstack_sgrow (node_obstack, "\n");
 179         */
 180       obstack_fgrow2 (node_obstack, _("$default\treduce using rule %d (%s)"),
 181                       rule, tags[symbol]);
 182     }
 183 #endif
 184
 185   if (i < k)
 186     {
 187       for (; i < k; i++)
 188         {
 189           if (!shiftp->shifts[i])
 190             continue;
 191           state1 = shiftp->shifts[i];
 192           symbol = state_table[state1].accessing_symbol;
 193
 194           new_edge (&edge);
 195           open_edge (&edge, fgraph);
 196           edge.sourcename = node_name;
 197           sprintf (buff, "%d", state1);
 198           edge.targetname = buff;
 199           edge.color = red;
 200           edge.label = tags[symbol];
 201           output_edge (&edge, fgraph);
 202           close_edge (fgraph);
 203         }
 204     }
 205 }
 206
 207
 208 /*-------------------------------------------------------------.
 209 | Output in FGRAPH the current node specifications and exiting |
 210 | edges.                                                       |
 211 `-------------------------------------------------------------*/
 212
 213 static void
 214 print_state (int state)
 215 {
 216   static char name[10];
 217   struct obstack node_obstack;
 218   node_t node;
 219
 220   /* The labels of the nodes are their the items.  */
 221   obstack_init (&node_obstack);
 222   new_node (&node);
 223   sprintf (name, "%d", state);
 224   node.title = name;
 225   print_core (state, &node_obstack);
 226   obstack_1grow (&node_obstack, '\0');
 227   node.label = obstack_finish (&node_obstack);
 228
 229   open_node (fgraph);
 230   output_node (&node, fgraph);
 231   close_node (fgraph);
 232
 233   /* Output the edges.  */
 234   print_actions (state, name);
 235
 236   obstack_free (&node_obstack, 0);
 237 }
 238 \f
 239
 240 void
 241 print_graph (void)
 242 {
 243   int i;
 244
 245   if (!graph_flag)
 246     return;
 247
 248   /* Output file.  */
 249   fgraph = xfopen (spec_graph_file, "w");
 250
 251   new_graph (&graph);
 252
 253 #if 0
 254   graph.smanhattan_edges = yes;
 255   graph.manhattan_edges = yes;
 256 #endif
 257
 258   graph.display_edge_labels = yes;
 259   graph.layoutalgorithm = normal;
 260
 261   graph.port_sharing = no;
 262   graph.finetuning = yes;
 263   graph.straight_phase = yes;
 264   graph.priority_phase = yes;
 265   graph.splines = yes;
 266
 267   graph.crossing_weight = median;
 268
 269   /* Output graph options. */
 270   open_graph (fgraph);
 271   output_graph (&graph, fgraph);
 272
 273   /* Output nodes and edges. */
 274   for (i = 0; i < nstates; i++)
 275     print_state (i);
 276
 277   /* Close graph. */
 278   close_graph (&graph, fgraph);
 279   xfclose (fgraph);
 280 }