| 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 "quotearg.h" |
| 23 | #include "files.h" |
| 24 | #include "symtab.h" |
| 25 | #include "gram.h" |
| 26 | #include "LR0.h" |
| 27 | #include "lalr.h" |
| 28 | #include "conflicts.h" |
| 29 | #include "complain.h" |
| 30 | #include "getargs.h" |
| 31 | #include "state.h" |
| 32 | #include "reader.h" |
| 33 | #include "closure.h" |
| 34 | #include "obstack.h" |
| 35 | #include "print_graph.h" |
| 36 | #include "vcg.h" |
| 37 | |
| 38 | static graph_t graph; |
| 39 | static FILE *fgraph = NULL; |
| 40 | |
| 41 | |
| 42 | /*----------------------------. |
| 43 | | Construct the node labels. | |
| 44 | `----------------------------*/ |
| 45 | |
| 46 | static void |
| 47 | print_core (struct obstack *oout, state_t *state) |
| 48 | { |
| 49 | int i; |
| 50 | item_number_t *sitems = state->items; |
| 51 | int snritems = state->nitems; |
| 52 | |
| 53 | /* Output all the items of a state, not only its kernel. */ |
| 54 | if (report_flag & report_itemsets) |
| 55 | { |
| 56 | closure (sitems, snritems); |
| 57 | sitems = itemset; |
| 58 | snritems = nritemset; |
| 59 | } |
| 60 | |
| 61 | obstack_fgrow1 (oout, "state %2d\n", state->number); |
| 62 | for (i = 0; i < snritems; i++) |
| 63 | { |
| 64 | item_number_t *sp; |
| 65 | item_number_t *sp1; |
| 66 | rule_number_t rule; |
| 67 | |
| 68 | sp1 = sp = ritem + sitems[i]; |
| 69 | |
| 70 | while (*sp >= 0) |
| 71 | sp++; |
| 72 | |
| 73 | rule = item_number_as_rule_number (*sp); |
| 74 | |
| 75 | if (i) |
| 76 | obstack_1grow (oout, '\n'); |
| 77 | obstack_fgrow1 (oout, " %s -> ", |
| 78 | rules[rule].lhs->tag); |
| 79 | |
| 80 | for (sp = rules[rule].rhs; sp < sp1; sp++) |
| 81 | obstack_fgrow1 (oout, "%s ", symbols[*sp]->tag); |
| 82 | |
| 83 | obstack_1grow (oout, '.'); |
| 84 | |
| 85 | for (/* Nothing */; *sp >= 0; ++sp) |
| 86 | obstack_fgrow1 (oout, " %s", symbols[*sp]->tag); |
| 87 | |
| 88 | /* Experimental feature: display the lookaheads. */ |
| 89 | if (report_flag & report_lookaheads) |
| 90 | { |
| 91 | /* Find the reduction we are handling. */ |
| 92 | reductions_t *reds = state->reductions; |
| 93 | int redno = state_reduction_find (state, &rules[rule]); |
| 94 | |
| 95 | /* Print them if there are. */ |
| 96 | if (reds->lookaheads && redno != -1) |
| 97 | { |
| 98 | bitset_iterator biter; |
| 99 | int k; |
| 100 | int not_first = 0; |
| 101 | obstack_sgrow (oout, "["); |
| 102 | BITSET_FOR_EACH (biter, reds->lookaheads[redno], k, 0) |
| 103 | obstack_fgrow2 (oout, "%s%s", |
| 104 | not_first++ ? ", " : "", |
| 105 | symbols[k]->tag); |
| 106 | obstack_sgrow (oout, "]"); |
| 107 | } |
| 108 | } |
| 109 | } |
| 110 | } |
| 111 | |
| 112 | |
| 113 | /*---------------------------------------------------------------. |
| 114 | | Output in graph_obstack edges specifications in incidence with | |
| 115 | | current node. | |
| 116 | `---------------------------------------------------------------*/ |
| 117 | |
| 118 | static void |
| 119 | print_actions (state_t *state, const char *node_name) |
| 120 | { |
| 121 | int i; |
| 122 | |
| 123 | transitions_t *transitions = state->transitions; |
| 124 | reductions_t *redp = state->reductions; |
| 125 | |
| 126 | static char buff[10]; |
| 127 | edge_t edge; |
| 128 | |
| 129 | if (!transitions->num && !redp) |
| 130 | return; |
| 131 | |
| 132 | for (i = 0; i < transitions->num; i++) |
| 133 | if (!TRANSITION_IS_DISABLED (transitions, i)) |
| 134 | { |
| 135 | state_t *state1 = transitions->states[i]; |
| 136 | symbol_number_t symbol = state1->accessing_symbol; |
| 137 | |
| 138 | new_edge (&edge); |
| 139 | |
| 140 | if (state->number > state1->number) |
| 141 | edge.type = back_edge; |
| 142 | open_edge (&edge, fgraph); |
| 143 | /* The edge source is the current node. */ |
| 144 | edge.sourcename = node_name; |
| 145 | sprintf (buff, "%d", state1->number); |
| 146 | edge.targetname = buff; |
| 147 | /* Shifts are blue, gotos are green, and error is red. */ |
| 148 | if (TRANSITION_IS_ERROR (transitions, i)) |
| 149 | edge.color = red; |
| 150 | else |
| 151 | edge.color = TRANSITION_IS_SHIFT(transitions, i) ? blue : green; |
| 152 | edge.label = symbols[symbol]->tag; |
| 153 | output_edge (&edge, fgraph); |
| 154 | close_edge (fgraph); |
| 155 | } |
| 156 | } |
| 157 | |
| 158 | |
| 159 | /*-------------------------------------------------------------. |
| 160 | | Output in FGRAPH the current node specifications and exiting | |
| 161 | | edges. | |
| 162 | `-------------------------------------------------------------*/ |
| 163 | |
| 164 | static void |
| 165 | print_state (state_t *state) |
| 166 | { |
| 167 | static char name[10]; |
| 168 | struct obstack node_obstack; |
| 169 | node_t node; |
| 170 | |
| 171 | /* The labels of the nodes are their the items. */ |
| 172 | obstack_init (&node_obstack); |
| 173 | new_node (&node); |
| 174 | sprintf (name, "%d", state->number); |
| 175 | node.title = name; |
| 176 | print_core (&node_obstack, state); |
| 177 | obstack_1grow (&node_obstack, '\0'); |
| 178 | node.label = obstack_finish (&node_obstack); |
| 179 | |
| 180 | open_node (fgraph); |
| 181 | output_node (&node, fgraph); |
| 182 | close_node (fgraph); |
| 183 | |
| 184 | /* Output the edges. */ |
| 185 | print_actions (state, name); |
| 186 | |
| 187 | obstack_free (&node_obstack, 0); |
| 188 | } |
| 189 | \f |
| 190 | |
| 191 | void |
| 192 | print_graph (void) |
| 193 | { |
| 194 | state_number_t i; |
| 195 | |
| 196 | /* Output file. */ |
| 197 | fgraph = xfopen (spec_graph_file, "w"); |
| 198 | |
| 199 | new_graph (&graph); |
| 200 | |
| 201 | #if 0 |
| 202 | graph.smanhattan_edges = yes; |
| 203 | graph.manhattan_edges = yes; |
| 204 | #endif |
| 205 | |
| 206 | graph.display_edge_labels = yes; |
| 207 | graph.layoutalgorithm = normal; |
| 208 | |
| 209 | graph.port_sharing = no; |
| 210 | graph.finetuning = yes; |
| 211 | graph.straight_phase = yes; |
| 212 | graph.priority_phase = yes; |
| 213 | graph.splines = yes; |
| 214 | |
| 215 | graph.crossing_weight = median; |
| 216 | |
| 217 | /* Output graph options. */ |
| 218 | open_graph (fgraph); |
| 219 | output_graph (&graph, fgraph); |
| 220 | |
| 221 | /* Output nodes and edges. */ |
| 222 | new_closure (nritems); |
| 223 | for (i = 0; i < nstates; i++) |
| 224 | print_state (states[i]); |
| 225 | free_closure (); |
| 226 | |
| 227 | /* Close graph. */ |
| 228 | close_graph (&graph, fgraph); |
| 229 | xfclose (fgraph); |
| 230 | } |