]> git.saurik.com Git - bison.git/blobdiff - src/vcg.c
projects / bison.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* data/glr.c (yyuserMerge, yyreportAmbiguity, yyreportSyntaxError):
[bison.git] / src / vcg.c
diff --git a/src/vcg.c b/src/vcg.c
index 9c4701a9eb68a8fdf57542b4135a6b380a5ebc46..fa5133888b7e089e12a0f2652bed62bfaff7604c 100644 (file)
--- a/src/vcg.c
+++ b/src/vcg.c
@@ -1,5 +1,6 @@
 /* VCG description handler for Bison.
 /* VCG description handler for Bison.
-   Copyright 2001 Free Software Foundation, Inc.
+
+   Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -15,18 +16,30 @@
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to
 
    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.  */
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 #include "system.h"
 
 #include "system.h"
+
+#include <quotearg.h>
+
 #include "vcg.h"
 #include "vcg_defaults.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
 
 /* 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->title = G_TITLE;
   g->label = G_LABEL;
@@ -51,6 +64,9 @@ new_graph (graph_t *g)
   g->textmode = G_TEXTMODE;
   g->shape = G_SHAPE;
 
   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->xmax = G_XMAX; /* Not output. */
   g->ymax = G_YMAX; /* Not output. */
 
@@ -69,7 +85,6 @@ new_graph (graph_t *g)
 
   g->classname = G_CLASSNAME; /* No class name association. */
 
 
   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_downfactor = G_LAYOUT_DOWNFACTOR;
   g->layout_upfactor = G_LAYOUT_UPFACTOR;
   g->layout_nearfactor = G_LAYOUT_NEARFACTOR;
@@ -80,14 +95,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->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->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->port_sharing = G_PORT_SHARING;
   g->arrow_mode = G_ARROW_MODE;
   g->treefactor = G_TREEFACTOR;
@@ -113,90 +127,90 @@ new_graph (graph_t *g)
   g->node_list = G_NODE_LIST;
   g->edge_list = G_EDGE_LIST;
 
   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
 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->stretch = N_STRETCH;
 
 
-  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
 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;
 }
 
 /*----------------------------------------------.
 }
 
 /*----------------------------------------------.
-| Get functions.                                       |
+| Get functions.                               |
 | Return string corresponding to an enum value. |
 `----------------------------------------------*/
 
 static const char *
 | Return string corresponding to an enum value. |
 `----------------------------------------------*/
 
 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";
     {
     case white:                return "white";
     case blue:         return "blue";
@@ -230,209 +244,186 @@ get_color_str (enum color_e c)
     case orange:       return "orange";
     case orchid:       return "orchid";
     case black:                return "black";
     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);
+    default:           abort (); return NULL;
     }
     }
-  return NULL;
 }
 
 static const char *
 }
 
 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";
     {
     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);
+    default:           abort (); return NULL;
     }
     }
-  return NULL;
 }
 
 static const char *
 }
 
 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";
     {
     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);
+    default:           abort (); return NULL;
     }
     }
-  return NULL;
 }
 
 static const char *
 }
 
 static const char *
-get_layoutalgorithm_str (enum layoutalgorithm_e l)
+get_decision_str (enum decision decision)
 {
 {
-  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)
+  switch (decision)
     {
     case no:   return "no";
     case yes:  return "yes";
     {
     case no:   return "no";
     case yes:  return "yes";
-    default:
-      complain (_("vcg graph: no such a decision.."));
-      return get_decision_str(defaults, 0);
+    default:   abort (); return NULL;
     }
     }
-  return NULL;
 }
 
 static const char *
 }
 
 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";
     {
     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 *
 }
 
 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";
     {
     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 *
 }
 
 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";
     {
     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 *
 }
 
 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";
     {
     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);
+    default:           abort (); return NULL;
     }
     }
-  return NULL;
 }
 
 static const char *
 }
 
 static const char *
-get_view_str (enum view_e v)
+get_view_str (enum view view)
 {
 {
-  switch (v)
+  /* There is no way with vcg 1.30 to specify a normal view explicitly,
+     so it is an error here if view == normal_view.  */
+  switch (view)
     {
     {
-    case normal_view:  return "normal_view";
     case cfish:                return "cfish";
     case pfish:                return "pfish";
     case fcfish:       return "fcfish";
     case fpfish:       return "fpfish";
     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);
+    default:           abort (); return NULL;
     }
     }
-  return NULL;
 }
 
 static const char *
 }
 
 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";
     {
     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);
+    default:           abort (); return NULL;
     }
     }
-  return NULL;
 }
 
 static const char *
 }
 
 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";
     {
     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
 
 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
 }
 
 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,396 +431,409 @@ add_edge (graph_t *graph, edge_t *edge)
 `-------------------------------------*/
 
 void
 `-------------------------------------*/
 
 void
-open_edge(edge_t *edge, struct obstack *os)
+open_edge (edge *e, FILE *fout)
 {
 {
-  switch (edge->type)
+  switch (e->type)
     {
     case normal_edge:
     {
     case normal_edge:
-      obstack_sgrow (os, "\tedge: {\n");
+      fputs ("\tedge: {\n", fout);
       break;
     case back_edge:
       break;
     case back_edge:
-      obstack_sgrow (os, "\tbackedge: {\n");
+      fputs ("\tbackedge: {\n", fout);
       break;
     case near_edge:
       break;
     case near_edge:
-      obstack_sgrow (os, "\tnearedge: {\n");
+      fputs ("\tnearedge: {\n", fout);
       break;
     case bent_near_edge:
       break;
     case bent_near_edge:
-      obstack_sgrow (os, "\tbentnearedge: {\n");
+      fputs ("\tbentnearedge: {\n", fout);
       break;
     default:
       break;
     default:
-      obstack_sgrow (os, "\tedge: {\n");
+      fputs ("\tedge: {\n", fout);
     }
 }
 
 void
     }
 }
 
 void
-close_edge(struct obstack *os)
+close_edge (FILE *fout)
 {
 {
-  obstack_sgrow (os, "\t}\n");
+  fputs ("\t}\n", fout);
 }
 
 void
 }
 
 void
-open_node(struct obstack *os)
+open_node (FILE *fout)
 {
 {
-  obstack_sgrow (os, "\tnode: {\n");
+  fputs ("\tnode: {\n", fout);
 }
 
 void
 }
 
 void
-close_node(struct obstack *os)
+close_node (FILE *fout)
 {
 {
-  obstack_sgrow (os, "\t}\n");
+  fputs ("\t}\n", fout);
 }
 
 void
 }
 
 void
-open_graph(struct obstack *os)
+open_graph (FILE *fout)
 {
 {
-  obstack_sgrow (os, "graph: {\n");
+  fputs ("graph: {\n", fout);
 }
 
 void
 }
 
 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
 `-------------------------------------------*/
 
 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->stretch != N_STRETCH)
+    fprintf (fout, "\t\tstretch:\t%d\n", n->stretch);
+
+  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
 }
 
 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", 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
 }
 
 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->stretch != G_STRETCH)
+    fprintf (fout, "\tstretch:\t%d\n", g->stretch);
+
+  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 = graph->classname; ite; ite = ite->next)
-       obstack_fgrow2 (os, "\tclassname %d :\t%s\n", ite->no, ite->name);
+      for (ite = g->classname; ite; ite = ite->next)
+       fprintf (fout, "\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->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 != normal_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);
 }
 }
bison