/* VCG description handler for Bison.
- Copyright 2001 Free Software Foundation, Inc.
+
+ Copyright (C) 2001, 2002 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
Boston, MA 02111-1307, USA. */
#include "system.h"
+
+#include <quotearg.h>
+
#include "vcg.h"
#include "vcg_defaults.h"
-#include "xalloc.h"
+
+/* Return an unambiguous printable representated, for NAME, suitable
+ for C strings. Use slot 2 since the user may use slots 0 and 1.
+ */
+
+static char const *
+quote (char const *name)
+{
+ return quotearg_n_style (2, c_quoting_style, name);
+}
+
/* Initialize a graph with the default values. */
void
-new_graph (graph_t *g)
+new_graph (graph *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->y = G_Y;
g->folding = G_FOLDING;
g->shrink = G_SHRINK;
- g->stretch = G_STRETCH;
+ g->expand = G_EXPAND;
g->textmode = G_TEXTMODE;
g->shape = G_SHAPE;
-
+
+ g->vertical_order = G_VERTICAL_ORDER;
+ g->horizontal_order = G_HORIZONTAL_ORDER;
+
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->long_straight_phase = G_LONG_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->node_alignment = G_NODE_ALIGNMENT;
g->port_sharing = G_PORT_SHARING;
g->arrow_mode = G_ARROW_MODE;
g->treefactor = G_TREEFACTOR;
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);
+
+ new_edge (&g->edge);
+ new_node (&g->node);
}
-/* Initialize a node with the defalut values. */
+/* Initialize a node with the default values. */
void
-new_node (node_t *node)
+new_node (node *n)
{
- 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;
+ n->title = N_TITLE;
+ n->label = N_LABEL;
+
+ n->locx = N_LOCX; /* Default unspcified. */
+ n->locy = N_LOCY; /* Default unspcified. */
+
+ n->vertical_order = N_VERTICAL_ORDER; /* Default unspcified. */
+ n->horizontal_order = N_HORIZONTAL_ORDER; /* Default unspcified. */
+
+ n->width = N_WIDTH; /* We assume that we can't define it now. */
+ n->height = N_HEIGHT; /* Also. */
+
+ n->shrink = N_SHRINK;
+ n->expand = N_EXPAND;
+
+ n->folding = N_FOLDING; /* No explicit default value. */
+
+ n->shape = N_SHAPE;
+ n->textmode = N_TEXTMODE;
+ n->borderwidth = N_BORDERWIDTH;
+
+ n->color = N_COLOR;
+ n->textcolor = N_TEXTCOLOR;
+ n->bordercolor = N_BORDERCOLOR;
+
+ n->infos[0] = N_INFOS1;
+ n->infos[1] = N_INFOS2;
+ n->infos[2] = N_INFOS3;
+
+ n->next = N_NEXT;
}
-/* Initialize a edge with the defalut values. */
+/* Initialize an edge with the default values. */
void
-new_edge (edge_t *edge)
+new_edge (edge *e)
{
- edge->type = E_EDGE_TYPE;
+ e->type = E_EDGE_TYPE;
- edge->sourcename = E_SOURCENAME;
- edge->targetname = E_TARGETNAME;
- edge->label = E_LABEL;
+ e->sourcename = E_SOURCENAME;
+ e->targetname = E_TARGETNAME;
+ e->label = E_LABEL;
- edge->linestyle = E_LINESTYLE;
- edge->thickness = E_THICKNESS;
+ e->linestyle = E_LINESTYLE;
+ e->thickness = E_THICKNESS;
- edge->class = E_CLASS;
+ e->class = E_CLASS;
- edge->color = E_COLOR;
- edge->textcolor = E_TEXTCOLOR;
- edge->arrowcolor = E_ARROWCOLOR;
- edge->backarrowcolor = E_BACKARROWCOLOR;
+ e->color = E_COLOR;
+ e->textcolor = E_TEXTCOLOR;
+ e->arrowcolor = E_ARROWCOLOR;
+ e->backarrowcolor = E_BACKARROWCOLOR;
- edge->arrowsize = E_ARROWSIZE;
- edge->backarrowsize = E_BACKARROWSIZE;
- edge->arrowstyle = E_ARROWSTYLE;
+ e->arrowsize = E_ARROWSIZE;
+ e->backarrowsize = E_BACKARROWSIZE;
+ e->arrowstyle = E_ARROWSTYLE;
- edge->backarrowstyle = E_BACKARROWSTYLE;
+ e->backarrowstyle = E_BACKARROWSTYLE;
- edge->priority = E_PRIORITY;
+ e->priority = E_PRIORITY;
- edge->anchor = E_ANCHOR;
+ e->anchor = E_ANCHOR;
- edge->horizontal_order = E_HORIZONTAL_ORDER;
+ e->horizontal_order = E_HORIZONTAL_ORDER;
- edge->next = E_NEXT;
+ e->next = E_NEXT;
}
/*----------------------------------------------.
`----------------------------------------------*/
static const char *
-get_color_str (enum color_e c)
+get_color_str (enum color 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));
+ 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: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_textmode_str (enum textmode_e t)
+get_textmode_str (enum textmode 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));
+ case centered: return "center";
+ case left_justify: return "left_justify";
+ case right_justify: return "right_justify";
+ default: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_shape_str (enum shape_e s)
+get_shape_str (enum shape 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));
+ case box: return "box";
+ case rhomb: return "rhomb";
+ case ellipse: return "ellipse";
+ case triangle: return "triangle";
+ default: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_layoutalgorithm_str (enum layoutalgorithm_e l)
+get_layoutalgorithm_str (enum layoutalgorithm 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");
+ 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: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_decision_str (enum decision_e d, enum decision_e defaults)
+get_decision_str (enum decision d)
{
switch (d)
{
- case no: return ("no");
- case yes: return ("yes");
- default:
- complain (_("vcg graph: no such a decision.."));
- return (get_decision_str(defaults, 0));
+ case no: return "no";
+ case yes: return "yes";
+ default: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_orientation_str (enum orientation_e o)
+get_orientation_str (enum orientation 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));
+ 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: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_node_alignement_str (enum alignement_e a)
+get_node_alignment_str (enum alignment 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));
+ case center: return "center";
+ case top: return "top";
+ case bottom: return "bottom";
+ default: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_arrow_mode_str (enum arrow_mode_e a)
+get_arrow_mode_str (enum arrow_mode 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));
+ case fixed: return "fixed";
+ case free_a: return "free";
+ default: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_crossing_type_str (enum crossing_type_e c)
+get_crossing_type_str (enum crossing_type 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;
+ case bary: return "bary";
+ case median: return "median";
+ case barymedian: return "barymedian";
+ case medianbary: return "medianbary";
+ default: abort (); return NULL;
+ }
}
static const char *
-get_view_str (enum view_e v)
+get_view_str (enum view 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));
+ case normal_view: return "normal_view";
+ case cfish: return "cfish";
+ case pfish: return "pfish";
+ case fcfish: return "fcfish";
+ case fpfish: return "fpfish";
+ default: abort (); return NULL;
}
- return NULL;
}
static const char *
-get_linestyle_str (enum linestyle_e l)
+get_linestyle_str (enum linestyle 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;
+ case continuous: return "continuous";
+ case dashed: return "dashed";
+ case dotted: return "dotted";
+ case invisible: return "invisible";
+ default: abort (); return NULL;
+ }
}
static const char *
-get_arrowstyle_str (enum arrowstyle_e a)
+get_arrowstyle_str (enum arrowstyle 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));
+ case solid: return "solid";
+ case line: return "line";
+ case none: return "none";
+ default: abort (); return NULL;
}
- return NULL;
}
-/*----------------------------.
-| Add functions. |
-| Edge and Nodes int a graph. |
-`----------------------------*/
+/*------------------------------.
+| Add functions. |
+| Edge and nodes into a graph. |
+`------------------------------*/
void
-add_node (graph_t *graph, node_t *node)
+add_node (graph *g, node *n)
{
- node->next = graph->node_list;
- graph->node_list = node;
+ n->next = g->node_list;
+ g->node_list = n;
}
void
-add_edge (graph_t *graph, edge_t *edge)
+add_edge (graph *g, edge *e)
{
- edge->next = graph->edge_list;
- graph->edge_list = edge;
+ e->next = g->edge_list;
+ g->edge_list = e;
+}
+
+void
+add_classname (graph *g, int val, const char *name)
+{
+ struct classname *classname;
+
+ MALLOC (classname, 1);
+ classname->no = val;
+ classname->name = name;
+ classname->next = g->classname;
+ g->classname = classname;
+}
+
+void
+add_infoname (graph *g, int integer, const char *str)
+{
+ struct infoname *infoname;
+
+ MALLOC (infoname, 1);
+ infoname->integer = integer;
+ infoname->chars = str;
+ infoname->next = g->infoname;
+ g->infoname = infoname;
+}
+
+/* Build a colorentry struct and add it to the list. */
+void
+add_colorentry (graph *g, int color_idx, int red_cp,
+ int green_cp, int blue_cp)
+{
+ struct colorentry *ce;
+
+ MALLOC (ce, 1);
+ ce->color_index = color_idx;
+ ce->red_cp = red_cp;
+ ce->green_cp = green_cp;
+ ce->blue_cp = blue_cp;
+ ce->next = g->colorentry;
+ g->colorentry = ce;
}
/*-------------------------------------.
`-------------------------------------*/
void
-open_edge(edge_t *edge, struct obstack *os)
+open_edge (edge *e, FILE *fout)
{
- switch (edge->type)
+ switch (e->type)
{
case normal_edge:
- obstack_sgrow (os, "\tedge: {\n");
+ fputs ("\tedge: {\n", fout);
break;
case back_edge:
- obstack_sgrow (os, "\tbackedge: {\n");
+ fputs ("\tbackedge: {\n", fout);
break;
case near_edge:
- obstack_sgrow (os, "\tnearedge: {\n");
+ fputs ("\tnearedge: {\n", fout);
break;
case bent_near_edge:
- obstack_sgrow (os, "\tbentnearedge: {\n");
- break;
+ fputs ("\tbentnearedge: {\n", fout);
+ break;
default:
- obstack_sgrow (os, "\tedge: {\n");
- }
+ fputs ("\tedge: {\n", fout);
+ }
}
void
-close_edge(struct obstack *os)
+close_edge (FILE *fout)
{
- obstack_sgrow (os, "\t}\n");
+ fputs ("\t}\n", fout);
}
void
-open_node(struct obstack *os)
+open_node (FILE *fout)
{
- obstack_sgrow (os, "\tnode: {\n");
+ fputs ("\tnode: {\n", fout);
}
void
-close_node(struct obstack *os)
-{
- obstack_sgrow (os, "\t}\n");
+close_node (FILE *fout)
+{
+ fputs ("\t}\n", fout);
}
void
-open_graph(struct obstack *os)
+open_graph (FILE *fout)
{
- obstack_sgrow (os, "graph: {\n");
+ fputs ("graph: {\n", fout);
}
void
-close_graph(graph_t *graph, struct obstack *os)
+close_graph (graph *g, FILE *fout)
{
- obstack_1grow (os, '\n');
+ fputc ('\n', fout);
+ /* FIXME: Unallocate nodes and edges if required. */
{
- node_t *node;
-
- for (node = graph->node_list; node; node = node->next)
+ node *n;
+
+ for (n = g->node_list; n; n = n->next)
{
- open_node (os);
- output_node (node, os);
- close_node (os);
+ open_node (fout);
+ output_node (n, fout);
+ close_node (fout);
}
}
-
- obstack_1grow (os, '\n');
-
+
+ fputc ('\n', fout);
+
{
- edge_t *edge;
-
- for (edge = graph->edge_list; edge; edge = edge->next)
- {
- open_edge (edge, os);
- output_edge (edge, os);
- close_edge (os);
+ edge *e;
+
+ for (e = g->edge_list; e; e = e->next)
+ {
+ open_edge (e, fout);
+ output_edge (e, fout);
+ close_edge (fout);
}
}
-
- obstack_sgrow (os, "}\n");
-}
-
+
+ fputs ("}\n", fout);
+}
+
/*-------------------------------------------.
-| Output functions (formatted) in obstack os |
+| Output functions (formatted) in file FOUT |
`-------------------------------------------*/
void
-output_node (node_t *node, struct obstack *os)
+output_node (node *n, FILE *fout)
{
- 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]);
+ if (n->title != N_TITLE)
+ fprintf (fout, "\t\ttitle:\t%s\n", quote (n->title));
+ if (n->label != N_LABEL)
+ fprintf (fout, "\t\tlabel:\t%s\n", quote (n->label));
+
+ if ((n->locx != N_LOCX) && (n->locy != N_LOCY))
+ fprintf (fout, "\t\tloc { x: %d y: %d }\t\n", n->locx, n->locy);
+
+ if (n->vertical_order != N_VERTICAL_ORDER)
+ fprintf (fout, "\t\tvertical_order:\t%d\n", n->vertical_order);
+ if (n->horizontal_order != N_HORIZONTAL_ORDER)
+ fprintf (fout, "\t\thorizontal_order:\t%d\n", n->horizontal_order);
+
+ if (n->width != N_WIDTH)
+ fprintf (fout, "\t\twidth:\t%d\n", n->width);
+ if (n->height != N_HEIGHT)
+ fprintf (fout, "\t\theight:\t%d\n", n->height);
+
+ if (n->shrink != N_SHRINK)
+ fprintf (fout, "\t\tshrink:\t%d\n", n->shrink);
+ if (n->expand != N_EXPAND)
+ fprintf (fout, "\t\texpand:\t%d\n", n->expand);
+
+ if (n->folding != N_FOLDING)
+ fprintf (fout, "\t\tfolding:\t%d\n", n->folding);
+
+ if (n->textmode != N_TEXTMODE)
+ fprintf (fout, "\t\ttextmode:\t%s\n",
+ get_textmode_str (n->textmode));
+
+ if (n->shape != N_SHAPE)
+ fprintf (fout, "\t\tshape:\t%s\n", get_shape_str (n->shape));
+
+ if (n->borderwidth != N_BORDERWIDTH)
+ fprintf (fout, "\t\tborderwidth:\t%d\n", n->borderwidth);
+
+ if (n->color != N_COLOR)
+ fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (n->color));
+ if (n->textcolor != N_TEXTCOLOR)
+ fprintf (fout, "\t\ttextcolor:\t%s\n",
+ get_color_str (n->textcolor));
+ if (n->bordercolor != N_BORDERCOLOR)
+ fprintf (fout, "\t\tbordercolor:\t%s\n",
+ get_color_str (n->bordercolor));
+
+ {
+ int i;
+ for (i = 0; i < 3; ++i)
+ if (n->infos[i])
+ fprintf (fout, "\t\tinfo%d:\t%s\n",
+ i, quote (n->infos[i]));
+ }
}
void
-output_edge (edge_t *edge, struct obstack *os)
+output_edge (edge *e, FILE *fout)
{
-
- 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);
+ /* FIXME: SOURCENAME and TARGETNAME are mandatory
+ so it has to be fatal not to give these informations. */
+ if (e->sourcename != E_SOURCENAME)
+ fprintf (fout, "\t\tsourcename:\t%s\n", quote (e->sourcename));
+ if (e->targetname != E_TARGETNAME)
+ fprintf (fout, "\t\ttargetname:\t%s\n", quote (e->targetname));
+
+ if (e->label != E_LABEL)
+ fprintf (fout, "\t\tlabel:\t%s\n", quote (e->label));
+
+ if (e->linestyle != E_LINESTYLE)
+ fprintf (fout, "\t\tlinestyle:\t%s\n",
+ quote (get_linestyle_str (e->linestyle)));
+
+ if (e->thickness != E_THICKNESS)
+ fprintf (fout, "\t\tthickness:\t%d\n", e->thickness);
+ if (e->class != E_CLASS)
+ fprintf (fout, "\t\tclass:\t%d\n", e->class);
+
+ if (e->color != E_COLOR)
+ fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (e->color));
+ if (e->color != E_TEXTCOLOR)
+ fprintf (fout, "\t\ttextcolor:\t%s\n",
+ get_color_str (e->textcolor));
+ if (e->arrowcolor != E_ARROWCOLOR)
+ fprintf (fout, "\t\tarrowcolor:\t%s\n",
+ get_color_str (e->arrowcolor));
+ if (e->backarrowcolor != E_BACKARROWCOLOR)
+ fprintf (fout, "\t\tbackarrowcolor:\t%s\n",
+ get_color_str (e->backarrowcolor));
+
+ if (e->arrowsize != E_ARROWSIZE)
+ fprintf (fout, "\t\tarrowsize:\t%d\n", e->arrowsize);
+ if (e->backarrowsize != E_BACKARROWSIZE)
+ fprintf (fout, "\t\tbackarrowsize:\t%d\n", e->backarrowsize);
+
+ if (e->arrowstyle != E_ARROWSTYLE)
+ fprintf (fout, "\t\tarrowstyle:\t%s\n",
+ get_arrowstyle_str (e->arrowstyle));
+ if (e->backarrowstyle != E_BACKARROWSTYLE)
+ fprintf (fout, "\t\tbackarrowstyle:\t%s\n",
+ get_arrowstyle_str (e->backarrowstyle));
+
+ if (e->priority != E_PRIORITY)
+ fprintf (fout, "\t\tpriority:\t%d\n", e->priority);
+ if (e->anchor != E_ANCHOR)
+ fprintf (fout, "\t\tanchor:\t%d\n", e->anchor);
+ if (e->horizontal_order != E_HORIZONTAL_ORDER)
+ fprintf (fout, "\t\thorizontal_order:\t%d\n", e->horizontal_order);
}
void
-output_graph (graph_t *graph, struct obstack *os)
+output_graph (graph *g, FILE *fout)
{
- 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)
+ if (g->title)
+ fprintf (fout, "\ttitle:\t%s\n", quote (g->title));
+ if (g->label)
+ fprintf (fout, "\tlabel:\t%s\n", quote (g->label));
+
+ {
+ int i;
+ for (i = 0; i < 3; ++i)
+ if (g->infos[i])
+ fprintf (fout, "\tinfo%d:\t%s\n", i, quote (g->infos[i]));
+ }
+
+ if (g->color != G_COLOR)
+ fprintf (fout, "\tcolor:\t%s\n", get_color_str (g->color));
+ if (g->textcolor != G_TEXTCOLOR)
+ fprintf (fout, "\ttextcolor:\t%s\n", get_color_str (g->textcolor));
+ if (g->bordercolor != G_BORDERCOLOR)
+ fprintf (fout, "\tbordercolor:\t%s\n",
+ get_color_str (g->bordercolor));
+
+ if (g->width != G_WIDTH)
+ fprintf (fout, "\twidth:\t%d\n", g->width);
+ if (g->height != G_HEIGHT)
+ fprintf (fout, "\theight:\t%d\n", g->height);
+ if (g->borderwidth != G_BORDERWIDTH)
+ fprintf (fout, "\tborderwidth:\t%d\n", g->borderwidth);
+
+ if (g->x != G_X)
+ fprintf (fout, "\tx:\t%d\n", g->x);
+ if (g->y != G_Y)
+ fprintf (fout, "\ty:\t%d\n", g->y);
+
+ if (g->folding != G_FOLDING)
+ fprintf (fout, "\tfolding:\t%d\n", g->folding);
+
+ if (g->shrink != G_SHRINK)
+ fprintf (fout, "\tshrink:\t%d\n", g->shrink);
+ if (g->expand != G_EXPAND)
+ fprintf (fout, "\texpand:\t%d\n", g->expand);
+
+ if (g->textmode != G_TEXTMODE)
+ fprintf (fout, "\ttextmode:\t%s\n",
+ get_textmode_str (g->textmode));
+
+ if (g->shape != G_SHAPE)
+ fprintf (fout, "\tshape:\t%s\n", get_shape_str (g->shape));
+
+ if (g->vertical_order != G_VERTICAL_ORDER)
+ fprintf (fout, "\tvertical_order:\t%d\n", g->vertical_order);
+ if (g->horizontal_order != G_HORIZONTAL_ORDER)
+ fprintf (fout, "\thorizontal_order:\t%d\n", g->horizontal_order);
+
+ if (g->xmax != G_XMAX)
+ fprintf (fout, "\txmax:\t%d\n", g->xmax);
+ if (g->ymax != G_YMAX)
+ fprintf (fout, "\tymax:\t%d\n", g->ymax);
+
+ if (g->xbase != G_XBASE)
+ fprintf (fout, "\txbase:\t%d\n", g->xbase);
+ if (g->ybase != G_YBASE)
+ fprintf (fout, "\tybase:\t%d\n", g->ybase);
+
+ if (g->xspace != G_XSPACE)
+ fprintf (fout, "\txspace:\t%d\n", g->xspace);
+ if (g->yspace != G_YSPACE)
+ fprintf (fout, "\tyspace:\t%d\n", g->yspace);
+ if (g->xlspace != G_XLSPACE)
+ fprintf (fout, "\txlspace:\t%d\n", g->xlspace);
+
+ if (g->xraster != G_XRASTER)
+ fprintf (fout, "\txraster:\t%d\n", g->xraster);
+ if (g->yraster != G_YRASTER)
+ fprintf (fout, "\tyraster:\t%d\n", g->yraster);
+ if (g->xlraster != G_XLRASTER)
+ fprintf (fout, "\txlraster:\t%d\n", g->xlraster);
+
+ if (g->hidden != G_HIDDEN)
+ fprintf (fout, "\thidden:\t%d\n", g->hidden);
+
+ /* FIXME: Unallocate struct list if required.
+ Maybe with a little function. */
+ if (g->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);
+ struct classname *ite;
+
+ for (ite = g->classname; ite; ite = ite->next)
+ fprintf (fout, "\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
+ if (g->infoname != G_INFONAME)
+ {
+ struct infoname *ite;
-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);
-}
+ for (ite = g->infoname; ite; ite = ite->next)
+ fprintf (fout, "\tinfoname %d :\t%s\n", ite->integer, ite->chars);
+ }
-#endif /* not DEBUG */
+ if (g->colorentry != G_COLORENTRY)
+ {
+ struct colorentry *ite;
+
+ for (ite = g->colorentry; ite; ite = ite->next)
+ {
+ fprintf (fout, "\tcolorentry %d :\t%d %d %d\n",
+ ite->color_index,
+ ite->red_cp,
+ ite->green_cp,
+ ite->blue_cp);
+ }
+ }
+
+ if (g->layoutalgorithm != G_LAYOUTALGORITHM)
+ fprintf (fout, "\tlayoutalgorithm:\t%s\n",
+ get_layoutalgorithm_str (g->layoutalgorithm));
+
+ if (g->layout_downfactor != G_LAYOUT_DOWNFACTOR)
+ fprintf (fout, "\tlayout_downfactor:\t%d\n", g->layout_downfactor);
+ if (g->layout_upfactor != G_LAYOUT_UPFACTOR)
+ fprintf (fout, "\tlayout_upfactor:\t%d\n", g->layout_upfactor);
+ if (g->layout_nearfactor != G_LAYOUT_NEARFACTOR)
+ fprintf (fout, "\tlayout_nearfactor:\t%d\n", g->layout_nearfactor);
+ if (g->layout_splinefactor != G_LAYOUT_SPLINEFACTOR)
+ fprintf (fout, "\tlayout_splinefactor:\t%d\n",
+ g->layout_splinefactor);
+
+ if (g->late_edge_labels != G_LATE_EDGE_LABELS)
+ fprintf (fout, "\tlate_edge_labels:\t%s\n",
+ get_decision_str (g->late_edge_labels));
+ if (g->display_edge_labels != G_DISPLAY_EDGE_LABELS)
+ fprintf (fout, "\tdisplay_edge_labels:\t%s\n",
+ get_decision_str (g->display_edge_labels));
+ if (g->dirty_edge_labels != G_DIRTY_EDGE_LABELS)
+ fprintf (fout, "\tdirty_edge_labels:\t%s\n",
+ get_decision_str (g->dirty_edge_labels));
+ if (g->finetuning != G_FINETUNING)
+ fprintf (fout, "\tfinetuning:\t%s\n",
+ get_decision_str (g->finetuning));
+ if (g->ignore_singles != G_IGNORE_SINGLES)
+ fprintf (fout, "\tignore_singles:\t%s\n",
+ get_decision_str (g->ignore_singles));
+ if (g->long_straight_phase != G_LONG_STRAIGHT_PHASE)
+ fprintf (fout, "\tlong_straight_phase:\t%s\n",
+ get_decision_str (g->long_straight_phase));
+ if (g->priority_phase != G_PRIORITY_PHASE)
+ fprintf (fout, "\tpriority_phase:\t%s\n",
+ get_decision_str (g->priority_phase));
+ if (g->manhattan_edges != G_MANHATTAN_EDGES)
+ fprintf (fout,
+ "\tmanhattan_edges:\t%s\n",
+ get_decision_str (g->manhattan_edges));
+ if (g->smanhattan_edges != G_SMANHATTAN_EDGES)
+ fprintf (fout,
+ "\tsmanhattan_edges:\t%s\n",
+ get_decision_str (g->smanhattan_edges));
+ if (g->near_edges != G_NEAR_EDGES)
+ fprintf (fout, "\tnear_edges:\t%s\n",
+ get_decision_str (g->near_edges));
+
+ if (g->orientation != G_ORIENTATION)
+ fprintf (fout, "\torientation:\t%s\n",
+ get_orientation_str (g->orientation));
+
+ if (g->node_alignment != G_NODE_ALIGNMENT)
+ fprintf (fout, "\tnode_alignment:\t%s\n",
+ get_node_alignment_str (g->node_alignment));
+
+ if (g->port_sharing != G_PORT_SHARING)
+ fprintf (fout, "\tport_sharing:\t%s\n",
+ get_decision_str (g->port_sharing));
+
+ if (g->arrow_mode != G_ARROW_MODE)
+ fprintf (fout, "\tarrow_mode:\t%s\n",
+ get_arrow_mode_str (g->arrow_mode));
+
+ if (g->treefactor != G_TREEFACTOR)
+ fprintf (fout, "\ttreefactor:\t%f\n", g->treefactor);
+ if (g->spreadlevel != G_SPREADLEVEL)
+ fprintf (fout, "\tspreadlevel:\t%d\n", g->spreadlevel);
+
+ if (g->crossing_weight != G_CROSSING_WEIGHT)
+ fprintf (fout, "\tcrossing_weight:\t%s\n",
+ get_crossing_type_str (g->crossing_weight));
+ if (g->crossing_phase2 != G_CROSSING_PHASE2)
+ fprintf (fout, "\tcrossing_phase2:\t%s\n",
+ get_decision_str (g->crossing_phase2));
+ if (g->crossing_optimization != G_CROSSING_OPTIMIZATION)
+ fprintf (fout, "\tcrossing_optimization:\t%s\n",
+ get_decision_str (g->crossing_optimization));
+
+ if (g->view != G_VIEW)
+ fprintf (fout, "\tview:\t%s\n", get_view_str (g->view));
+
+ if (g->edges != G_EDGES)
+ fprintf (fout, "\tedges:\t%s\n", get_decision_str (g->edges));
+
+ if (g->nodes != G_NODES)
+ fprintf (fout,"\tnodes:\t%s\n", get_decision_str (g->nodes));
+
+ if (g->splines != G_SPLINES)
+ fprintf (fout, "\tsplines:\t%s\n", get_decision_str (g->splines));
+
+ if (g->bmax != G_BMAX)
+ fprintf (fout, "\tbmax:\t%d\n", g->bmax);
+ if (g->cmin != G_CMIN)
+ fprintf (fout, "\tcmin:\t%d\n", g->cmin);
+ if (g->cmax != G_CMAX)
+ fprintf (fout, "\tcmax:\t%d\n", g->cmax);
+ if (g->pmin != G_PMIN)
+ fprintf (fout, "\tpmin:\t%d\n", g->pmin);
+ if (g->pmax != G_PMAX)
+ fprintf (fout, "\tpmax:\t%d\n", g->pmax);
+ if (g->rmin != G_RMIN)
+ fprintf (fout, "\trmin:\t%d\n", g->rmin);
+ if (g->rmax != G_RMAX)
+ fprintf (fout, "\trmax:\t%d\n", g->rmax);
+ if (g->smax != G_SMAX)
+ fprintf (fout, "\tsmax:\t%d\n", g->smax);
+}
projects / bison.git / blobdiff