* src/reader.c (grammar_rule_begin, previous_rule, current_rule):

[bison.git] / src / vcg.c

diff --git a/src/vcg.c b/src/vcg.c
index 8e016511964c2e3aad661ad6eda13dccf72e7dc3..5e3263e4358bbceea49776a85aaad8a813b257e6 100644 (file)
--- a/src/vcg.c
+++ b/src/vcg.c
@@ -21,8 +21,16 @@
 #include "system.h"
 #include "vcg.h"
 #include "vcg_defaults.h"
 #include "system.h"
 #include "vcg.h"
 #include "vcg_defaults.h"

-#include "xalloc.h"
-#include "complain.h"
+#include "quotearg.h"
+
+/* Return an unambiguous printable representated, allocated in slot 0,
+   for NAME, suitable for C strings.  */
+static char const *
+quote (char const *name)
+{
+  return quotearg_n_style (0, c_quoting_style, name);
+}
+

 
 /* Initialize a graph with the default values. */
 void
 
 /* Initialize a graph with the default values. */
 void


@@ -51,6 +59,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. */
 


@@ -231,8 +242,8 @@ get_color_str (enum color_e c)
     case orchid:       return "orchid";
     case black:                return "black";
     default:
     case orchid:       return "orchid";
     case black:                return "black";
     default:

-      complain (_("vcg graph: no such a color."));
-      return get_color_str(G_COLOR);
+#define A_known_default_color 0
+      assert (A_known_default_color);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -246,8 +257,8 @@ get_textmode_str (enum textmode_e t)
     case left_justify: return "left_justify";
     case right_justify:        return "right_justify";
     default:
     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);
+#define A_known_text_mode 0
+      assert (A_known_text_mode);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -262,8 +273,8 @@ get_shape_str (enum shape_e s)
     case ellipse:      return "ellipse";
     case triangle:     return "triangle";
     default:
     case ellipse:      return "ellipse";
     case triangle:     return "triangle";
     default:

-      complain (_("vcg graph: no such a shape.."));
-      return get_shape_str(G_SHAPE);
+#define A_known_shape 0
+      assert (A_known_shape);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -288,21 +299,22 @@ get_layoutalgorithm_str (enum layoutalgorithm_e l)
     case dfs:          return "dfs";
     case tree:         return "tree";
     default:
     case dfs:          return "dfs";
     case tree:         return "tree";
     default:

-      return "normal";
+#define A_known_layout_algorithm 0
+      assert (A_known_layout_algorithm);

     }
   return NULL;
 }
 
 static const char *
     }
   return NULL;
 }
 
 static const char *

-get_decision_str (enum decision_e d, enum decision_e defaults)
+get_decision_str (enum decision_e d)

 {
   switch (d)
     {
     case no:   return "no";
     case yes:  return "yes";
     default:
 {
   switch (d)
     {
     case no:   return "no";
     case yes:  return "yes";
     default:

-      complain (_("vcg graph: no such a decision.."));
-      return get_decision_str(defaults, 0);
+#define Either_yes_nor_no 0
+      assert (Either_yes_nor_no);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -317,8 +329,8 @@ get_orientation_str (enum orientation_e o)
     case left_to_right: return "left_to_right";
     case right_to_left: return "right_to_left";
     default:
     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);
+#define A_knownn_orientation 0
+      assert (A_knownn_orientation);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -332,8 +344,8 @@ get_node_alignement_str (enum alignement_e a)
     case top:          return "top";
     case bottom:       return "bottom";
     default:
     case top:          return "top";
     case bottom:       return "bottom";
     default:

-      complain (_("vcg graph: no such an alignement.."));
-      return get_node_alignement_str(G_NODE_ALIGNEMENT);
+#define A_known_alignement 0
+      assert (A_known_alignement);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -346,8 +358,8 @@ get_arrow_mode_str (enum arrow_mode_e a)
     case fixed:                return "fixed";
     case free_a:       return "free";
     default:
     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);
+#define A_known_arrow_mode 0
+      assert (A_known_arrow_mode);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -362,8 +374,8 @@ get_crossing_type_str (enum crossing_type_e c)
     case barymedian:   return "barymedian";
     case medianbary:   return "medianbary";
     default:
     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);
+#define A_known_crossing_type 0
+      assert (A_known_crossing_type);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -379,8 +391,8 @@ get_view_str (enum view_e v)
     case fcfish:       return "fcfish";
     case fpfish:       return "fpfish";
     default:
     case fcfish:       return "fcfish";
     case fpfish:       return "fpfish";
     default:

-      complain (_("vcg graph: no such a view.."));
-      return get_view_str(G_VIEW);
+#define A_known_view 0
+      assert (A_known_view);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -395,8 +407,8 @@ get_linestyle_str (enum linestyle_e l)
     case dotted:       return "dotted";
     case invisible:    return "invisible";
     default:
     case dotted:       return "dotted";
     case invisible:    return "invisible";
     default:

-      complain (_("vcg graph: no such a linestyle.."));
-      return get_linestyle_str(E_LINESTYLE);
+#define A_known_line_style 0
+      assert (A_known_line_style);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -410,8 +422,8 @@ get_arrowstyle_str (enum arrowstyle_e a)
     case line: return "line";
     case none: return "none";
     default:
     case line: return "line";
     case none: return "none";
     default:

-      complain (_("vcg graph: no such an arrowstyle.."));
-      return get_arrowstyle_str(E_ARROWSTYLE);
+#define A_known_arrow_style 0
+      assert (A_known_arrow_style);

     }
   return NULL;
 }
     }
   return NULL;
 }


@@ -435,402 +447,462 @@ add_edge (graph_t *graph, edge_t *edge)
   graph->edge_list = edge;
 }
 
   graph->edge_list = edge;
 }
 

+void
+add_classname (graph_t *g, int val, const char *name)
+{
+  struct classname_s *classname;
+
+  classname = XMALLOC (struct classname_s, 1);
+  classname->no = val;
+  classname->name = name;
+  classname->next = g->classname;
+  g->classname = classname;
+}
+
+void
+add_infoname (graph_t *g, int integer, const char *string)
+{
+  struct infoname_s *infoname;
+
+  infoname = XMALLOC (struct infoname_s, 1);
+  infoname->integer = integer;
+  infoname->string = string;
+  infoname->next = g->infoname;
+  g->infoname = infoname;
+}
+
+/* Build a colorentry struct and add it to the list.  */
+void
+add_colorentry (graph_t *g, int color_idx, int red_cp,
+               int green_cp, int blue_cp)
+{
+  struct colorentry_s *ce;
+
+  ce = XMALLOC (struct colorentry_s, 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;
+}
+

 /*-------------------------------------.
 | Open and close functions (formatted) |
 `-------------------------------------*/
 
 void
 /*-------------------------------------.
 | Open and close functions (formatted) |
 `-------------------------------------*/
 
 void

-open_edge(edge_t *edge, struct obstack *os)
+open_edge(edge_t *edge, FILE *fout)

 {
   switch (edge->type)
     {
     case normal_edge:
 {
   switch (edge->type)
     {
     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_t *graph, 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_t *node;
 
     for (node = graph->node_list; node; node = node->next)
       {

-       open_node (os);
-       output_node (node, os);
-       close_node (os);
+       open_node (fout);
+       output_node (node, fout);
+       close_node (fout);

       }
   }
 
       }
   }
 

-  obstack_1grow (os, '\n');
+  fputc ('\n', fout);

 
   {
     edge_t *edge;
 
     for (edge = graph->edge_list; edge; edge = edge->next)
       {
 
   {
     edge_t *edge;
 
     for (edge = graph->edge_list; edge; edge = edge->next)
       {

-       open_edge (edge, os);
-       output_edge (edge, os);
-       close_edge (os);
+       open_edge (edge, fout);
+       output_edge (edge, 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_t *node, FILE *fout)

 {
   if (node->title != N_TITLE)
 {
   if (node->title != N_TITLE)

-    obstack_fgrow1 (os, "\t\ttitle:\t\"%s\"\n", node->title);
+    fprintf (fout, "\t\ttitle:\t%s\n", quote (node->title));

   if (node->label != N_LABEL)
   if (node->label != N_LABEL)

-    obstack_fgrow1 (os, "\t\tlabel:\t\"%s\"\n", node->label);
+    fprintf (fout, "\t\tlabel:\t%s\n", quote (node->label));

 
   if ((node->locx != N_LOCX) && (node->locy != N_LOCY))
 
   if ((node->locx != N_LOCX) && (node->locy != N_LOCY))

-    obstack_fgrow2 (os, "\t\tloc { x: %d  y: %d }\t\n", node->locx, node->locy);
+    fprintf (fout, "\t\tloc { x: %d  y: %d }\t\n", node->locx, node->locy);

 
   if (node->vertical_order != N_VERTICAL_ORDER)
 
   if (node->vertical_order != N_VERTICAL_ORDER)

-    obstack_fgrow1 (os, "\t\tvertical_order:\t%d\n", node->vertical_order);
+    fprintf (fout, "\t\tvertical_order:\t%d\n", node->vertical_order);

   if (node->horizontal_order != N_HORIZONTAL_ORDER)
   if (node->horizontal_order != N_HORIZONTAL_ORDER)

-    obstack_fgrow1 (os, "\t\thorizontal_order:\t%d\n", node->horizontal_order);
+    fprintf (fout, "\t\thorizontal_order:\t%d\n", node->horizontal_order);

 
   if (node->width != N_WIDTH)
 
   if (node->width != N_WIDTH)

-    obstack_fgrow1 (os, "\t\twidth:\t%d\n", node->width);
+    fprintf (fout, "\t\twidth:\t%d\n", node->width);

   if (node->height != N_HEIGHT)
   if (node->height != N_HEIGHT)

-    obstack_fgrow1 (os, "\t\theight:\t%d\n", node->height);
+    fprintf (fout, "\t\theight:\t%d\n", node->height);

 
   if (node->shrink != N_SHRINK)
 
   if (node->shrink != N_SHRINK)

-    obstack_fgrow1 (os, "\t\tshrink:\t%d\n", node->shrink);
+    fprintf (fout, "\t\tshrink:\t%d\n", node->shrink);

   if (node->stretch != N_STRETCH)
   if (node->stretch != N_STRETCH)

-    obstack_fgrow1 (os, "\t\tstretch:\t%d\n", node->stretch);
+    fprintf (fout, "\t\tstretch:\t%d\n", node->stretch);

 
   if (node->folding != N_FOLDING)
 
   if (node->folding != N_FOLDING)

-    obstack_fgrow1 (os, "\t\tfolding:\t%d\n", node->folding);
+    fprintf (fout, "\t\tfolding:\t%d\n", node->folding);

 
   if (node->textmode != N_TEXTMODE)
 
   if (node->textmode != N_TEXTMODE)

-    obstack_fgrow1 (os, "\t\ttextmode:\t%s\n",
-                   get_textmode_str (node->textmode));
+    fprintf (fout, "\t\ttextmode:\t%s\n",
+            get_textmode_str (node->textmode));

 
   if (node->shape != N_SHAPE)
 
   if (node->shape != N_SHAPE)

-    obstack_fgrow1 (os, "\t\tshape:\t%s\n", get_shape_str (node->shape));
+    fprintf (fout, "\t\tshape:\t%s\n", get_shape_str (node->shape));

 
   if (node->borderwidth != N_BORDERWIDTH)
 
   if (node->borderwidth != N_BORDERWIDTH)

-    obstack_fgrow1 (os, "\t\tborderwidth:\t%d\n", node->borderwidth);
+    fprintf (fout, "\t\tborderwidth:\t%d\n", node->borderwidth);

 
   if (node->color != N_COLOR)
 
   if (node->color != N_COLOR)

-    obstack_fgrow1 (os, "\t\tcolor:\t%s\n", get_color_str (node->color));
+    fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (node->color));

   if (node->textcolor != N_TEXTCOLOR)
   if (node->textcolor != N_TEXTCOLOR)

-    obstack_fgrow1 (os, "\t\ttextcolor:\t%s\n",
-                   get_color_str (node->textcolor));
+    fprintf (fout, "\t\ttextcolor:\t%s\n",
+            get_color_str (node->textcolor));

   if (node->bordercolor != N_BORDERCOLOR)
   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]);
+    fprintf (fout, "\t\tbordercolor:\t%s\n",
+            get_color_str (node->bordercolor));
+
+  {
+    int i;
+    for (i = 0; i < 3; ++i)
+      if (node->infos[i])
+       fprintf (fout, "\t\tinfo%d:\t%s\n",
+                i, quote (node->infos[i]));
+  }

 }
 
 void
 }
 
 void

-output_edge (edge_t *edge, struct obstack *os)
+output_edge (edge_t *edge, FILE *fout)

 {
   /* FIXME: SOURCENAME and TARGETNAME are mandatory
      so it has to be fatal not to give these informations.  */
   if (edge->sourcename != E_SOURCENAME)
 {
   /* 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);
+    fprintf (fout, "\t\tsourcename:\t%s\n", quote (edge->sourcename));

   if (edge->targetname != E_TARGETNAME)
   if (edge->targetname != E_TARGETNAME)

-    obstack_fgrow1 (os, "\t\ttargetname:\t\"%s\"\n", edge->targetname);
+    fprintf (fout, "\t\ttargetname:\t%s\n", quote (edge->targetname));

 
   if (edge->label != E_LABEL)
 
   if (edge->label != E_LABEL)

-    obstack_fgrow1 (os, "\t\tlabel:\t\"%s\"\n", edge->label);
+    fprintf (fout, "\t\tlabel:\t%s\n", quote (edge->label));

 
   if (edge->linestyle != E_LINESTYLE)
 
   if (edge->linestyle != E_LINESTYLE)

-    obstack_fgrow1 (os, "\t\tlinestyle:\t\"%s\"\n",
-                   get_linestyle_str(edge->linestyle));
+    fprintf (fout, "\t\tlinestyle:\t%s\n",
+            quote (get_linestyle_str(edge->linestyle)));

 
   if (edge->thickness != E_THICKNESS)
 
   if (edge->thickness != E_THICKNESS)

-    obstack_fgrow1 (os, "\t\tthickness:\t%d\n", edge->thickness);
+    fprintf (fout, "\t\tthickness:\t%d\n", edge->thickness);

   if (edge->class != E_CLASS)
   if (edge->class != E_CLASS)

-    obstack_fgrow1 (os, "\t\tclass:\t%d\n", edge->class);
+    fprintf (fout, "\t\tclass:\t%d\n", edge->class);

 
   if (edge->color != E_COLOR)
 
   if (edge->color != E_COLOR)

-    obstack_fgrow1 (os, "\t\tcolor:\t%s\n", get_color_str (edge->color));
+    fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (edge->color));

   if (edge->color != E_TEXTCOLOR)
   if (edge->color != E_TEXTCOLOR)

-    obstack_fgrow1 (os, "\t\ttextcolor:\t%s\n",
-                   get_color_str (edge->textcolor));
+    fprintf (fout, "\t\ttextcolor:\t%s\n",
+            get_color_str (edge->textcolor));

   if (edge->arrowcolor != E_ARROWCOLOR)
   if (edge->arrowcolor != E_ARROWCOLOR)

-    obstack_fgrow1 (os, "\t\tarrowcolor:\t%s\n",
-                   get_color_str (edge->arrowcolor));
+    fprintf (fout, "\t\tarrowcolor:\t%s\n",
+            get_color_str (edge->arrowcolor));

   if (edge->backarrowcolor != E_BACKARROWCOLOR)
   if (edge->backarrowcolor != E_BACKARROWCOLOR)

-    obstack_fgrow1 (os, "\t\tbackarrowcolor:\t%s\n",
-                   get_color_str (edge->backarrowcolor));
+    fprintf (fout, "\t\tbackarrowcolor:\t%s\n",
+            get_color_str (edge->backarrowcolor));

 
   if (edge->arrowsize != E_ARROWSIZE)
 
   if (edge->arrowsize != E_ARROWSIZE)

-    obstack_fgrow1 (os, "\t\tarrowsize:\t%d\n", edge->arrowsize);
+    fprintf (fout, "\t\tarrowsize:\t%d\n", edge->arrowsize);

   if (edge->backarrowsize != E_BACKARROWSIZE)
   if (edge->backarrowsize != E_BACKARROWSIZE)

-    obstack_fgrow1 (os, "\t\tbackarrowsize:\t%d\n", edge->backarrowsize);
+    fprintf (fout, "\t\tbackarrowsize:\t%d\n", edge->backarrowsize);

 
   if (edge->arrowstyle != E_ARROWSTYLE)
 
   if (edge->arrowstyle != E_ARROWSTYLE)

-    obstack_fgrow1 (os, "\t\tarrowstyle:\t%s\n",
-                   get_arrowstyle_str(edge->arrowstyle));
+    fprintf (fout, "\t\tarrowstyle:\t%s\n",
+            get_arrowstyle_str(edge->arrowstyle));

   if (edge->backarrowstyle != E_BACKARROWSTYLE)
   if (edge->backarrowstyle != E_BACKARROWSTYLE)

-    obstack_fgrow1 (os, "\t\tbackarrowstyle:\t%s\n",
-                   get_arrowstyle_str(edge->backarrowstyle));
+    fprintf (fout, "\t\tbackarrowstyle:\t%s\n",
+            get_arrowstyle_str(edge->backarrowstyle));

 
   if (edge->priority != E_PRIORITY)
 
   if (edge->priority != E_PRIORITY)

-    obstack_fgrow1 (os, "\t\tpriority:\t%d\n", edge->priority);
+    fprintf (fout, "\t\tpriority:\t%d\n", edge->priority);

   if (edge->anchor != E_ANCHOR)
   if (edge->anchor != E_ANCHOR)

-    obstack_fgrow1 (os, "\t\tanchor:\t%d\n", edge->anchor);
+    fprintf (fout, "\t\tanchor:\t%d\n", edge->anchor);

   if (edge->horizontal_order != E_HORIZONTAL_ORDER)
   if (edge->horizontal_order != E_HORIZONTAL_ORDER)

-    obstack_fgrow1 (os, "\t\thorizontal_order:\t%d\n", edge->horizontal_order);
+    fprintf (fout, "\t\thorizontal_order:\t%d\n", edge->horizontal_order);

 }
 
 void
 }
 
 void

-output_graph (graph_t *graph, struct obstack *os)
+output_graph (graph_t *graph, FILE *fout)

 {
   if (graph->title)
 {
   if (graph->title)

-    obstack_fgrow1 (os, "\ttitle:\t\"%s\"\n", graph->title);
+    fprintf (fout, "\ttitle:\t%s\n", quote (graph->title));

   if (graph->label)
   if (graph->label)

-    obstack_fgrow1 (os, "\tlabel:\t\"%s\"\n", graph->label);
+    fprintf (fout, "\tlabel:\t%s\n", quote (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]);
+  {
+    int i;
+    for (i = 0; i < 3; ++i)
+      if (graph->infos[i])
+       fprintf (fout, "\tinfo%d:\t%s\n", i, quote (graph->infos[i]));
+  }

 
   if (graph->color != G_COLOR)
 
   if (graph->color != G_COLOR)

-    obstack_fgrow1 (os, "\tcolor:\t%s\n", get_color_str (graph->color));
+    fprintf (fout, "\tcolor:\t%s\n", get_color_str (graph->color));

   if (graph->textcolor != G_TEXTCOLOR)
   if (graph->textcolor != G_TEXTCOLOR)

-    obstack_fgrow1 (os, "\ttextcolor:\t%s\n", get_color_str (graph->textcolor));
+    fprintf (fout, "\ttextcolor:\t%s\n", get_color_str (graph->textcolor));

   if (graph->bordercolor != G_BORDERCOLOR)
   if (graph->bordercolor != G_BORDERCOLOR)

-    obstack_fgrow1 (os, "\tbordercolor:\t%s\n",
-                   get_color_str (graph->bordercolor));
+    fprintf (fout, "\tbordercolor:\t%s\n",
+            get_color_str (graph->bordercolor));

 
   if (graph->width != G_WIDTH)
 
   if (graph->width != G_WIDTH)

-    obstack_fgrow1 (os, "\twidth:\t%d\n", graph->width);
+    fprintf (fout, "\twidth:\t%d\n", graph->width);

   if (graph->height != G_HEIGHT)
   if (graph->height != G_HEIGHT)

-    obstack_fgrow1 (os, "\theight:\t%d\n", graph->height);
+    fprintf (fout, "\theight:\t%d\n", graph->height);

   if (graph->borderwidth != G_BORDERWIDTH)
   if (graph->borderwidth != G_BORDERWIDTH)

-    obstack_fgrow1 (os, "\tborderwidth:\t%d\n", graph->borderwidth);
+    fprintf (fout, "\tborderwidth:\t%d\n", graph->borderwidth);

 
   if (graph->x != G_X)
 
   if (graph->x != G_X)

-    obstack_fgrow1 (os, "\tx:\t%d\n", graph->x);
+    fprintf (fout, "\tx:\t%d\n", graph->x);

   if (graph->y != G_Y)
   if (graph->y != G_Y)

-    obstack_fgrow1 (os, "\ty:\t%d\n", graph->y);
+    fprintf (fout, "\ty:\t%d\n", graph->y);

 
   if (graph->folding != G_FOLDING)
 
   if (graph->folding != G_FOLDING)

-    obstack_fgrow1 (os, "\tfolding:\t%d\n", graph->folding);
+    fprintf (fout, "\tfolding:\t%d\n", graph->folding);

 
   if (graph->shrink != G_SHRINK)
 
   if (graph->shrink != G_SHRINK)

-    obstack_fgrow1 (os, "\tshrink:\t%d\n", graph->shrink);
+    fprintf (fout, "\tshrink:\t%d\n", graph->shrink);

   if (graph->stretch != G_STRETCH)
   if (graph->stretch != G_STRETCH)

-    obstack_fgrow1 (os, "\tstretch:\t%d\n", graph->stretch);
+    fprintf (fout, "\tstretch:\t%d\n", graph->stretch);

 
   if (graph->textmode != G_TEXTMODE)
 
   if (graph->textmode != G_TEXTMODE)

-    obstack_fgrow1 (os, "\ttextmode:\t%s\n",
-                   get_textmode_str (graph->textmode));
+    fprintf (fout, "\ttextmode:\t%s\n",
+            get_textmode_str (graph->textmode));

 
   if (graph->shape != G_SHAPE)
 
   if (graph->shape != G_SHAPE)

-    obstack_fgrow1 (os, "\tshape:\t%s\n", get_shape_str (graph->shape));
+    fprintf (fout, "\tshape:\t%s\n", get_shape_str (graph->shape));
+
+  if (graph->vertical_order != G_VERTICAL_ORDER)
+    fprintf (fout, "\tvertical_order:\t%d\n", graph->vertical_order);
+  if (graph->horizontal_order != G_HORIZONTAL_ORDER)
+    fprintf (fout, "\thorizontal_order:\t%d\n", graph->horizontal_order);

 
   if (graph->xmax != G_XMAX)
 
   if (graph->xmax != G_XMAX)

-    obstack_fgrow1 (os, "\txmax:\t%d\n", graph->xmax);
+    fprintf (fout, "\txmax:\t%d\n", graph->xmax);

   if (graph->ymax != G_YMAX)
   if (graph->ymax != G_YMAX)

-    obstack_fgrow1 (os, "\tymax:\t%d\n", graph->ymax);
+    fprintf (fout, "\tymax:\t%d\n", graph->ymax);

 
   if (graph->xbase != G_XBASE)
 
   if (graph->xbase != G_XBASE)

-    obstack_fgrow1 (os, "\txbase:\t%d\n", graph->xbase);
+    fprintf (fout, "\txbase:\t%d\n", graph->xbase);

   if (graph->ybase != G_YBASE)
   if (graph->ybase != G_YBASE)

-    obstack_fgrow1 (os, "\tybase:\t%d\n", graph->ybase);
+    fprintf (fout, "\tybase:\t%d\n", graph->ybase);

 
   if (graph->xspace != G_XSPACE)
 
   if (graph->xspace != G_XSPACE)

-    obstack_fgrow1 (os, "\txspace:\t%d\n", graph->xspace);
+    fprintf (fout, "\txspace:\t%d\n", graph->xspace);

   if (graph->yspace != G_YSPACE)
   if (graph->yspace != G_YSPACE)

-    obstack_fgrow1 (os, "\tyspace:\t%d\n", graph->yspace);
+    fprintf (fout, "\tyspace:\t%d\n", graph->yspace);

   if (graph->xlspace != G_XLSPACE)
   if (graph->xlspace != G_XLSPACE)

-    obstack_fgrow1 (os, "\txlspace:\t%d\n", graph->xlspace);
+    fprintf (fout, "\txlspace:\t%d\n", graph->xlspace);

 
   if (graph->xraster != G_XRASTER)
 
   if (graph->xraster != G_XRASTER)

-    obstack_fgrow1 (os, "\txraster:\t%d\n", graph->xraster);
+    fprintf (fout, "\txraster:\t%d\n", graph->xraster);

   if (graph->yraster != G_YRASTER)
   if (graph->yraster != G_YRASTER)

-    obstack_fgrow1 (os, "\tyraster:\t%d\n", graph->yraster);
+    fprintf (fout, "\tyraster:\t%d\n", graph->yraster);

   if (graph->xlraster != G_XLRASTER)
   if (graph->xlraster != G_XLRASTER)

-    obstack_fgrow1 (os, "\txlraster:\t%d\n", graph->xlraster);
+    fprintf (fout, "\txlraster:\t%d\n", graph->xlraster);

 
   if (graph->hidden != G_HIDDEN)
 
   if (graph->hidden != G_HIDDEN)

-    obstack_fgrow1 (os, "\thidden:\t%d\n", graph->hidden);
+    fprintf (fout, "\thidden:\t%d\n", graph->hidden);

 
 

+  /* FIXME: Unallocate struct list if required.
+     Maybe with a little function.  */

   if (graph->classname != G_CLASSNAME)
     {
       struct classname_s *ite;
 
       for (ite = graph->classname; ite; ite = ite->next)
   if (graph->classname != G_CLASSNAME)
     {
       struct classname_s *ite;
 
       for (ite = graph->classname; ite; ite = ite->next)

-       obstack_fgrow2 (os, "\tclassname %d :\t%s\n", ite->no, ite->name);
+       fprintf (fout, "\tclassname %d :\t%s\n", ite->no, ite->name);
+    }
+
+  if (graph->infoname != G_INFONAME)
+    {
+      struct infoname_s *ite;
+
+      for (ite = graph->infoname; ite; ite = ite->next)
+       fprintf (fout, "\tinfoname %d :\t%s\n", ite->integer, ite->string);
+    }
+
+  if (graph->colorentry != G_COLORENTRY)
+    {
+      struct colorentry_s *ite;
+
+      for (ite = graph->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)
     }
 
   if (graph->layoutalgorithm != G_LAYOUTALGORITHM)

-    obstack_fgrow1 (os, "\tlayoutalgorithm:\t%s\n",
-                   get_layoutalgorithm_str(graph->layoutalgorithm));
+    fprintf (fout, "\tlayoutalgorithm:\t%s\n",
+            get_layoutalgorithm_str(graph->layoutalgorithm));

 
   if (graph->layout_downfactor != G_LAYOUT_DOWNFACTOR)
 
   if (graph->layout_downfactor != G_LAYOUT_DOWNFACTOR)

-    obstack_fgrow1 (os, "\tlayout_downfactor:\t%d\n", graph->layout_downfactor);
+    fprintf (fout, "\tlayout_downfactor:\t%d\n", graph->layout_downfactor);

   if (graph->layout_upfactor != G_LAYOUT_UPFACTOR)
   if (graph->layout_upfactor != G_LAYOUT_UPFACTOR)

-    obstack_fgrow1 (os, "\tlayout_upfactor:\t%d\n", graph->layout_upfactor);
+    fprintf (fout, "\tlayout_upfactor:\t%d\n", graph->layout_upfactor);

   if (graph->layout_nearfactor != G_LAYOUT_NEARFACTOR)
   if (graph->layout_nearfactor != G_LAYOUT_NEARFACTOR)

-    obstack_fgrow1 (os, "\tlayout_nearfactor:\t%d\n", graph->layout_nearfactor);
+    fprintf (fout, "\tlayout_nearfactor:\t%d\n", graph->layout_nearfactor);

   if (graph->layout_splinefactor != G_LAYOUT_SPLINEFACTOR)
   if (graph->layout_splinefactor != G_LAYOUT_SPLINEFACTOR)

-    obstack_fgrow1 (os, "\tlayout_splinefactor:\t%d\n",
-                   graph->layout_splinefactor);
+    fprintf (fout, "\tlayout_splinefactor:\t%d\n",
+            graph->layout_splinefactor);

 
   if (graph->late_edge_labels != G_LATE_EDGE_LABELS)
 
   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));
+    fprintf (fout, "\tlate_edge_labels:\t%s\n",
+            get_decision_str(graph->late_edge_labels));

   if (graph->display_edge_labels != G_DISPLAY_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));
+    fprintf (fout, "\tdisplay_edge_labels:\t%s\n",
+            get_decision_str(graph->display_edge_labels));

   if (graph->dirty_edge_labels != G_DIRTY_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));
+    fprintf (fout, "\tdirty_edge_labels:\t%s\n",
+            get_decision_str(graph->dirty_edge_labels));

   if (graph->finetuning != G_FINETUNING)
   if (graph->finetuning != G_FINETUNING)

-    obstack_fgrow1 (os, "\tfinetuning:\t%s\n",
-                   get_decision_str(graph->finetuning, G_FINETUNING));
+    fprintf (fout, "\tfinetuning:\t%s\n",
+            get_decision_str(graph->finetuning));

   if (graph->ignore_singles != G_IGNORE_SINGLES)
   if (graph->ignore_singles != G_IGNORE_SINGLES)

-    obstack_fgrow1 (os, "\tignore_singles:\t%s\n",
-                   get_decision_str(graph->ignore_singles, G_IGNORE_SINGLES));
+    fprintf (fout, "\tignore_singles:\t%s\n",
+            get_decision_str(graph->ignore_singles));

   if (graph->straight_phase != G_STRAIGHT_PHASE)
   if (graph->straight_phase != G_STRAIGHT_PHASE)

-    obstack_fgrow1 (os, "\tstraight_phase:\t%s\n",
-                   get_decision_str(graph->straight_phase, G_STRAIGHT_PHASE));
+    fprintf (fout, "\tstraight_phase:\t%s\n",
+            get_decision_str(graph->straight_phase));

   if (graph->priority_phase != G_PRIORITY_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));
+    fprintf (fout, "\tpriority_phase:\t%s\n",
+            get_decision_str(graph->priority_phase));

   if (graph->manhattan_edges != G_MANHATTAN_EDGES)
   if (graph->manhattan_edges != G_MANHATTAN_EDGES)

-    obstack_fgrow1 (os,
-                   "\tmanhattan_edges:\t%s\n",
-                   get_decision_str(graph->manhattan_edges,
-                                    G_MANHATTAN_EDGES));
+    fprintf (fout,
+            "\tmanhattan_edges:\t%s\n",
+            get_decision_str(graph->manhattan_edges));

   if (graph->smanhattan_edges != G_SMANHATTAN_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));
+    fprintf (fout,
+            "\tsmanhattan_edges:\t%s\n",
+            get_decision_str(graph->smanhattan_edges));

   if (graph->near_edges != G_NEAR_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));
+    fprintf (fout, "\tnear_edges:\t%s\n",
+            get_decision_str(graph->near_edges));

 
   if (graph->orientation != G_ORIENTATION)
 
   if (graph->orientation != G_ORIENTATION)

-    obstack_fgrow1 (os, "\torientation:\t%s\n",
-                   get_decision_str(graph->orientation, G_ORIENTATION));
+    fprintf (fout, "\torientation:\t%s\n",
+            get_orientation_str(graph->orientation));

 
   if (graph->node_alignement != G_NODE_ALIGNEMENT)
 
   if (graph->node_alignement != G_NODE_ALIGNEMENT)

-    obstack_fgrow1 (os, "\tnode_alignement:\t%s\n",
-                   get_decision_str(graph->node_alignement,
-                                    G_NODE_ALIGNEMENT));
+    fprintf (fout, "\tnode_alignement:\t%s\n",
+            get_node_alignement_str(graph->node_alignement));

 
   if (graph->port_sharing != G_PORT_SHARING)
 
   if (graph->port_sharing != G_PORT_SHARING)

-    obstack_fgrow1 (os, "\tport_sharing:\t%s\n",
-                   get_decision_str(graph->port_sharing, G_PORT_SHARING));
+    fprintf (fout, "\tport_sharing:\t%s\n",
+            get_decision_str(graph->port_sharing));

 
   if (graph->arrow_mode != G_ARROW_MODE)
 
   if (graph->arrow_mode != G_ARROW_MODE)

-    obstack_fgrow1 (os, "\tarrow_mode:\t%s\n",
-                   get_arrow_mode_str(graph->arrow_mode));
+    fprintf (fout, "\tarrow_mode:\t%s\n",
+            get_arrow_mode_str(graph->arrow_mode));

 
   if (graph->treefactor != G_TREEFACTOR)
 
   if (graph->treefactor != G_TREEFACTOR)

-    obstack_fgrow1 (os, "\ttreefactor:\t%f\n", graph->treefactor);
+    fprintf (fout, "\ttreefactor:\t%f\n", graph->treefactor);

   if (graph->spreadlevel != G_SPREADLEVEL)
   if (graph->spreadlevel != G_SPREADLEVEL)

-    obstack_fgrow1 (os, "\tspreadlevel:\t%d\n", graph->spreadlevel);
+    fprintf (fout, "\tspreadlevel:\t%d\n", graph->spreadlevel);

 
   if (graph->crossing_weight != G_CROSSING_WEIGHT)
 
   if (graph->crossing_weight != G_CROSSING_WEIGHT)

-    obstack_fgrow1 (os, "\tcrossing_weight:\t%s\n",
-                   get_crossing_type_str(graph->crossing_weight));
+    fprintf (fout, "\tcrossing_weight:\t%s\n",
+            get_crossing_type_str(graph->crossing_weight));

   if (graph->crossing_phase2 != G_CROSSING_PHASE2)
   if (graph->crossing_phase2 != G_CROSSING_PHASE2)

-    obstack_fgrow1 (os, "\tcrossing_phase2:\t%s\n",
-                   get_decision_str(graph->crossing_phase2,
-                                    G_CROSSING_PHASE2));
+    fprintf (fout, "\tcrossing_phase2:\t%s\n",
+            get_decision_str(graph->crossing_phase2));

   if (graph->crossing_optimization != G_CROSSING_OPTIMIZATION)
   if (graph->crossing_optimization != G_CROSSING_OPTIMIZATION)

-    obstack_fgrow1 (os, "\tcrossing_optimization:\t%s\n",
-                   get_decision_str(graph->crossing_optimization,
-                                    G_CROSSING_OPTIMIZATION));
+    fprintf (fout, "\tcrossing_optimization:\t%s\n",
+            get_decision_str(graph->crossing_optimization));

 
   if (graph->view != G_VIEW)
 
   if (graph->view != G_VIEW)

-    obstack_fgrow1 (os, "\tview:\t%s\n", get_view_str(graph->view));
+    fprintf (fout, "\tview:\t%s\n", get_view_str(graph->view));

 
   if (graph->edges != G_EDGES)
 
   if (graph->edges != G_EDGES)

-    obstack_fgrow1 (os, "\tedges:\t%s\n", get_decision_str(graph->edges,
-                                                          G_EDGES));
+    fprintf (fout, "\tedges:\t%s\n", get_decision_str(graph->edges));

 
   if (graph->nodes != G_NODES)
 
   if (graph->nodes != G_NODES)

-    obstack_fgrow1 (os,"\tnodes:\t%s\n",
-                   get_decision_str(graph->nodes, G_NODES));
+    fprintf (fout,"\tnodes:\t%s\n", get_decision_str(graph->nodes));

 
   if (graph->splines != G_SPLINES)
 
   if (graph->splines != G_SPLINES)

-    obstack_fgrow1 (os, "\tsplines:\t%s\n",
-                   get_decision_str(graph->splines, G_SPLINES));
+    fprintf (fout, "\tsplines:\t%s\n", get_decision_str(graph->splines));

 
   if (graph->bmax != G_BMAX)
 
   if (graph->bmax != G_BMAX)

-    obstack_fgrow1 (os, "\tbmax:\t%d\n", graph->bmax);
+    fprintf (fout, "\tbmax:\t%d\n", graph->bmax);

   if (graph->cmin != G_CMIN)
   if (graph->cmin != G_CMIN)

-    obstack_fgrow1 (os, "\tcmin:\t%d\n", graph->cmin);
+    fprintf (fout, "\tcmin:\t%d\n", graph->cmin);

   if (graph->cmax != G_CMAX)
   if (graph->cmax != G_CMAX)

-    obstack_fgrow1 (os, "\tcmax:\t%d\n", graph->cmax);
+    fprintf (fout, "\tcmax:\t%d\n", graph->cmax);

   if (graph->pmin != G_PMIN)
   if (graph->pmin != G_PMIN)

-    obstack_fgrow1 (os, "\tpmin:\t%d\n", graph->pmin);
+    fprintf (fout, "\tpmin:\t%d\n", graph->pmin);

   if (graph->pmax != G_PMAX)
   if (graph->pmax != G_PMAX)

-    obstack_fgrow1 (os, "\tpmax:\t%d\n", graph->pmax);
+    fprintf (fout, "\tpmax:\t%d\n", graph->pmax);

   if (graph->rmin != G_RMIN)
   if (graph->rmin != G_RMIN)

-    obstack_fgrow1 (os, "\trmin:\t%d\n", graph->rmin);
+    fprintf (fout, "\trmin:\t%d\n", graph->rmin);

   if (graph->rmax != G_RMAX)
   if (graph->rmax != G_RMAX)

-    obstack_fgrow1 (os, "\trmax:\t%d\n", graph->rmax);
+    fprintf (fout, "\trmax:\t%d\n", graph->rmax);

   if (graph->smax != G_SMAX)
   if (graph->smax != G_SMAX)

-    obstack_fgrow1 (os, "\tsmax:\t%d\n", graph->smax);
+    fprintf (fout, "\tsmax:\t%d\n", graph->smax);

 }
 }