From: Akim Demaille Date: Mon, 6 Aug 2001 09:05:53 +0000 (+0000) Subject: * src/print_graph.c, src/print_graph.h (graph): New. X-Git-Tag: BISON-1_28c~47 X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/ce4d5ce009fe91e1da3740abd9c5941521a1cd07 * src/print_graph.c, src/print_graph.h (graph): New. * src/vcg.h: New file. * src/vcg.c: New file, VCG graph handling. --- diff --git a/ChangeLog b/ChangeLog index 5f5a829b..0bb065ea 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2001-08-06 Marc Autret + + * src/print_graph.c, src/print_graph.h (graph): New. + * src/vcg.h: New file. + * src/vcg.c: New file, VCG graph handling. + 2001-08-06 Marc Autret Add of %source_extension and %header_extension which specify diff --git a/src/print_graph.c b/src/print_graph.c new file mode 100644 index 00000000..4430f00d --- /dev/null +++ b/src/print_graph.c @@ -0,0 +1,242 @@ +/* Output a VCG description on generated parser, for bison, + Copyright 1984, 1986, 1989, 2000, 2001 Free Software Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + Bison is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + Bison is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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. */ + +#include "system.h" +#include "xalloc.h" +#include "files.h" +#include "gram.h" +#include "LR0.h" +#include "lalr.h" +#include "conflicts.h" +#include "complain.h" +#include "getargs.h" +#include "state.h" +#include "reader.h" +#include "obstack.h" +#include "print_graph.h" +#include "vcg.h" + +static graph_t graph; + +/* This part will construct the label of nodes. */ +static void +print_core (int state) +{ + int i; + int k; + int rule; + core *statep; + short *sp; + short *sp1; + + statep = state_table[state]; + k = statep->nitems; + + if (k == 0) + return; + + obstack_sgrow(&graph_obstack, "\t\tlabel:\t\""); + + for (i = 0; i < k; i++) + { + sp1 = sp = ritem + statep->items[i]; + + while (*sp > 0) + sp++; + + rule = -(*sp); + + obstack_fgrow1(&graph_obstack, _("%d: "), rule); + obstack_fgrow1(&graph_obstack, " %s -> ", tags[rlhs[rule]]); + + for (sp = ritem + rrhs[rule]; sp < sp1; sp++) + obstack_fgrow1(&graph_obstack, "%s ", tags[*sp]); + + obstack_1grow(&graph_obstack, '.'); + + while (*sp > 0) + obstack_fgrow1(&graph_obstack, " %s", tags[*sp++]); + + obstack_sgrow(&graph_obstack, "\\n"); + } + obstack_sgrow(&graph_obstack, "\"\n"); +} + +static void +print_actions (int state, node_t *node) +{ + int i; + int k; + int state1; + int symbol; + shifts *shiftp; + errs *errp; + reductions *redp; + int rule; + static char buff[10]; + edge_t edge; + + shiftp = shift_table[state]; + redp = reduction_table[state]; + errp = err_table[state]; + + if (!shiftp && !redp) + { + if (final_state == state) + ;//fprintf(f, " $default\taccept\n"); + else + ;//fprintf(f, " NO ACTIONS\n"); + return; + } + + if (shiftp) + { + k = shiftp->nshifts; + + for (i = 0; i < k; i++) + { + if (!shiftp->shifts[i]) + continue; + state1 = shiftp->shifts[i]; + symbol = accessing_symbol[state1]; + + if (ISVAR (symbol)) + break; + + { + new_edge (&edge); + + if (state > state1) + edge.type = back_edge; + open_edge (&edge, &graph_obstack); + edge.sourcename = node->title; + edge.targetname = buff; + sprintf (edge.targetname, "%d", state1); + edge.color = (symbol == 0) ? blue : red; + edge.label = tags[symbol]; + output_edge (&edge, &graph_obstack); + close_edge (&graph_obstack); + } + } + } + else + { + i = 0; + k = 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 (consistent[state] && redp) + { + rule = redp->rules[0]; + symbol = rlhs[rule]; + } + + if (i < k) + { + for (; i < k; i++) + { + if (!shiftp->shifts[i]) + continue; + state1 = shiftp->shifts[i]; + symbol = accessing_symbol[state1]; + + new_edge (&edge); + open_edge (&edge, &graph_obstack); + edge.sourcename = node->title; + edge.targetname = buff; + edge.color = red; + sprintf (edge.targetname, "%d", state1); + edge.label = tags[symbol]; + output_edge (&edge, &graph_obstack); + close_edge (&graph_obstack); + } + } +} + +static void +print_state (int state) +{ + static char name[10]; + node_t node; + + 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 */ +} + + +void +print_graph (void) +{ + int i; + + if (!graph_flag) + return ; + new_graph (&graph); + + /* graph.smanhattan_edges = yes; + graph.manhattan_edges = yes; */ + + graph.display_edge_labels = yes; + graph.layoutalgorithm = 0; + + 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); + + for (i = 0; i < nstates; i++) + /* Output nodes & edges. */ + print_state (i); + + /* Close graph. */ + close_graph (&graph, &graph_obstack); +} + diff --git a/src/print_graph.h b/src/print_graph.h new file mode 100644 index 00000000..1a76028b --- /dev/null +++ b/src/print_graph.h @@ -0,0 +1,26 @@ +/* Output a VCG description on generated parser, for bison, + Copyright 2000 Free Software Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + Bison is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + Bison is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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. */ + +#ifndef PRINT_H_ +# define PRINT_H_ + +void print_graph PARAMS ((void)); + +#endif /* !PRINT_H_ */ diff --git a/src/vcg.c b/src/vcg.c new file mode 100644 index 00000000..acaffc04 --- /dev/null +++ b/src/vcg.c @@ -0,0 +1,886 @@ +/* VCG description handler for Bison. + Copyright 2001 Free Software Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + Bison is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + Bison is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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. */ + +#include "system.h" +#include "vcg.h" +#include "vcg_defaults.h" +#include "xalloc.h" + +/* Initialize a graph with the default values. */ +void +new_graph (graph_t *g) +{ + g->title = G_TITLE; + g->label = G_LABEL; + + g->infos[0] = G_INFOS1; + g->infos[1] = G_INFOS2; + g->infos[2] = G_INFOS3; + + g->color = G_COLOR; + g->textcolor = G_TEXTCOLOR; + g->bordercolor = G_BORDERCOLOR; + + g->width = G_WIDTH; + g->height = G_HEIGHT; + g->borderwidth = G_BORDERWIDTH; + g->x = G_X; + g->y = G_Y; + g->folding = G_FOLDING; + g->shrink = G_SHRINK; + g->stretch = G_STRETCH; + + g->textmode = G_TEXTMODE; + g->shape = G_SHAPE; + + g->xmax = G_XMAX; /* Not output. */ + g->ymax = G_YMAX; /* Not output. */ + + g->xbase = G_XBASE; + g->ybase = G_YBASE; + + g->xspace = G_XSPACE; + g->yspace = G_YSPACE; + g->xlspace = G_XLSPACE; /* Not output. */ + + g->xraster = G_XRASTER; + g->yraster = G_YRASTER; + g->xlraster = G_XLRASTER; + + g->hidden = G_HIDDEN; /* No default value. */ + + g->classname = G_CLASSNAME; /* No class name association. */ + + g->layoutalgorithm = G_LAYOUTALGORITHM; + g->layout_downfactor = G_LAYOUT_DOWNFACTOR; + g->layout_upfactor = G_LAYOUT_UPFACTOR; + g->layout_nearfactor = G_LAYOUT_NEARFACTOR; + g->layout_splinefactor = G_LAYOUT_SPLINEFACTOR; + + g->late_edge_labels = G_LATE_EDGE_LABELS; + g->display_edge_labels = G_DISPLAY_EDGE_LABELS; + g->dirty_edge_labels = G_DIRTY_EDGE_LABELS; + g->finetuning = G_FINETUNING; + g->ignore_singles = G_IGNORE_SINGLES; + g->straight_phase = G_STRAIGHT_PHASE; + g->priority_phase = G_PRIORITY_PHASE; + g->manhattan_edges = G_MANHATTAN_EDGES; + g->smanhattan_edges = G_SMANHATTAN_EDGES; + g->near_edges = G_NEAR_EDGES; + + g->orientation = G_ORIENTATION; + g->node_alignement = G_NODE_ALIGNEMENT; + g->port_sharing = G_PORT_SHARING; + g->arrow_mode = G_ARROW_MODE; + g->treefactor = G_TREEFACTOR; + g->spreadlevel = G_SPREADLEVEL; + g->crossing_weight = G_CROSSING_WEIGHT; + g->crossing_phase2 = G_CROSSING_PHASE2; + g->crossing_optimization = G_CROSSING_OPTIMIZATION; + g->view = G_VIEW; + + g->edges = G_EDGES; + g->nodes = G_NODES; + g->splines = G_SPLINES; + + g->bmax = G_BMAX; + g->cmin = G_CMIN; + g->cmax = G_CMAX; + g->pmin = G_PMIN; + g->pmax = G_PMAX; + g->rmin = G_RMIN; + g->rmax = G_RMAX; + g->smax = G_SMAX; + + g->node_list = G_NODE_LIST; + g->edge_list = G_EDGE_LIST; + + new_edge(&g->edge); + new_node(&g->node); +} + +/* Initialize a node with the defalut values. */ +void +new_node (node_t *node) +{ + node->title = N_TITLE; + node->label = N_LABEL; + + node->locx = N_LOCX; /* Default unspcified. */ + node->locy = N_LOCY; /* Default unspcified. */ + + node->vertical_order = N_VERTICAL_ORDER; /* Default unspcified. */ + node->horizontal_order = N_HORIZONTAL_ORDER; /* Default unspcified. */ + + node->width = N_WIDTH; /* We assume that we can't define it now. */ + node->height = N_HEIGHT; /* Also. */ + + node->shrink = N_SHRINK; + node->stretch = N_STRETCH; + + node->folding = N_FOLDING; /* No explicit default value. */ + + node->shape = N_SHAPE; + node->textmode = N_TEXTMODE; + node->borderwidth = N_BORDERWIDTH; + + node->color = N_COLOR; + node->textcolor = N_TEXTCOLOR; + node->bordercolor = N_BORDERCOLOR; + + node->infos[0] = N_INFOS1; + node->infos[1] = N_INFOS2; + node->infos[2] = N_INFOS3; + + node->next = N_NEXT; +} + +/* Initialize a edge with the defalut values. */ +void +new_edge (edge_t *edge) +{ + edge->type = E_EDGE_TYPE; + + edge->sourcename = E_SOURCENAME; + edge->targetname = E_TARGETNAME; + edge->label = E_LABEL; + + edge->linestyle = E_LINESTYLE; + edge->thickness = E_THICKNESS; + + edge->class = E_CLASS; + + edge->color = E_COLOR; + edge->textcolor = E_TEXTCOLOR; + edge->arrowcolor = E_ARROWCOLOR; + edge->backarrowcolor = E_BACKARROWCOLOR; + + edge->arrowsize = E_ARROWSIZE; + edge->backarrowsize = E_BACKARROWSIZE; + edge->arrowstyle = E_ARROWSTYLE; + + edge->backarrowstyle = E_BACKARROWSTYLE; + + edge->priority = E_PRIORITY; + + edge->anchor = E_ANCHOR; + + edge->horizontal_order = E_HORIZONTAL_ORDER; + + edge->next = E_NEXT; +} + +/*----------------------------------------------. +| Get functions. | +| Return string corresponding to an enum value. | +`----------------------------------------------*/ + +static const char * +get_color_str (enum color_e c) +{ + switch (c) + { + case white: return ("white"); + case blue: return ("blue"); + case red: return ("red"); + case green: return ("green"); + case yellow: return ("yellow"); + case magenta: return ("magenta"); + case cyan: return ("cyan"); + case darkgrey: return ("darkgrey"); + case darkblue: return ("darkblue"); + case darkred: return ("darkred"); + case darkgreen: return ("darkgreen"); + case darkyellow: return ("darkyellow"); + case darkmagenta: return ("darkmagenta"); + case darkcyan: return ("darkcyan"); + case gold: return ("gold"); + case lightgrey: return ("lightgrey"); + case lightblue: return ("lightblue"); + case lightred: return ("lightred"); + case lightgreen: return ("lightgreen"); + case lightyellow: return ("lightyellow"); + case lightmagenta: return ("lightmagenta"); + case lightcyan: return ("lightcyan"); + case lilac: return ("lilac"); + case turquoise: return ("turquoise"); + case aquamarine: return ("aquamarine"); + case khaki: return ("khaki"); + case purple: return ("purple"); + case yellowgreen: return ("yellowgreen"); + case pink: return ("pink"); + case orange: return ("orange"); + case orchid: return ("orchid"); + case black: return ("black"); + default: + complain (_("vcg graph: no such a color.")); + return (get_color_str(G_COLOR)); + } + return NULL; +} + +static const char * +get_textmode_str (enum textmode_e t) +{ + switch (t) + { + case centered: return ("center"); + case left_justify: return ("left_justify"); + case right_justify: return ("right_justify"); + default: + complain (_("vcg graph: no such a text mode..")); + return (get_textmode_str(G_TEXTMODE)); + } + return NULL; +} + +static const char * +get_shape_str (enum shape_e s) +{ + switch (s) + { + case box: return ("box"); + case rhomb: return ("rhomb"); + case ellipse: return ("ellipse"); + case triangle: return ("triangle"); + default: + complain (_("vcg graph: no such a shape..")); + return (get_shape_str(G_SHAPE)); + } + return NULL; +} + +static const char * +get_layoutalgorithm_str (enum layoutalgorithm_e l) +{ + switch (l) + { + case normal: return ("normal"); + case maxdepth: return ("maxdepth"); + case mindepth: return ("mindepth"); + case maxdepthslow: return ("maxdepthslow"); + case mindepthslow: return ("mindepthslow"); + case maxdegree: return ("maxdegree"); + case mindegree: return ("mindegree"); + case maxindegree: return ("maxindegree"); + case minindegree: return ("minindegree"); + case maxoutdegree: return ("maxoutdegree"); + case minoutdegree: return ("minoutdegree"); + case minbackward: return ("minbackward"); + case dfs: return ("dfs"); + case tree: return ("tree"); + default: + return ("normal"); + } + return NULL; +} + +static const char * +get_decision_str (enum decision_e d, enum decision_e defaults) +{ + switch (d) + { + case no: return ("no"); + case yes: return ("yes"); + default: + complain (_("vcg graph: no such a decision..")); + return (get_decision_str(defaults, 0)); + } + return NULL; +} + +static const char * +get_orientation_str (enum orientation_e o) +{ + switch (o) + { + case top_to_bottom: return ("top_to_bottom"); + case bottom_to_top: return ("bottom_to_top"); + case left_to_right: return ("left_to_right"); + case right_to_left: return ("right_to_left"); + default: + complain (_("vcg graph: no such an orientation..")); + return (get_orientation_str(G_ORIENTATION)); + } + return NULL; +} + +static const char * +get_node_alignement_str (enum alignement_e a) +{ + switch (a) + { + case center: return ("center"); + case top: return ("top"); + case bottom: return ("bottom"); + default: + complain (_("vcg graph: no such an alignement..")); + return (get_node_alignement_str(G_NODE_ALIGNEMENT)); + } + return NULL; +} + +static const char * +get_arrow_mode_str (enum arrow_mode_e a) +{ + switch (a) + { + case fixed: return ("fixed"); + case free_a: return ("free"); + default: + complain (_("vcg graph: no such an arrow mode..")); + return (get_arrow_mode_str(G_ARROW_MODE)); + } + return NULL; +} + +static const char * +get_crossing_type_str (enum crossing_type_e c) +{ + switch (c) + { + case bary: return ("bary"); + case median: return ("median"); + case barymedian: return ("barymedian"); + case medianbary: return ("medianbary"); + default: + complain (_("vcg graph: no such a crossing_type..")); + return (get_crossing_type_str(G_CROSSING_WEIGHT)); + } + return NULL; +} + +static const char * +get_view_str (enum view_e v) +{ + switch (v) + { + case normal_view: return ("normal_view"); + case cfish: return ("cfish"); + case pfish: return ("pfish"); + case fcfish: return ("fcfish"); + case fpfish: return ("fpfish"); + default: + complain (_("vcg graph: no such a view..")); + return (get_view_str(G_VIEW)); + } + return NULL; +} + +static const char * +get_linestyle_str (enum linestyle_e l) +{ + switch (l) + { + case continuous: return ("continuous"); + case dashed: return ("dashed"); + case dotted: return ("dotted"); + case invisible: return ("invisible"); + default: + complain (_("vcg graph: no such a linestyle..")); + return (get_linestyle_str(E_LINESTYLE)); + } + return NULL; +} + +static const char * +get_arrowstyle_str (enum arrowstyle_e a) +{ + switch (a) + { + case solid: return ("solid"); + case line: return ("line"); + case none: return ("none"); + default: + complain (_("vcg graph: no such an arrowstyle..")); + return (get_arrowstyle_str(E_ARROWSTYLE)); + } + return NULL; +} + +/*----------------------------. +| Add functions. | +| Edge and Nodes int a graph. | +`----------------------------*/ + +void +add_node (graph_t *graph, node_t *node) +{ + node->next = graph->node_list; + graph->node_list = node; +} + +void +add_edge (graph_t *graph, edge_t *edge) +{ + edge->next = graph->edge_list; + graph->edge_list = edge; +} + +/*-------------------------------------. +| Open and close functions (formatted) | +`-------------------------------------*/ + +void +open_edge(edge_t *edge, struct obstack *os) +{ + switch (edge->type) + { + case normal_edge: + obstack_sgrow (os, "\tedge: {\n"); + break; + case back_edge: + obstack_sgrow (os, "\tbackedge: {\n"); + break; + case near_edge: + obstack_sgrow (os, "\tnearedge: {\n"); + break; + case bent_near_edge: + obstack_sgrow (os, "\tbentnearedge: {\n"); + break; + default: + obstack_sgrow (os, "\tedge: {\n"); + } +} + +void +close_edge(struct obstack *os) +{ + obstack_sgrow (os, "\t}\n"); +} + +void +open_node(struct obstack *os) +{ + obstack_sgrow (os, "\tnode: {\n"); +} + +void +close_node(struct obstack *os) +{ + obstack_sgrow (os, "\t}\n"); +} + +void +open_graph(struct obstack *os) +{ + obstack_sgrow (os, "graph: {\n"); +} + +void +close_graph(graph_t *graph, struct obstack *os) +{ + obstack_1grow (os, '\n'); + + { + node_t *node; + + for (node = graph->node_list; node; node = node->next) + { + open_node (os); + output_node (node, os); + close_node (os); + } + } + + obstack_1grow (os, '\n'); + + { + edge_t *edge; + + for (edge = graph->edge_list; edge; edge = edge->next) + { + open_edge (edge, os); + output_edge (edge, os); + close_edge (os); + } + } + + obstack_sgrow (os, "}\n"); +} + +/*-------------------------------------------. +| Output functions (formatted) in obstack os | +`-------------------------------------------*/ + +void +output_node (node_t *node, struct obstack *os) +{ + if (node->title != N_TITLE) + obstack_fgrow1 (os, "\t\ttitle:\t\"%s\"\n", node->title); + if (node->label != N_LABEL) + obstack_fgrow1 (os, "\t\tlabel:\t\"%s\"\n", node->label); + + if ((node->locx != N_LOCX) && (node->locy != N_LOCY)) + obstack_fgrow2 (os, "\t\tloc { x: %d y: %d }\t\n", node->locx, node->locy); + + if (node->vertical_order != N_VERTICAL_ORDER) + obstack_fgrow1 (os, "\t\tvertical_order:\t%d\n", node->vertical_order); + if (node->horizontal_order != N_HORIZONTAL_ORDER) + obstack_fgrow1 (os, "\t\thorizontal_order:\t%d\n", node->horizontal_order); + + if (node->width != N_WIDTH) + obstack_fgrow1 (os, "\t\twidth:\t%d\n", node->width); + if (node->height != N_HEIGHT) + obstack_fgrow1 (os, "\t\theight:\t%d\n", node->height); + + if (node->shrink != N_SHRINK) + obstack_fgrow1 (os, "\t\tshrink:\t%d\n", node->shrink); + if (node->stretch != N_STRETCH) + obstack_fgrow1 (os, "\t\tshrink:\t%d\n", node->shrink); + + if (node->folding != N_FOLDING) + obstack_fgrow1 (os, "\t\tfolding:\t%d\n", node->folding); + + if (node->textmode != N_TEXTMODE) + obstack_fgrow1 (os, "\t\ttextmode:\t%s\n", + get_textmode_str (node->textmode)); + + if (node->shape != N_SHAPE) + obstack_fgrow1 (os, "\t\tshape:\t%s\n", get_shape_str (node->shape)); + + if (node->borderwidth != N_BORDERWIDTH) + obstack_fgrow1 (os, "\t\tborderwidth:\t%d\n", node->borderwidth); + + if (node->color != N_COLOR) + obstack_fgrow1 (os, "\t\tcolor:\t%s\n", get_color_str (node->color)); + if (node->textcolor != N_TEXTCOLOR) + obstack_fgrow1 (os, "\t\ttextcolor:\t%s\n", + get_color_str (node->textcolor)); + if (node->bordercolor != N_BORDERCOLOR) + obstack_fgrow1 (os, "\t\tbordercolor:\t%s\n", + get_color_str (node->bordercolor)); + + if (node->infos[0]) + obstack_fgrow1 (os, "\t\tinfo1:\t\"%s\"\n", node->infos[0]); + if (node->infos[1]) + obstack_fgrow1 (os, "\t\tinfo2:\t\"%s\"\n", node->infos[1]); + if (node->infos[2]) + obstack_fgrow1 (os, "\t\tinfo3:\t\"%s\"\n", node->infos[2]); +} + +void +output_edge (edge_t *edge, struct obstack *os) +{ + + if (edge->sourcename != E_SOURCENAME) + obstack_fgrow1 (os, "\t\tsourcename:\t\"%s\"\n", edge->sourcename); + if (edge->targetname != E_TARGETNAME) + obstack_fgrow1 (os, "\t\ttargetname:\t\"%s\"\n", edge->targetname); + + if (edge->label != E_LABEL) + obstack_fgrow1 (os, "\t\tlabel:\t\"%s\"\n", edge->label); + + if (edge->linestyle != E_LINESTYLE) + obstack_fgrow1 (os, "\t\tlinestyle:\t\"%s\"\n", + get_linestyle_str(edge->linestyle)); + + if (edge->thickness != E_THICKNESS) + obstack_fgrow1 (os, "\t\tthickness:\t%d\n", edge->thickness); + if (edge->class != E_CLASS) + obstack_fgrow1 (os, "\t\tclass:\t%d\n", edge->class); + + if (edge->color != E_COLOR) + obstack_fgrow1 (os, "\t\tcolor:\t%s\n", get_color_str (edge->color)); + if (edge->color != E_TEXTCOLOR) + obstack_fgrow1 (os, "\t\ttextcolor:\t%s\n", + get_color_str (edge->textcolor)); + if (edge->arrowcolor != E_ARROWCOLOR) + obstack_fgrow1 (os, "\t\tarrowcolor:\t%s\n", + get_color_str (edge->arrowcolor)); + if (edge->backarrowcolor != E_BACKARROWCOLOR) + obstack_fgrow1 (os, "\t\tbackarrowcolor:\t%s\n", + get_color_str (edge->backarrowcolor)); + + if (edge->arrowsize != E_ARROWSIZE) + obstack_fgrow1 (os, "\t\tarrowsize:\t%d\n", edge->arrowsize); + if (edge->backarrowsize != E_BACKARROWSIZE) + obstack_fgrow1 (os, "\t\tbackarrowsize:\t%d\n", edge->backarrowsize); + + if (edge->arrowstyle != E_ARROWSTYLE) + obstack_fgrow1 (os, "\t\tarrowstyle:\t%s\n", + get_arrowstyle_str(edge->arrowstyle)); + if (edge->backarrowstyle != E_BACKARROWSTYLE) + obstack_fgrow1 (os, "\t\tbackarrowstyle:\t%s\n", + get_arrowstyle_str(edge->backarrowstyle)); + + if (edge->priority != E_PRIORITY) + obstack_fgrow1 (os, "\t\tpriority:\t%d\n", edge->priority); + if (edge->anchor != E_ANCHOR) + obstack_fgrow1 (os, "\t\tanchor:\t%d\n", edge->anchor); + if (edge->horizontal_order != E_HORIZONTAL_ORDER) + obstack_fgrow1 (os, "\t\thorizontal_order:\t%d\n", edge->horizontal_order); +} + +void +output_graph (graph_t *graph, struct obstack *os) +{ + if (graph->title) + obstack_fgrow1 (os, "\ttitle:\t\"%s\"\n", graph->title); + if (graph->label) + obstack_fgrow1 (os, "\tlabel:\t\"%s\"\n", graph->label); + + if (graph->infos[0]) + obstack_fgrow1 (os, "\tinfo1:\t\"%s\"\n", graph->infos[0]); + if (graph->infos[1]) + obstack_fgrow1 (os, "\tinfo2:\t\"%s\"\n", graph->infos[1]); + if (graph->infos[2]) + obstack_fgrow1 (os, "\tinfo3:\t\"%s\"\n", graph->infos[2]); + + if (graph->color != G_COLOR) + obstack_fgrow1 (os, "\tcolor:\t%s\n", get_color_str (graph->color)); + if (graph->textcolor != G_TEXTCOLOR) + obstack_fgrow1 (os, "\ttextcolor:\t%s\n", get_color_str (graph->textcolor)); + if (graph->bordercolor != G_BORDERCOLOR) + obstack_fgrow1 (os, "\tbordercolor:\t%s\n", + get_color_str (graph->bordercolor)); + + if (graph->width != G_WIDTH) + obstack_fgrow1 (os, "\twidth:\t%d\n", graph->width); + if (graph->height != G_HEIGHT) + obstack_fgrow1 (os, "\theight:\t%d\n", graph->height); + if (graph->borderwidth != G_BORDERWIDTH) + obstack_fgrow1 (os, "\tborderwidth:\t%d\n", graph->borderwidth); + + if (graph->x != G_X) + obstack_fgrow1 (os, "\tx:\t%d\n", graph->x); + if (graph->y != G_Y) + obstack_fgrow1 (os, "\ty:\t%d\n", graph->y); + + if (graph->folding != G_FOLDING) + obstack_fgrow1 (os, "\tfolding:\t%d\n", graph->folding); + + if (graph->shrink != G_SHRINK) + obstack_fgrow1 (os, "\tshrink:\t%d\n", graph->shrink); + if (graph->stretch != G_STRETCH) + obstack_fgrow1 (os, "\tstretch:\t%d\n", graph->stretch); + + if (graph->textmode != G_TEXTMODE) + obstack_fgrow1 (os, "\ttextmode:\t%s\n", + get_textmode_str (graph->textmode)); + + if (graph->shape != G_SHAPE) + obstack_fgrow1 (os, "\tshape:\t%s\n", get_shape_str (graph->shape)); + + if (graph->xmax != G_XMAX) + obstack_fgrow1 (os, "\txmax:\t%d\n", graph->xmax); + if (graph->ymax != G_YMAX) + obstack_fgrow1 (os, "\tymax:\t%d\n", graph->ymax); + + if (graph->xbase != G_XBASE) + obstack_fgrow1 (os, "\txbase:\t%d\n", graph->xbase); + if (graph->ybase != G_YBASE) + obstack_fgrow1 (os, "\tybase:\t%d\n", graph->ybase); + + if (graph->xspace != G_XSPACE) + obstack_fgrow1 (os, "\txspace:\t%d\n", graph->xspace); + if (graph->yspace != G_YSPACE) + obstack_fgrow1 (os, "\tyspace:\t%d\n", graph->yspace); + if (graph->xlspace != G_XLSPACE) + obstack_fgrow1 (os, "\txlspace:\t%d\n", graph->xlspace); + + if (graph->xraster != G_XRASTER) + obstack_fgrow1 (os, "\txraster:\t%d\n", graph->xraster); + if (graph->yraster != G_YRASTER) + obstack_fgrow1 (os, "\tyraster:\t%d\n", graph->yraster); + if (graph->xlraster != G_XLRASTER) + obstack_fgrow1 (os, "\txlraster:\t%d\n", graph->xlraster); + + if (graph->hidden != G_HIDDEN) + obstack_fgrow1 (os, "\thidden:\t%d\n", graph->hidden); + + if (graph->classname != G_CLASSNAME) + { + struct classname_s *ite; + + for (ite = graph->classname; ite; ite = ite->next) + obstack_fgrow2 (os, "\tclassname %d :\t%s\n", ite->no, ite->name); + } + + if (graph->layoutalgorithm != G_LAYOUTALGORITHM) + obstack_fgrow1 (os, "\tlayoutalgorithm:\t%s\n", + get_layoutalgorithm_str(graph->layoutalgorithm)); + + if (graph->layout_downfactor != G_LAYOUT_DOWNFACTOR) + obstack_fgrow1 (os, "\tlayout_downfactor:\t%d\n", graph->layout_downfactor); + if (graph->layout_upfactor != G_LAYOUT_UPFACTOR) + obstack_fgrow1 (os, "\tlayout_upfactor:\t%d\n", graph->layout_upfactor); + if (graph->layout_nearfactor != G_LAYOUT_NEARFACTOR) + obstack_fgrow1 (os, "\tlayout_nearfactor:\t%d\n", graph->layout_nearfactor); + if (graph->layout_splinefactor != G_LAYOUT_SPLINEFACTOR) + obstack_fgrow1 (os, "\tlayout_splinefactor:\t%d\n", + graph->layout_splinefactor); + + if (graph->late_edge_labels != G_LATE_EDGE_LABELS) + obstack_fgrow1 (os, "\tlate_edge_labels:\t%s\n", + get_decision_str(graph->late_edge_labels, + G_LATE_EDGE_LABELS)); + if (graph->display_edge_labels != G_DISPLAY_EDGE_LABELS) + obstack_fgrow1 (os, "\tdisplay_edge_labels:\t%s\n", + get_decision_str(graph->display_edge_labels, + G_DISPLAY_EDGE_LABELS)); + if (graph->dirty_edge_labels != G_DIRTY_EDGE_LABELS) + obstack_fgrow1 (os, "\tdirty_edge_labels:\t%s\n", + get_decision_str(graph->dirty_edge_labels, + G_DIRTY_EDGE_LABELS)); + if (graph->finetuning != G_FINETUNING) + obstack_fgrow1 (os, "\tfinetuning:\t%s\n", + get_decision_str(graph->finetuning, G_FINETUNING)); + if (graph->ignore_singles != G_IGNORE_SINGLES) + obstack_fgrow1 (os, "\tignore_singles:\t%s\n", + get_decision_str(graph->ignore_singles, G_IGNORE_SINGLES)); + if (graph->straight_phase != G_STRAIGHT_PHASE) + obstack_fgrow1 (os, "\tstraight_phase:\t%s\n", + get_decision_str(graph->straight_phase, G_STRAIGHT_PHASE)); + if (graph->priority_phase != G_PRIORITY_PHASE) + obstack_fgrow1 (os, "\tpriority_phase:\t%s\n", + get_decision_str(graph->priority_phase, G_PRIORITY_PHASE)); + if (graph->manhattan_edges != G_MANHATTAN_EDGES) + obstack_fgrow1 (os, + "\tmanhattan_edges:\t%s\n", + get_decision_str(graph->manhattan_edges, + G_MANHATTAN_EDGES)); + if (graph->smanhattan_edges != G_SMANHATTAN_EDGES) + obstack_fgrow1 (os, + "\tsmanhattan_edges:\t%s\n", + get_decision_str(graph->smanhattan_edges, + G_SMANHATTAN_EDGES)); + if (graph->near_edges != G_NEAR_EDGES) + obstack_fgrow1 (os, "\tnear_edges:\t%s\n", + get_decision_str(graph->near_edges, G_NEAR_EDGES)); + + if (graph->orientation != G_ORIENTATION) + obstack_fgrow1 (os, "\torientation:\t%s\n", + get_decision_str(graph->orientation, G_ORIENTATION)); + + if (graph->node_alignement != G_NODE_ALIGNEMENT) + obstack_fgrow1 (os, "\tnode_alignement:\t%s\n", + get_decision_str(graph->node_alignement, + G_NODE_ALIGNEMENT)); + + if (graph->port_sharing != G_PORT_SHARING) + obstack_fgrow1 (os, "\tport_sharing:\t%s\n", + get_decision_str(graph->port_sharing, G_PORT_SHARING)); + + if (graph->arrow_mode != G_ARROW_MODE) + obstack_fgrow1 (os, "\tarrow_mode:\t%s\n", + get_arrow_mode_str(graph->arrow_mode)); + + if (graph->treefactor != G_TREEFACTOR) + obstack_fgrow1 (os, "\ttreefactor:\t%f\n", graph->treefactor); + if (graph->spreadlevel != G_SPREADLEVEL) + obstack_fgrow1 (os, "\tspreadlevel:\t%d\n", graph->spreadlevel); + + if (graph->crossing_weight != G_CROSSING_WEIGHT) + obstack_fgrow1 (os, "\tcrossing_weight:\t%s\n", + get_crossing_type_str(graph->crossing_weight)); + if (graph->crossing_phase2 != G_CROSSING_PHASE2) + obstack_fgrow1 (os, "\tcrossing_phase2:\t%s\n", + get_decision_str(graph->crossing_phase2, + G_CROSSING_PHASE2)); + if (graph->crossing_optimization != G_CROSSING_OPTIMIZATION) + obstack_fgrow1 (os, "\tcrossing_optimization:\t%s\n", + get_decision_str(graph->crossing_optimization, + G_CROSSING_OPTIMIZATION)); + + if (graph->view != G_VIEW) + obstack_fgrow1 (os, "\tview:\t%s\n", get_view_str(graph->view)); + + if (graph->edges != G_EDGES) + obstack_fgrow1 (os, "\tedges:\t%s\n", get_decision_str(graph->edges, + G_EDGES)); + + if (graph->nodes != G_NODES) + obstack_fgrow1 (os,"\tnodes:\t%s\n", + get_decision_str(graph->nodes, G_NODES)); + + if (graph->splines != G_SPLINES) + obstack_fgrow1 (os, "\tsplines:\t%s\n", + get_decision_str(graph->splines, G_SPLINES)); + + if (graph->bmax != G_BMAX) + obstack_fgrow1 (os, "\tbmax:\t%d\n", graph->bmax); + if (graph->cmin != G_CMIN) + obstack_fgrow1 (os, "\tcmin:\t%d\n", graph->cmin); + if (graph->cmax != G_CMAX) + obstack_fgrow1 (os, "\tcmax:\t%d\n", graph->cmax); + if (graph->pmin != G_PMIN) + obstack_fgrow1 (os, "\tpmin:\t%d\n", graph->pmin); + if (graph->pmax != G_PMAX) + obstack_fgrow1 (os, "\tpmax:\t%d\n", graph->pmax); + if (graph->rmin != G_RMIN) + obstack_fgrow1 (os, "\trmin:\t%d\n", graph->rmin); + if (graph->rmax != G_RMAX) + obstack_fgrow1 (os, "\trmax:\t%d\n", graph->rmax); + if (graph->smax != G_SMAX) + obstack_fgrow1 (os, "\tsmax:\t%d\n", graph->smax); +} + +#ifdef NDEBUG + +int main () +{ + graph_t graph; + node_t *node; + edge_t *edge; + struct obstack graph_obstack; + + obstack_init (&graph_obstack); + + new_graph(&graph); + + graph.title = "graph_title"; + graph.label = "graph_label"; + graph.color = yellow; + graph.textcolor = green; + graph.width = 5; + graph.x = 12; + graph.y = 17; + graph.textmode = right_justify; + + open_graph (&graph, stdout); + + node = XMALLOC (node_t, 1); + new_node (node); + node->title = "A"; + node->locx = 12; + node->locy = 71; + add_node (&graph, node); + + node = XMALLOC (node_t, 1); + new_node (node); + node->title = "B"; + add_node (&graph, node); + + edge = XMALLOC (edge_t, 1); + new_edge (edge); + edge->sourcename = "B"; + edge->targetname = "A"; + add_edge (&graph, edge); + + output_graph(&graph, stdout); + close_graph (&graph, stdout); + + obstack_save (&graph_obstack, "essai.vcg"); + + return (0); +} + +#endif /* not DEBUG */ diff --git a/src/vcg.h b/src/vcg.h new file mode 100644 index 00000000..c2ccfaba --- /dev/null +++ b/src/vcg.h @@ -0,0 +1,975 @@ +/* VCG description handler for Bison. + Copyright 2001 Free Software Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + Bison is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + Bison is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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. */ + +#ifndef VCG_H_ +# define VCG_H_ + +/* VCG color map. The 32 prime predefined colors. */ +enum color_e +{ + white = 0, + blue, + red, + green = 3, + yellow, + magenta, + cyan = 6, + darkgrey, + darkblue, + darkred = 9, + darkgreen, + darkyellow, + darkmagenta = 12, + darkcyan, + gold, + lightgrey = 15, + lightblue, + lightred, + lightgreen = 18, + lightyellow, + lightmagenta, + lightcyan = 21, + lilac, + turquoise, + aquamarine = 24, + khaki, + purple, + yellowgreen = 27, + pink, + orange, + orchid, + black = 31 +}; + +/* VCG textmode. Specify the adjustement of the text within the border of a summary node. */ +enum textmode_e +{ + centered, + left_justify, + right_justify +}; + +/* VCG shapes. Used for nodes shapes. */ +enum shape_e +{ + box, + rhomb, + ellipse, + triangle +}; + +/* Structure to construct lists of classnames. */ +struct classname_s +{ + int no; /* Class number */ + char *name; /* Name associated to the class no. */ + struct classname_s *next; /* next name class association. */ +}; + +/* Layout Algorithms which can be found in VCG. + Details about each algoithm can be found below. */ +enum layoutalgorithm_e +{ + normal, + maxdepth, + mindepth, + maxdepthslow, + mindepthslow, + maxdegree, + mindegree, + maxindegree, + minindegree, + maxoutdegree, + minoutdegree, + minbackward, + dfs, + tree +}; + +/* VCG decision yes/no. */ +enum decision_e +{ + yes, + no +}; + +/* VCG graph orientation. */ +enum orientation_e +{ + top_to_bottom, + bottom_to_top, + left_to_right, + right_to_left +}; + +/* VCG alignement for node alignement. */ +enum alignement_e +{ + center, + top, + bottom +}; + +/* VCG arrow mode. */ +enum arrow_mode_e +{ + fixed, + free_a +}; + +/* VCG crossing weight type. */ +enum crossing_type_e +{ + bary, + median, + barymedian, + medianbary +}; + +/* VCG views. */ +enum view_e +{ + normal_view, + cfish, + pfish, + fcfish, + fpfish +}; + +/*------------------------------------------------------. +| Node attributs list. structure that describes a node. | +`------------------------------------------------------*/ + +struct node_s +{ + /* Title the unique string identifying the node. This attribute is + mandatory. */ + char *title; + + /* Label the text displayed inside the node. If no label is specified + then the title of the node will be used. Note that this text may + contain control characters like NEWLINE that influences the size of + the node. */ + char *label; + + /* loc is the location as x, y position relatively to the system of + coordinates of the graph. Locations are specified in the form + loc: - x: xpos y: ypos "". The locations of nodes are only valid, + if the whole graph is fully specified with locations and no part is + folded. The layout algorithm of the tool calculates appropriate x, y + positions, if at least one node that must be drawn (i.e., is not + hidden by folding or edge classes) does not have fixed specified + locations. + Default is none. */ + int locx; + int locy; + + /* vertical order is the level position (rank) of the node. We can also + specify level: int. Level specifications are only valid, if the + layout is calculated, i.e. if at least one node does not have a + fixed location specification. The layout algorithm partitioned all + nodes into levels 0...maxlevel. Nodes at the level 0 are on the + upper corner. The algorithm is able to calculate appropriate levels + for the nodes automatically, if no fixed levels are given. + Specifications of levels are additional constraints, that may be + ignored, if they are in conflict with near edge specifications. + Default values are unspecified. */ + int vertical_order; + + /* horizontal order is the horizontal position of the node within a + level. The nodes which are specified with horizontal positions are + ordered according to these positions within the levels. The nodes + which do not have this attribute are inserted into this ordering by + the crossing reduction mechanism. Note that connected components are + handled separately, thus it is not possible to intermix such + components by specifying a horizontal order. If the algorithm for + downward laid out trees is used, the horizontal order influences + only the order of the child nodes at a node, but not the order of + the whole level. + Default is unspecified. */ + int horizontal_order; + + /* width, height is the width and height of a node including the border. + If no value (in pixels) is given then width and height are + calculated from the size of the label. + Default are width and height of the label. */ + int width; + int height; + + /* shrink, stretch gives the shrinking and stretching factor of the + node. The values of the attributes width, height, borderwidth and + the size of the label text is scaled by ((stretch=shrink) \Lambda + 100) percent. Note that the actual scale value is determined by the + scale value of a node relatively to a scale value of the graph, + i.e. if (stretch,shrink) = (2,1) for the graph and (stretch,shrink) + = (2,1) for the node of the graph, then the node is scaled by the + factor 4 compared to the normal size. The scale value can also be + specified by scaling: float. + Default are 1,1. */ + int shrink; + int stretch; + + /* folding specifies the default folding of the nodes. The folding k + (with k ? 0) means that the graph part that is reachable via edges + of a class less or equal to k is folded and displayed as one node. + There are commands to unfold such summary nodes, see section 5. If + no folding is specified for a node, then the node may be folded if + it is in the region of another node that starts the folding. If + folding 0 is specified, then the node is never folded. In this case + the folding stops at the predecessors of this node, if it is + reachable from another folding node. The summary node inherits some + attributes from the original node which starts the folding (all + color attributes, textmode and label, but not the location). A + folded region may contain folded regions with smaller folding class + values (nested foldings). If there is more than one node that start + the folding of the same region (this implies that the folding class + values are equal) then the attributes are inherited by one of these + nodes nondeterministically. If foldnode attributes are specified, + then the summary node attributes are inherited from these attributes. + Default is none. */ + int folding; + + /* shape specifies the visual appearance of a node: box, rhomb, ellipse, + and triangle. The drawing of ellipses is much slower than the drawing + of the other shapes. + Default is box. */ + enum shape_e shape; + + /* textmode specifies the adjustment of the text within the border of a + node. The possibilities are center, left.justify and right.justify. + Default is center. */ + enum textmode_e textmode; + + /* borderwidth specifies the thickness of the node's border in pixels. + color is the background color of the node. If none is given, the + node is white. For the possibilities, see the attribute color for + graphs. + Default is 2. */ + int borderwidth; + + /* node color. + Default is white or transparent, */ + enum color_e color; + + /* textcolor is the color for the label text. bordercolor is the color + of the border. Default color is the textcolor. info1, info2, info3 + combines additional text labels with a node or a folded graph. info1, + Default is black. */ + enum color_e textcolor; + + /* info2, info3 can be selected from the menu. The corresponding text + labels can be shown by mouse clicks on nodes. + Default are null strings. */ + char *infos[3]; + + /* Node border color. + Default is textcolor. */ + enum color_e bordercolor; + + /* Next node node... */ + struct node_s *next; +}; + +/* typedef alias. */ +typedef struct node_s node_t; + +/*-------------------------------------------------------. +| Edge attributs list. Structure that describes an edge. | +`-------------------------------------------------------*/ + +/* VCG Edge type. */ +enum edge_type +{ + normal_edge, + back_edge, + near_edge, + bent_near_edge +}; + +/* Structs enum definitions for edges. */ +enum linestyle_e +{ + continuous, + dashed, + dotted, + invisible +}; + +enum arrowstyle_e +{ + solid, + line, + none +}; + +/* The struct edge_s itself. */ +struct edge_s +{ + + /* Edge type. + Default is normal edge. */ + enum edge_type type; + + /* Sourcename is the title of the source node of the edge. + Default: none. */ + char *sourcename; /* Mandatory. */ + + /* Targetname is the title of the target node of the edge. + Default: none. */ + char *targetname; /* Mandatory. */ + + /* Label specifies the label of the edge. It is drawn if + display.edge.labels is set to yes. + Default: no label. */ + char *label; + + /* Linestyle specifies the style the edge is drawn. Possibilities are: + ffl continuous a solid line is drawn ( -- ) ffl dashed the edge + consists of single dashes ( - - - ) ffl dotted the edge is made of + single dots ( \Delta \Delta \Delta ) ffl invisible the edge is not + drawn. The attributes of its shape (color, thickness) are ignored. + To draw a dashed or dotted line needs more time than solid lines. + Default is continuous. */ + enum linestyle_e linestyle; + + /* Thickness is the thickness of an edge. + Default is 2. */ + int thickness; + + /* Class specifies the folding class of the edge. Nodes reachable by + edges of a class less or equal to a constant k specify folding + regions of k. See the node attribute folding and the folding commands. + Default is 1. */ + int class; + + /* color is the color of the edge. + Default is black. */ + enum color_e color; + + /* textcolor is the color of the label of the edge. arrowcolor, + backarrowcolor is the color of the arrow head and of the backarrow + head. priority The positions of the nodes are mainly determined by + the incoming and outgoing edges. One can think of rubberbands instead + of edges that pull a node into its position. The priority of an edges + corresponds to the strength of the rubberband. + Default is color. */ + enum color_e textcolor; + + /* Arrow color. + Default is color. */ + enum color_e arrowcolor; + + /* BackArrow color. + Default is color. */ + enum color_e backarrowcolor; + + /* arrowsize, backarrowsize The arrow head is a right-angled, isosceles + triangle and the cathetuses have length arrowsize. + Default is 10. */ + int arrowsize; + + /* Backarrow size + Default is 0. */ + int backarrowsize; + + /* arrowstyle, backarrowstyle Each edge has two arrow heads: the one + appears at the target node (the normal arrow head), the other appears + at the source node (the backarrow head). Normal edges only have the + normal solid arrow head, while the backarrow head is not drawn, i.e. + it is none. Arrowstyle is the style of the normal arrow head, and + backarrowstyle is the style of the backarrow head. Styles are none, + i.e. no arrow head, solid, and line. + Default is solid. */ + enum arrowstyle_e arrowstyle; + + /* Default is none. */ + enum arrowstyle_e backarrowstyle; + + /* Default is 1. */ + int priority; + + /* Anchor. An anchor point describes the vertical position in a node + where an edge goes out. This is useful, if node labels are several + lines long, and outgoing edges are related to label lines. (E.g., + this allows a nice visualization of structs containing pointers as + fields.). + Default is none. */ + int anchor; + + /* Horizontal order is the horizontal position the edge. This is of + interest only if the edge crosses several levels because it specifies + the point where the edge crosses the level. within a level. The nodes + which are specified with horizontal positions are ordered according + to these positions within a level. The horizontal position of a long + edge that crosses the level specifies between which two node of that + level the edge has to be drawn. Other edges which do not have this + attribute are inserted into this ordering by the crossing reduction + mechanism. Note that connected components are handled separately, + thus it is not possible to intermix such components by specifying a + horizontal order. + Default is unspcified. */ + int horizontal_order; + + /* + ** Next edge node... + */ + struct edge_s *next; + +}; + +/* +** typedef alias. +*/ +typedef struct edge_s edge_t; + +/***************************************************************. + ** + ****************************************************************/ + +/*--------------------------------------------------------. +| Graph attributs list. Structure that describes a graph. | +`--------------------------------------------------------*/ + +struct graph_s +{ + /* Graph title or name. + Title specifies the name (a string) associated with the graph. The + default name of a subgraph is the name of the outer graph, and the + name of the outmost graph is the name of the specification input + file. The name of a graph is used to identify this graph, e.g., if + we want to express that an edge points to a subgraph. Such edges + point to the root of the graph, i.e. the first node of the graph or + the root of the first subgraph in the graph, if the subgraph is + visualized explicitly. + By default, it's the name of the vcg graph file description. */ + char *title; + + /* Graph label. + Label the text displayed inside the node, when the graph is folded + to a node. If no label is specified then the title of the graph will + be used. Note that this text may contain control characters like + NEWLINE that influences the size of the node. + By default, it takes the title value */ + char *label; + + /* Any informations. + Info1, info2, info3 combines additional text labels with a node or a + folded graph. info1, info2, info3 can be selected from the menu + interactively. The corresponding text labels can be shown by mouse + clicks on nodes. + Defalut values are empty strings (here NULL pointers) */ + char *infos[3]; + + /* Background color and summary node colors + Color specifies the background color for the outermost graph, or the + color of the summary node for subgraphs. Colors are given in the enum + declared above. If more than these default colors are needed, a + color map with maximal 256 entries can be used. The first 32 entries + correspond to the colors just listed. A color of the color map can + selected by the color map index, an integer, for instance red has + index 2, green has index 3, etc. + Default is white for background and white or transparent for summary + nodes. */ + unsigned char color; + + /* Textcolor. + need explainations ??? + defalut is black for summary nodes. */ + unsigned char textcolor; + + /* Bordercolor is the color of the summary node's border. Default color + is the textcolor. width, height are width and height of the + displayed part of the window of the outermost graph in pixels, or + width and height of the summary node of inner subgraphs. + Default is the defalut of the textcolor. */ + unsigned char bordercolor; + + /* Width, height are width and height of the displayed part of the + window of the outermost graph in pixels, or width and height of the + summary node of inner subgraphs. + Defalut value is 100. */ + int width; + int height; + + /* Specify the thickness if summary node's border in pixels. + defalut value is 2. */ + int borderwidth; + + /* x, y are the x-position and y-position of the graph's window in + pixels, relatively to the root screen, if it is the outermost graph. + The origin of the window is upper, left hand. For inner subgraphs, + it is the position of the folded summary node. The position can also + be specified in the form loc: fx:int y:intg. + The default value is 0. */ + int x; + int y; + + /* folding of a subgraph is 1, if the subgraph is fused, and 0, if the + subgraph is visualized explicitly. There are commands to unfold such + summary nodes. + Defalut value is 0 */ + int folding; + + /* Shrink, stretch gives the shrinking and stretching factor for the + graph's representation (default is 1, 1). ((stretch=shrink) \Lambda + 100) is the scaling of the graph in percentage, e.g., + (stretch,shrink) = (1,1) or (2,2) or (3,3) : : : is normal size, + (stretch,shrink) = (1,2) is half size, (stretch,shrink) = (2,1) is + double size. For subgraphs, it is also the scaling factor of the + summary node. The scaling factor can also be specified by scaling: + float (here, scaling 1.0 means normal size). */ + int shrink; + int stretch; + + /* textmode specifies the adjustment of the text within the border of a + summary node. The possibilities are center, left.justify and + right.justify. + Default value is center.*/ + enum textmode_e textmode; + + /* Shape can be specified for subgraphs only. It is the shape of the + subgraph summary node that appears if the subgraph is folded: box, + rhomb, ellipse, and triangle. vertical order is the level position + (rank) of the summary node of an inner subgraph, if this subgraph is + folded. We can also specify level: int. The level is only + recognized, if an automatical layout is calculated. horizontal order + is the horizontal position of the summary node within a level. The + nodes which are specified with horizontal positions are ordered + according to these positions within the levels. The nodes which do + not have this attribute are inserted into this ordering by the + crossing reduction mechanism. Note that connected + components are handled separately, thus it is not possible to + intermix such components by specifying a horizontal order. If the + algorithm for downward laid out trees is used, the horizontal order + influences only the order of the child nodes at a node, but not the + order of the whole level. + Defalut is box, other: rhomb, ellipse, triangle. */ + enum shape_e shape; + + /* FIXME {vertival,horizontal}_order */ + + /* xmax, ymax specify the maximal size of the virtual window that is + used to display the graph. This is usually larger than the displayed + part, thus the width and height of the displayed part cannot be + greater than xmax and ymax. Only those parts of the graph are drawn + that are inside the virtual window. The virtual window can be moved + over the potential infinite system of coordinates by special + positioning commands. + Defaults are 90 and 90. */ + int xmax; + int ymax; + + /* xy-base: specify the upper left corner coordonates of the graph + relatively to the root window. + Defaults are 5, 5. */ + int xbase; + int ybase; + + /* xspace, yspace the minimum horizontal and vertical distance between + nodes. xlspace is the horizontal distance between lines at the + points where they cross the levels. (At these points, dummy nodes + are used. In fact, this is the horizontal distance between dummy + nodes.) It is recommended to set xlspace to a larger value, if + splines are used to draw edges, to prevent sharp bendings. + Default are 20 and 70. */ + int xspace; + int yspace; + + /* The horizontal space between lines at the point where they cross + the levels. + defaults value is 1/2 xspace (polygone) and 4/5 xspace (splines)*/ + int xlspace; + + /* xraster, yraster specifies the raster distance for the position of + the nodes. The center of a node is aligned to this raster. xlraster + is the horizontal raster for the positions of the line control + points (the dummy nodes). It should be a divisor of xraster. + defaluts are 1,1. */ + int xraster; + int yraster; + + /* xlraster is the horizontal raster for the positions of the line + control points (the dummy nodes). It should be a divisor of xraster. + defaults is 1. */ + int xlraster; + + /* hidden specifies the classes of edges that are hidden. + Edges that are within such a class are not laid out nor drawn. + Nodes that are only reachable (forward or backward) by edges of an + hidden class are not drawn. However, nodes that are not reachable + at all are drawn. (But see attribute ignore.singles.) Specification + of classes of hidden edges allows to hide parts of a graph, e.g., + annotations of a syntax tree. This attribute is only allowed at the + outermost level. More than one settings are possible to specify + exactly the set of classes that are hidden. Note the important + difference between hiding of edges and the edge line style invisible. + Hidden edges are not existent in the layout. Edges with line style + invisible are existent in the layout; they need space and may + produce crossings and influence the layout, but you cannot see + them. + No default value. */ + int hidden; + + /* Classname allows to introduce names for the edge classes. The names + are used in the menus. infoname allows to introduce names for the + additional text labels. The names are used in the menus. + defaults are 1,2,3... + By default, no class names. */ + struct classname_s *classname; + + /* FIXME : infoname. */ + /* FIXME : colorentry. */ + + /* layoutalgorithm chooses different graph layout algorithms + Possibilities are maxdepth, mindepth, maxdepthslow, mindepthslow, + maxdegree, mindegree, maxindegree, minindegree, maxoutdegree, + minoutdegree, minbackward, dfs and tree. The default algorithm tries + to give all edges the same orientation and is based on the + calculation of strongly connected components. The algorithms that + are based on depth first search are faster. While the simple dfs + does not enforce additionally constraints, the algorithm maxdepth + tries to increase the depth of the layout and the algorithm mindepth + tries to increase the wide of the layout. These algorithms are fast + heuristics. If they are not appropriate, the algorithms maxdepthslow + or mindepthslow also increase the depth or wide, but they are very + slow. The algorithm maxindegree lays out the nodes by scheduling the + nodes with the maximum of incoming edges first, and minindegree lays + out the nodes by scheduling the nodes with the minimum of incoming + edges first. In the same manner work the algorithms maxoutdegree and + minoutdegree for outgoing edges, and maxdegree and mindegree for the + sum of incoming and outgoing edges. These algorithms may have various + effects, and can sometimes be used as replacements of maxdepthslow + or mindepthslow. + + The algorithm minbackward can be used if the graph is acyclic. + The algorithm tree is a specialized method for downward laid out + trees. It is much faster on such tree-like graphs and results in a + balanced layout. + Default is normal. */ + enum layoutalgorithm_e layoutalgorithm; + + /* Layout downfactor, layout upfactor, layout nearfactor The layout + algorithm partitions the set of edges into edges pointing upward, + edges pointing downward, and edges pointing sidewards. The last type + of edges is also called near edges. If the layout.downfactor is + large compared to the layout.upfactor and the layout.nearfactor, + then the positions of the nodes is mainly determined by the edges + pointing downwards. If the layout.upfactor is large compared to the + layout.downfactor and the layout.nearfactor, then the positions of + the nodes is mainly determined by the edges pointing upwards. If the + layout.nearfactor is large, then the positions of the nodes is + mainly determined by the edges pointing sidewards. These attributes + have no effect, if the method for downward laid out trees is used. + Defalut is normal. */ + int layout_downfactor; + int layout_upfactor; + int layout_nearfactor; + /* Layout splinefactor determines the bending at splines. The factor + 100 indicates a very sharp bending, a factor 1 indicates a very flat + bending. Useful values are 30 : : : 80. */ + int layout_splinefactor; + + /* Late edge labels yes means that the graph is first partitioned and + then, labels are introduced. The default algorithm first creates + labels and then partitions the graph, which yield a more compact + layout, but may have more crossings. + Default is no. */ + enum decision_e late_edge_labels; + + /* Display edge labels yes means display labels and no means don't + display edge labels. + Default vaule is no. */ + enum decision_e display_edge_labels; + + /* Dirty edge labels yes enforces a fast layout of edge labels, which + may very ugly because several labels may be drawn at the same place. + Dirty edge labels cannot be used if splines are used. + Default is no. + */ + enum decision_e dirty_edge_labels; + + /* Finetuning no switches the fine tuning phase of the graph layout + algorithm off, while it is on as default. The fine tuning phase + tries to give all edges the same length. + Default is yes. */ + enum decision_e finetuning; + + /* Ignore singles yes hides all nodes which would appear single and + unconnected from the remaining graph. Such nodes have no edge at all + and are sometimes very ugly. Default is to show all nodes. + Default is no. */ + enum decision_e ignore_singles; + + /* Straight phase yes initiates an additional phase that tries to avoid + bendings in long edges. + Long edges are laid out by long straight vertical lines with + gradient 90 degree. Thus, this phase is not very appropriate for + normal layout, but it is recommended, if an orthogonal layout is + selected (see manhattan.edges). + Default is no. */ + enum decision_e straight_phase; + + /* priority phase yes replaces the normal pendulum method by a + specialized method: It forces straight long edges with 90 degree, + just as the straight phase. In fact, the straight phase is a fine + tune phase of the priority method. This phase is also recommended, + if an orthogonal layout is selected (see manhattan.edges). + Default is no. */ + enum decision_e priority_phase; + + /* manhattan edges yes switches the orthogonal layout on. Orthogonal + layout (or manhattan layout) means that all edges consist of line + segments with gradient 0 or 90 degree. Vertical edge segments might + by shared by several edges, while horizontal edge segments are never + shared. This results in very aesthetical layouts just for flowcharts. + If the orthogonal layout is used, then the priority phase and + straight phase should be used. Thus, these both phases are switched + on, too, unless priority layout and straight line tuning are + switched off explicitly. + Default is no. */ + enum decision_e manhattan_edges; + + /* Smanhattan edges yes switches a specialized orthogonal layout on: + Here, all horizontal edge segments between two levels share the same + horizontal line, i.e. not only vertical edge segments are shared, + but horizontal edge segments are shared by several edges, too. This + looks nice for trees but might be too confusing in general, because + the location of an edge might be ambiguously. + Default is no. */ + enum decision_e smanhattan_edges; + + /* Near edges no suppresses near edges and bent near edges in the + graph layout. + Default is yes. */ + enum decision_e near_edges; + + /* Orientation specifies the orientation of the graph: top.to.bottom, + bottom.to.top, left.to.right or right.to.left. Note: the normal + orientation is top.to.bottom. All explanations here are given + relatively to the normal orientation, i.e., e.g., if the orientation + is left to right, the attribute xlspace is not the horizontal but + the vertical distance between lines, etc. + Default is to_to_bottom. */ + enum orientation_e orientation; + + /* Node alignment specified the vertical alignment of nodes at the + horizontal reference line of the levels. If top is specified, the + tops of all nodes of a level have the same y-coordinate; on bottom, + the bottoms have the same y-coordinate, on center the nodes are + centered at the levels. + Default is center. */ + enum alignement_e node_alignement; + + /* Port sharing no suppresses the sharing of ports of edges at the + nodes. Normally, if multiple edges are adjacent to the same node, + and the arrow head of all these edges has the same visual appearance + (color, size, etc.), then these edges may share a port at a node, + i.e. only one arrow head is draw, and all edges are incoming into + this arrow head. This allows to have many edges adjacent to one node + without getting confused by too many arrow heads. If no port sharing + is used, each edge has its own port, i.e. its own place where it is + adjacent to the node. + Default is yes. */ + enum decision_e port_sharing; + + /* Arrow mode fixed (default) should be used, if port sharing is used, + because then, only a fixed set of rotations for the arrow heads are + used. If the arrow mode is free, then each arrow head is rotated + individually to each edge. But this can yield to a black spot, where + nothing is recognizable, if port sharing is used, since all these + qdifferently rotated arrow heads are drawn at the same place. If the + arrow mode is fixed, then the arrow head is rotated only in steps of + 45 degree, and only one arrow head occurs at each port. + Default is fixed. */ + enum arrow_mode_e arrow_mode; + + /* Treefactor The algorithm tree for downward laid out trees tries to + produce a medium dense, balanced tree-like layout. If the tree + factor is greater than 0.5, the tree edges are spread, i.e. they + get a larger gradient. This may improve the readability of the tree. + Note: it is not obvious whether spreading results in a more dense or + wide layout. For a tree, there is a tree factor such that the whole + tree is minimal wide. + Default is 0.5. */ + float treefactor; + + /* Spreadlevel This parameter only influences the algorithm tree, too. + For large, balanced trees, spreading of the uppermost nodes would + enlarge the width of the tree too much, such that the tree does not + fit anymore in a window. Thus, the spreadlevel specifies the minimal + level (rank) where nodes are spread. Nodes of levels upper than + spreadlevel are not spread. + Default is 1. */ + int spreadlevel; + + /* Crossing weight specifies the weight that is used for the crossing + reduction: bary (default), median, barymedian or medianbary. We + cannot give a general recommendation, which is the best method. For + graphs with very large average degree of edges (number of incoming + and outgoing edges at a node), the weight bary is the fastest + method. With the weights barymedian and medianbary, equal weights of + different nodes are not very probable, thus the crossing reduction + phase 2 might be very fast. + Default is bary. */ + enum crossing_type_e crossing_weight; + + /* Crossing phase2 is the most time consuming phase of the crossing + reduction. In this phase, the nodes that happen to have equal + crossing weights are permuted. By specifying no, this phase is + suppressed. + Default is yes. */ + enum decision_e crossing_phase2; + + /* Crossing optimization is a postprocessing phase after the normal + crossing reduction: we try to optimize locally, by exchanging pairs + of nodes to reduce the crossings. Although this phase is not very + time consuming, it can be suppressed by specifying no. + Default is yes. */ + enum decision_e crossing_optimization; + + /* View allows to select the fisheye views. Because + of the fixed size of the window that shows the graph, we normally + can only see a small amount of a large graph. If we shrink the graph + such that it fits into the window, we cannot recognize any detail + anymore. Fisheye views are coordinate transformations: the view onto + the graph is distort, to overcome this usage deficiency. The polar + fisheye is easy to explain: assume a projection of the plane that + contains the graph picture onto a spheric ball. If we now look onto + this ball in 3 D, we have a polar fisheye view. There is a focus + point which is magnified such that we see all details. Parts of the + plane that are far away from the focus point are demagnified very + much. Cartesian fisheye have a similar effect; only the formula for + the coordinate transformation is different. Selecting cfish means + the cartesian fisheye is used which demagnifies such that the whole + graph is visible (self adaptable cartesian fisheye). With fcfish, + the cartesian fisheye shows the region of a fixed radius around the + focus point (fixed radius cartesian fisheye). This region might be + smaller than the whole graph, but the demagnification needed to show + this region in the window is also not so large, thus more details + are recognizable. With pfish the self adaptable polar fisheye is + selected that shows the whole graph, and with fpfish the fixed + radius polar fisheye is selected. + Defalut is normal view. */ + enum view_e view; + + /* Edges no suppresses the drawing of edges. + Default is yes. */ + enum decision_e edges; + + /* Nodes no suppresses the drawing of nodes. + Default is yes. */ + enum decision_e nodes; + + /* Splines specifies whether splines are used to draw edges (yes or no). + As default, polygon segments are used to draw edges, because this is + much faster. Note that the spline drawing routine is not fully + validated, and is very slow. Its use is mainly to prepare high + quality PostScript output for very small graphs. + Default is no. */ + enum decision_e splines; + + /* Bmax set the maximal number of iterations that are done for the + reduction of edge bendings. + Default is 100. */ + int bmax; + + /* Cmin set the minimal number of iterations that are done for the + crossing reduction with the crossing weights. The normal method + stops if two consecutive checks does not reduce the number of + crossings anymore. However, this increasing of the number of + crossings might be locally, such that after some more iterations, + the crossing number might decrease much more. + Default is 0. */ + int cmin; + + /* Cmax set the maximal number of interactions for crossing reduction. + This is helpful for speedup the layout process. + Default is infinite. */ + int cmax; + + /* Pmin set the minimal number of iterations that is done with the + pendulum method. Similar to the crossing reduction, this method + stops if the `imbalancement weight' does not decreases anymore. + However, the increasing of the imbalancement weight might be locally, + such that after some more iterations, the imbalancement weight might + decrease much more. + Default is 0. */ + int pmin; + + /* Pmax set the maximal number of iterations of the pendulum method. + This is helpful for speedup the layout process. + Default is 100. */ + int pmax; + + /* Rmin set the minimal number of iterations that is done with the + rubberband method. This is similar as for the pendulum method. + Default is 0. */ + int rmin; + + /* Rmax set the maximal number of iterations of the rubberband method. + This is helpful for speedup the layout process. + Default is 100. */ + int rmax; + + /* Smax set the maximal number of iterations of the straight line + recognition phase (useful only, if the straight line recognition + phase is switched on, see attribute straight.phase). + Default is 100. */ + int smax; + + /* Generic values. + */ + node_t node; + edge_t edge; + + /* List of nodes declared. + Pointer. */ + node_t *node_list; + + /* List of edges declared. + Pointer. */ + edge_t *edge_list; + +}; + +/* Graph typedefs. */ +typedef struct graph_s graph_t; + +void new_graph PARAMS ((graph_t *g)); +void new_node PARAMS ((node_t *node)); +void new_edge PARAMS ((edge_t *edge)); + +void add_node PARAMS ((graph_t *graph, node_t *node)); +void add_edge PARAMS ((graph_t *graph, edge_t *edge)); + +void open_node PARAMS ((struct obstack *os)); +void output_node PARAMS ((node_t *node, struct obstack *os)); +void close_node PARAMS ((struct obstack *os)); + +void open_edge PARAMS ((edge_t *edge, struct obstack *os)); +void output_edge PARAMS ((edge_t *edge, struct obstack *os)); +void close_edge PARAMS ((struct obstack *os)); + +void open_graph PARAMS ((struct obstack *os)); +void output_graph PARAMS ((graph_t *graph, struct obstack *os)); +void close_graph PARAMS ((graph_t *graph, struct obstack *os)); + +#endif /* VCG_H_ */ + diff --git a/src/vcg_defaults.h b/src/vcg_defaults.h new file mode 100644 index 00000000..c2c2d944 --- /dev/null +++ b/src/vcg_defaults.h @@ -0,0 +1,175 @@ +/* VCG description handler for Bison. + Copyright 2001 Free Software Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + Bison is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + Bison is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + 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. */ + +#ifndef VCG_DEFAULTS_H_ +# define VCG_DEFAULTS_H_ + +/* Graph defaults. */ +# define G_TITLE 0 +# define G_LABEL 0 +# define G_INFOS1 0 +# define G_INFOS2 0 +# define G_INFOS3 0 + +# define G_COLOR white +# define G_TEXTCOLOR black +# define G_BORDERCOLOR G_TEXTCOLOR + +# define G_WIDTH 100 +# define G_HEIGHT 100 +# define G_BORDERWIDTH 2 + +# define G_X 0 +# define G_Y 0 + +# define G_FOLDING 0 + +# define G_SHRINK 1 +# define G_STRETCH 1 + +# define G_TEXTMODE centered +# define G_SHAPE box + +# define G_XMAX 90 /* Not output */ +# define G_YMAX 90 /* Not output */ + +# define G_XBASE 5 +# define G_YBASE 5 + +# define G_XSPACE 20 +# define G_YSPACE 70 +# define G_XLSPACE G_XSPACE / 2 /* Not output */ + +# define G_XRASTER 1 +# define G_YRASTER 1 +# define G_XLRASTER 1 + +# define G_HIDDEN -1 /* No default value. */ + +# define G_CLASSNAME 0 /* No class name association */ +# define G_LAYOUTALGORITHM normal +# define G_LAYOUT_DOWNFACTOR 1 +# define G_LAYOUT_UPFACTOR 1 +# define G_LAYOUT_NEARFACTOR 1 +# define G_LAYOUT_SPLINEFACTOR 70 + +# define G_LATE_EDGE_LABELS no +# define G_DISPLAY_EDGE_LABELS no +# define G_DIRTY_EDGE_LABELS no +# define G_FINETUNING yes +# define G_IGNORE_SINGLES no +# define G_STRAIGHT_PHASE no +# define G_PRIORITY_PHASE no +# define G_MANHATTAN_EDGES no +# define G_SMANHATTAN_EDGES no +# define G_NEAR_EDGES yes + +# define G_ORIENTATION top_to_bottom +# define G_NODE_ALIGNEMENT center +# define G_PORT_SHARING yes +# define G_ARROW_MODE fixed +# define G_TREEFACTOR 0.5 +# define G_SPREADLEVEL 1 +# define G_CROSSING_WEIGHT bary +# define G_CROSSING_PHASE2 yes +# define G_CROSSING_OPTIMIZATION yes +# define G_VIEW normal_view + +# define G_EDGES yes +# define G_NODES yes +# define G_SPLINES no + +# define G_BMAX 100 +# define G_CMIN 0 +/* computes the max value of an int ... */ +# define G_CMAX ((unsigned) 1 << (sizeof(int) * 8 - 1)) - 1 +# define G_PMIN 0 +# define G_PMAX 100 +# define G_RMIN 0 +# define G_RMAX 100 +# define G_SMAX 100 + +# define G_NODE_LIST 0 +# define G_EDGE_LIST 0 + +/* Nodes defaults. */ +# define N_TITLE 0 +# define N_LABEL 0 + +# define N_LOCX -1 /* Default unspcified */ +# define N_LOCY -1 /* Default unspcified */ + +# define N_VERTICAL_ORDER -1 /* Default unspcified */ +# define N_HORIZONTAL_ORDER -1 /* Default unspcified */ + +# define N_WIDTH -1 /* We assume that we can't define it now. */ +# define N_HEIGHT -1 /* also. */ + +# define N_SHRINK 1 +# define N_STRETCH 1 + +# define N_FOLDING -1 /* no explicit default value. */ + +# define N_SHAPE box +# define N_TEXTMODE centered +# define N_BORDERWIDTH 2 + +# define N_COLOR white +# define N_TEXTCOLOR black +# define N_BORDERCOLOR N_TEXTCOLOR + +# define N_INFOS1 0 +# define N_INFOS2 0 +# define N_INFOS3 0 + +# define N_NEXT 0 + +/* Edge defaults. */ +# define E_EDGE_TYPE normal_edge + +# define E_SOURCENAME 0 /* Mandatory. */ +# define E_TARGETNAME 0 /* Mandatory. */ +# define E_LABEL 0 + +# define E_LINESTYLE continuous +# define E_THICKNESS 2 + +# define E_CLASS 1 + +# define E_COLOR black +# define E_TEXTCOLOR E_COLOR +# define E_ARROWCOLOR E_COLOR +# define E_BACKARROWCOLOR E_COLOR + +# define E_ARROWSIZE 10 +# define E_BACKARROWSIZE 0 + +# define E_ARROWSTYLE solid +# define E_BACKARROWSTYLE none + +# define E_PRIORITY 1 + +# define E_ANCHOR -1 + +# define E_HORIZONTAL_ORDER -1 + +# define E_NEXT 0 + +#endif /* not VCG_DEFAULTS_H_ */