X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ce4d5ce009fe91e1da3740abd9c5941521a1cd07..eeeb962b:/src/print_graph.c diff --git a/src/print_graph.c b/src/print_graph.c index 4430f00d..4d95a587 100644 --- a/src/print_graph.c +++ b/src/print_graph.c @@ -1,5 +1,5 @@ -/* Output a VCG description on generated parser, for bison, - Copyright 1984, 1986, 1989, 2000, 2001 Free Software Foundation, Inc. +/* Output a VCG description on generated parser, for Bison, + Copyright 2001 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -19,7 +19,6 @@ Boston, MA 02111-1307, USA. */ #include "system.h" -#include "xalloc.h" #include "files.h" #include "gram.h" #include "LR0.h" @@ -34,28 +33,24 @@ #include "vcg.h" static graph_t graph; +static FILE *fgraph = NULL; /* This part will construct the label of nodes. */ static void -print_core (int state) +print_core (int state, struct obstack *node_obstack) { int i; - int k; - int rule; - core *statep; - short *sp; - short *sp1; - - statep = state_table[state]; - k = statep->nitems; - - if (k == 0) + core *statep = state_table[state].state; + + if (!statep->nitems) return; - - obstack_sgrow(&graph_obstack, "\t\tlabel:\t\""); - for (i = 0; i < k; i++) + for (i = 0; i < statep->nitems; i++) { + short *sp; + short *sp1; + int rule; + sp1 = sp = ritem + statep->items[i]; while (*sp > 0) @@ -63,24 +58,30 @@ print_core (int state) rule = -(*sp); - obstack_fgrow1(&graph_obstack, _("%d: "), rule); - obstack_fgrow1(&graph_obstack, " %s -> ", tags[rlhs[rule]]); + if (i) + obstack_1grow (node_obstack, '\n'); + obstack_fgrow1 (node_obstack, "%d: ", rule); + obstack_fgrow1 (node_obstack, " %s -> ", + tags[rule_table[rule].lhs]); - for (sp = ritem + rrhs[rule]; sp < sp1; sp++) - obstack_fgrow1(&graph_obstack, "%s ", tags[*sp]); + for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++) + obstack_fgrow1 (node_obstack, "%s ", tags[*sp]); - obstack_1grow(&graph_obstack, '.'); - - while (*sp > 0) - obstack_fgrow1(&graph_obstack, " %s", tags[*sp++]); - - obstack_sgrow(&graph_obstack, "\\n"); + obstack_1grow (node_obstack, '.'); + + for (/* Nothing */; *sp > 0; ++sp) + obstack_fgrow1 (node_obstack, " %s", tags[*sp]); } - obstack_sgrow(&graph_obstack, "\"\n"); } + +/*---------------------------------------------------------------. +| Output in graph_obstack edges specifications in incidence with | +| current node. | +`---------------------------------------------------------------*/ + static void -print_actions (int state, node_t *node) +print_actions (int state, const char *node_name) { int i; int k; @@ -89,20 +90,21 @@ print_actions (int state, node_t *node) shifts *shiftp; errs *errp; reductions *redp; - int rule; static char buff[10]; edge_t edge; - - shiftp = shift_table[state]; - redp = reduction_table[state]; + + shiftp = state_table[state].shift_table; + redp = state_table[state].reduction_table; errp = err_table[state]; if (!shiftp && !redp) { +#if 0 if (final_state == state) - ;//fprintf(f, " $default\taccept\n"); + obstack_sgrow (node_obstack, "$default: accept"); else - ;//fprintf(f, " NO ACTIONS\n"); + obstack_sgrow (node_obstack, "NO ACTIONS"); +#endif return; } @@ -115,25 +117,26 @@ print_actions (int state, node_t *node) if (!shiftp->shifts[i]) continue; state1 = shiftp->shifts[i]; - symbol = accessing_symbol[state1]; + symbol = state_table[state1].accessing_symbol; if (ISVAR (symbol)) break; - + { new_edge (&edge); if (state > state1) edge.type = back_edge; - open_edge (&edge, &graph_obstack); - edge.sourcename = node->title; + open_edge (&edge, fgraph); + /* The edge source is the current node. */ + edge.sourcename = node_name; + sprintf (buff, "%d", state1); edge.targetname = buff; - sprintf (edge.targetname, "%d", state1); - edge.color = (symbol == 0) ? blue : red; + edge.color = (symbol == 0) ? red : blue; edge.label = tags[symbol]; - output_edge (&edge, &graph_obstack); - close_edge (&graph_obstack); - } + output_edge (&edge, fgraph); + close_edge (fgraph); + } } } else @@ -142,6 +145,7 @@ print_actions (int state, node_t *node) k = 0; } +#if 0 if (errp) { int j, nerrs; @@ -153,15 +157,31 @@ print_actions (int state, node_t *node) 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 (consistent[state] && redp) + + if (state_table[state].consistent && redp) { rule = redp->rules[0]; - symbol = rlhs[rule]; + 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 + if (i < k) { for (; i < k; i++) @@ -169,39 +189,51 @@ print_actions (int state, node_t *node) if (!shiftp->shifts[i]) continue; state1 = shiftp->shifts[i]; - symbol = accessing_symbol[state1]; + symbol = state_table[state1].accessing_symbol; new_edge (&edge); - open_edge (&edge, &graph_obstack); - edge.sourcename = node->title; + open_edge (&edge, fgraph); + edge.sourcename = node_name; + sprintf (buff, "%d", state1); edge.targetname = buff; edge.color = red; - sprintf (edge.targetname, "%d", state1); edge.label = tags[symbol]; - output_edge (&edge, &graph_obstack); - close_edge (&graph_obstack); + output_edge (&edge, fgraph); + close_edge (fgraph); } } } + +/*-------------------------------------------------------------. +| Output in FGRAPH the current node specifications and exiting | +| edges. | +`-------------------------------------------------------------*/ + static void print_state (int state) { static char name[10]; - node_t node; + struct obstack node_obstack; + node_t node; + /* The labels of the nodes are their the items. */ + obstack_init (&node_obstack); new_node (&node); - open_node (&graph_obstack); - - sprintf(name, "%d", state); - node.title = name; - output_node (&node, &graph_obstack); - - print_core (state); /* node label */ - - close_node (&graph_obstack); - - print_actions (state, &node); /* edges */ + sprintf (name, "%d", state); + node.title = name; + print_core (state, &node_obstack); + obstack_1grow (&node_obstack, '\0'); + node.label = obstack_finish (&node_obstack); + + open_node (fgraph); + output_node (&node, fgraph); + close_node (fgraph); + + /* Output the edges. */ + print_actions (state, name); + + obstack_free (&node_obstack, 0); } @@ -209,34 +241,40 @@ void print_graph (void) { int i; - + if (!graph_flag) - return ; + return; + + /* Output file. */ + fgraph = xfopen (spec_graph_file, "w"); + new_graph (&graph); - - /* graph.smanhattan_edges = yes; - graph.manhattan_edges = yes; */ - + +#if 0 + graph.smanhattan_edges = yes; + graph.manhattan_edges = yes; +#endif + graph.display_edge_labels = yes; - graph.layoutalgorithm = 0; - + graph.layoutalgorithm = normal; + graph.port_sharing = no; graph.finetuning = yes; graph.straight_phase = yes; graph.priority_phase = yes; graph.splines = yes; - + graph.crossing_weight = median; /* Output graph options. */ - open_graph (&graph_obstack); - output_graph (&graph, &graph_obstack); + open_graph (fgraph); + output_graph (&graph, fgraph); + /* Output nodes and edges. */ for (i = 0; i < nstates; i++) - /* Output nodes & edges. */ - print_state (i); + print_state (i); /* Close graph. */ - close_graph (&graph, &graph_obstack); + close_graph (&graph, fgraph); + xfclose (fgraph); } -