X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/7cae438bd8686b33f774a9452fc8f10cd240327f..da2a7671e11663b9ad941aa3e1f3014d6ad950cb:/src/vcg.c

diff --git a/src/vcg.c b/src/vcg.c
index ecc4c41a..d5f88141 100644
--- a/src/vcg.c
+++ b/src/vcg.c
@@ -1,5 +1,6 @@
 /* VCG description handler for Bison.
-   Copyright 2001 Free Software Foundation, Inc.
+
+   Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -19,14 +20,26 @@
    Boston, MA 02111-1307, USA.  */
 
 #include "system.h"
+
+#include <quotearg.h>
+
 #include "vcg.h"
 #include "vcg_defaults.h"
-#include "xalloc.h"
-#include "complain.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;
@@ -46,11 +59,14 @@ new_graph (graph_t *g)
   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. */
 
@@ -80,14 +96,13 @@ new_graph (graph_t *g)
   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->node_alignment = G_NODE_ALIGNMENT;
   g->port_sharing = G_PORT_SHARING;
   g->arrow_mode = G_ARROW_MODE;
   g->treefactor = G_TREEFACTOR;
@@ -113,79 +128,79 @@ new_graph (graph_t *g)
   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;
+  n->title = N_TITLE;
+  n->label = N_LABEL;
 
-  node->locx = N_LOCX; /* Default unspcified. */
-  node->locy = N_LOCY; /* Default unspcified. */
+  n->locx = N_LOCX; /* Default unspcified. */
+  n->locy = N_LOCY; /* Default unspcified. */
 
-  node->vertical_order = N_VERTICAL_ORDER;	/* Default unspcified. */
-  node->horizontal_order = N_HORIZONTAL_ORDER;	/* Default unspcified. */
+  n->vertical_order = N_VERTICAL_ORDER;	/* Default unspcified. */
+  n->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. */
+  n->width = N_WIDTH; /* We assume that we can't define it now. */
+  n->height = N_HEIGHT; /* Also. */
 
-  node->shrink = N_SHRINK;
-  node->stretch = N_STRETCH;
+  n->shrink = N_SHRINK;
+  n->expand = N_EXPAND;
 
-  node->folding = N_FOLDING; /* No explicit default value. */
+  n->folding = N_FOLDING; /* No explicit default value. */
 
-  node->shape = N_SHAPE;
-  node->textmode = N_TEXTMODE;
-  node->borderwidth = N_BORDERWIDTH;
+  n->shape = N_SHAPE;
+  n->textmode = N_TEXTMODE;
+  n->borderwidth = N_BORDERWIDTH;
 
-  node->color = N_COLOR;
-  node->textcolor = N_TEXTCOLOR;
-  node->bordercolor = N_BORDERCOLOR;
+  n->color = N_COLOR;
+  n->textcolor = N_TEXTCOLOR;
+  n->bordercolor = N_BORDERCOLOR;
 
-  node->infos[0] = N_INFOS1;
-  node->infos[1] = N_INFOS2;
-  node->infos[2] = N_INFOS3;
+  n->infos[0] = N_INFOS1;
+  n->infos[1] = N_INFOS2;
+  n->infos[2] = N_INFOS3;
 
-  node->next = N_NEXT;
+  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;
 }
 
 /*----------------------------------------------.
@@ -194,9 +209,9 @@ new_edge (edge_t *edge)
 `----------------------------------------------*/
 
 static const char *
-get_color_str (enum color_e c)
+get_color_str (enum color color)
 {
-  switch (c)
+  switch (color)
     {
     case white:		return "white";
     case blue:		return "blue";
@@ -230,48 +245,39 @@ get_color_str (enum color_e c)
     case orange:	return "orange";
     case orchid:	return "orchid";
     case black:		return "black";
-    default:
-      complain (_("vcg graph: no such color."));
-      return get_color_str(G_COLOR);
+    default:		abort (); return NULL;
     }
-  return NULL;
 }
 
 static const char *
-get_textmode_str (enum textmode_e t)
+get_textmode_str (enum textmode textmode)
 {
-  switch (t)
+  switch (textmode)
     {
     case centered:	return "center";
     case left_justify:	return "left_justify";
     case right_justify:	return "right_justify";
-    default:
-      complain (_("vcg graph: no such text mode"));
-      return get_textmode_str(G_TEXTMODE);
+    default:		abort (); return NULL;
     }
-  return NULL;
 }
 
 static const char *
-get_shape_str (enum shape_e s)
+get_shape_str (enum shape shape)
 {
-  switch (s)
+  switch (shape)
     {
     case box:		return "box";
     case rhomb:		return "rhomb";
     case ellipse:	return "ellipse";
     case triangle:	return "triangle";
-    default:
-      complain (_("vcg graph: no such shape"));
-      return get_shape_str(G_SHAPE);
+    default:		abort (); return NULL;
     }
-  return NULL;
 }
 
 static const char *
-get_layoutalgorithm_str (enum layoutalgorithm_e l)
+get_layoutalgorithm_str (enum layoutalgorithm layoutalgorithm)
 {
-  switch (l)
+  switch (layoutalgorithm)
     {
     case normal:       	return "normal";
     case maxdepth:	return "maxdepth";
@@ -287,152 +293,160 @@ get_layoutalgorithm_str (enum layoutalgorithm_e l)
     case minbackward:	return "minbackward";
     case dfs:		return "dfs";
     case tree:		return "tree";
-    default:
-      return "normal";
+    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 decision)
 {
-  switch (d)
+  switch (decision)
     {
     case no:	return "no";
     case yes:	return "yes";
-    default:
-      complain (_("vcg graph: no such decision"));
-      return get_decision_str(defaults, 0);
+    default:	abort (); return NULL;
     }
-  return NULL;
 }
 
 static const char *
-get_orientation_str (enum orientation_e o)
+get_orientation_str (enum orientation orientation)
 {
-  switch (o)
+  switch (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:
-      complain (_("vcg graph: no such an orientation"));
-      return get_orientation_str(G_ORIENTATION);
+    default:		abort (); return NULL;
     }
-  return NULL;
 }
 
 static const char *
-get_node_alignement_str (enum alignement_e a)
+get_node_alignment_str (enum alignment alignment)
 {
-  switch (a)
+  switch (alignment)
     {
     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);
+    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 arrow_mode)
 {
-  switch (a)
+  switch (arrow_mode)
     {
     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);
+    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 crossing_type)
 {
-  switch (c)
+  switch (crossing_type)
     {
     case bary:		return "bary";
     case median:	return "median";
     case barymedian:	return "barymedian";
     case medianbary:	return "medianbary";
-    default:
-      complain (_("vcg graph: no such crossing_type"));
-      return get_crossing_type_str(G_CROSSING_WEIGHT);
+    default:		abort (); return NULL;
     }
-  return NULL;
 }
 
 static const char *
-get_view_str (enum view_e v)
+get_view_str (enum view view)
 {
-  switch (v)
+  switch (view)
     {
     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 view"));
-      return get_view_str(G_VIEW);
+    default:		abort (); return NULL;
     }
-  return NULL;
 }
 
 static const char *
-get_linestyle_str (enum linestyle_e l)
+get_linestyle_str (enum linestyle linestyle)
 {
-  switch (l)
+  switch (linestyle)
     {
     case continuous:	return "continuous";
     case dashed:	return "dashed";
     case dotted:	return "dotted";
     case invisible:	return "invisible";
-    default:
-      complain (_("vcg graph: no such linestyle"));
-      return get_linestyle_str(E_LINESTYLE);
+    default:		abort (); return NULL;
     }
-  return NULL;
 }
 
 static const char *
-get_arrowstyle_str (enum arrowstyle_e a)
+get_arrowstyle_str (enum arrowstyle arrowstyle)
 {
-  switch (a)
+  switch (arrowstyle)
     {
     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);
+    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 = xmalloc (sizeof *classname);
+  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 = xmalloc (sizeof *infoname);
+  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 = xmalloc (sizeof *ce);
+  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;
 }
 
 /*-------------------------------------.
@@ -440,397 +454,414 @@ add_edge (graph_t *graph, edge_t *edge)
 `-------------------------------------*/
 
 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");
+      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)
+close_node (FILE *fout)
 {
-  obstack_sgrow (os, "\t}\n");
+  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;
+    node *n;
 
-    for (node = graph->node_list; node; node = node->next)
+    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;
+    edge *e;
 
-    for (edge = graph->edge_list; edge; edge = edge->next)
+    for (e = g->edge_list; e; e = e->next)
       {
-	open_edge (edge, os);
-	output_edge (edge, os);
-	close_edge (os);
+	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\tstretch:\t%d\n", node->stretch);
-
-  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)
 {
   /* FIXME: SOURCENAME and TARGETNAME are mandatory
      so it has to be fatal not to give these informations.  */
-  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);
+  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;
+      struct classname *ite;
+
+      for (ite = g->classname; ite; ite = ite->next)
+	fprintf (fout, "\tclassname %d :\t%s\n", ite->no, ite->name);
+    }
 
-      for (ite = graph->classname; ite; ite = ite->next)
-	obstack_fgrow2 (os, "\tclassname %d :\t%s\n", ite->no, ite->name);
+  if (g->infoname != G_INFONAME)
+    {
+      struct infoname *ite;
+
+      for (ite = g->infoname; ite; ite = ite->next)
+	fprintf (fout, "\tinfoname %d :\t%s\n", ite->integer, ite->chars);
+    }
+
+  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 (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);
+  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->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);
 }