]> git.saurik.com Git - bison.git/blame_incremental - src/vcg.c
projects / bison.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
* src/reader.c (grammar_rule_begin, previous_rule, current_rule):
[bison.git] / src / vcg.c
... / ...
CommitLineData
1/* VCG description handler for Bison.
2 Copyright 2001 Free Software Foundation, Inc.
3
4 This file is part of Bison, the GNU Compiler Compiler.
5
6 Bison is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 Bison is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with Bison; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
21#include "system.h"
22#include "vcg.h"
23#include "vcg_defaults.h"
24#include "quotearg.h"
25
26/* Return an unambiguous printable representated, allocated in slot 0,
27 for NAME, suitable for C strings. */
28static char const *
29quote (char const *name)
30{
31 return quotearg_n_style (0, c_quoting_style, name);
32}
33
34
35/* Initialize a graph with the default values. */
36void
37new_graph (graph_t *g)
38{
39 g->title = G_TITLE;
40 g->label = G_LABEL;
41
42 g->infos[0] = G_INFOS1;
43 g->infos[1] = G_INFOS2;
44 g->infos[2] = G_INFOS3;
45
46 g->color = G_COLOR;
47 g->textcolor = G_TEXTCOLOR;
48 g->bordercolor = G_BORDERCOLOR;
49
50 g->width = G_WIDTH;
51 g->height = G_HEIGHT;
52 g->borderwidth = G_BORDERWIDTH;
53 g->x = G_X;
54 g->y = G_Y;
55 g->folding = G_FOLDING;
56 g->shrink = G_SHRINK;
57 g->stretch = G_STRETCH;
58
59 g->textmode = G_TEXTMODE;
60 g->shape = G_SHAPE;
61
62 g->vertical_order = G_VERTICAL_ORDER;
63 g->horizontal_order = G_HORIZONTAL_ORDER;
64
65 g->xmax = G_XMAX; /* Not output. */
66 g->ymax = G_YMAX; /* Not output. */
67
68 g->xbase = G_XBASE;
69 g->ybase = G_YBASE;
70
71 g->xspace = G_XSPACE;
72 g->yspace = G_YSPACE;
73 g->xlspace = G_XLSPACE; /* Not output. */
74
75 g->xraster = G_XRASTER;
76 g->yraster = G_YRASTER;
77 g->xlraster = G_XLRASTER;
78
79 g->hidden = G_HIDDEN; /* No default value. */
80
81 g->classname = G_CLASSNAME; /* No class name association. */
82
83 g->layoutalgorithm = G_LAYOUTALGORITHM;
84 g->layout_downfactor = G_LAYOUT_DOWNFACTOR;
85 g->layout_upfactor = G_LAYOUT_UPFACTOR;
86 g->layout_nearfactor = G_LAYOUT_NEARFACTOR;
87 g->layout_splinefactor = G_LAYOUT_SPLINEFACTOR;
88
89 g->late_edge_labels = G_LATE_EDGE_LABELS;
90 g->display_edge_labels = G_DISPLAY_EDGE_LABELS;
91 g->dirty_edge_labels = G_DIRTY_EDGE_LABELS;
92 g->finetuning = G_FINETUNING;
93 g->ignore_singles = G_IGNORE_SINGLES;
94 g->straight_phase = G_STRAIGHT_PHASE;
95 g->priority_phase = G_PRIORITY_PHASE;
96 g->manhattan_edges = G_MANHATTAN_EDGES;
97 g->smanhattan_edges = G_SMANHATTAN_EDGES;
98 g->near_edges = G_NEAR_EDGES;
99
100 g->orientation = G_ORIENTATION;
101 g->node_alignement = G_NODE_ALIGNEMENT;
102 g->port_sharing = G_PORT_SHARING;
103 g->arrow_mode = G_ARROW_MODE;
104 g->treefactor = G_TREEFACTOR;
105 g->spreadlevel = G_SPREADLEVEL;
106 g->crossing_weight = G_CROSSING_WEIGHT;
107 g->crossing_phase2 = G_CROSSING_PHASE2;
108 g->crossing_optimization = G_CROSSING_OPTIMIZATION;
109 g->view = G_VIEW;
110
111 g->edges = G_EDGES;
112 g->nodes = G_NODES;
113 g->splines = G_SPLINES;
114
115 g->bmax = G_BMAX;
116 g->cmin = G_CMIN;
117 g->cmax = G_CMAX;
118 g->pmin = G_PMIN;
119 g->pmax = G_PMAX;
120 g->rmin = G_RMIN;
121 g->rmax = G_RMAX;
122 g->smax = G_SMAX;
123
124 g->node_list = G_NODE_LIST;
125 g->edge_list = G_EDGE_LIST;
126
127 new_edge(&g->edge);
128 new_node(&g->node);
129}
130
131/* Initialize a node with the defalut values. */
132void
133new_node (node_t *node)
134{
135 node->title = N_TITLE;
136 node->label = N_LABEL;
137
138 node->locx = N_LOCX; /* Default unspcified. */
139 node->locy = N_LOCY; /* Default unspcified. */
140
141 node->vertical_order = N_VERTICAL_ORDER; /* Default unspcified. */
142 node->horizontal_order = N_HORIZONTAL_ORDER; /* Default unspcified. */
143
144 node->width = N_WIDTH; /* We assume that we can't define it now. */
145 node->height = N_HEIGHT; /* Also. */
146
147 node->shrink = N_SHRINK;
148 node->stretch = N_STRETCH;
149
150 node->folding = N_FOLDING; /* No explicit default value. */
151
152 node->shape = N_SHAPE;
153 node->textmode = N_TEXTMODE;
154 node->borderwidth = N_BORDERWIDTH;
155
156 node->color = N_COLOR;
157 node->textcolor = N_TEXTCOLOR;
158 node->bordercolor = N_BORDERCOLOR;
159
160 node->infos[0] = N_INFOS1;
161 node->infos[1] = N_INFOS2;
162 node->infos[2] = N_INFOS3;
163
164 node->next = N_NEXT;
165}
166
167/* Initialize a edge with the defalut values. */
168void
169new_edge (edge_t *edge)
170{
171 edge->type = E_EDGE_TYPE;
172
173 edge->sourcename = E_SOURCENAME;
174 edge->targetname = E_TARGETNAME;
175 edge->label = E_LABEL;
176
177 edge->linestyle = E_LINESTYLE;
178 edge->thickness = E_THICKNESS;
179
180 edge->class = E_CLASS;
181
182 edge->color = E_COLOR;
183 edge->textcolor = E_TEXTCOLOR;
184 edge->arrowcolor = E_ARROWCOLOR;
185 edge->backarrowcolor = E_BACKARROWCOLOR;
186
187 edge->arrowsize = E_ARROWSIZE;
188 edge->backarrowsize = E_BACKARROWSIZE;
189 edge->arrowstyle = E_ARROWSTYLE;
190
191 edge->backarrowstyle = E_BACKARROWSTYLE;
192
193 edge->priority = E_PRIORITY;
194
195 edge->anchor = E_ANCHOR;
196
197 edge->horizontal_order = E_HORIZONTAL_ORDER;
198
199 edge->next = E_NEXT;
200}
201
202/*----------------------------------------------.
203| Get functions. |
204| Return string corresponding to an enum value. |
205`----------------------------------------------*/
206
207static const char *
208get_color_str (enum color_e c)
209{
210 switch (c)
211 {
212 case white: return "white";
213 case blue: return "blue";
214 case red: return "red";
215 case green: return "green";
216 case yellow: return "yellow";
217 case magenta: return "magenta";
218 case cyan: return "cyan";
219 case darkgrey: return "darkgrey";
220 case darkblue: return "darkblue";
221 case darkred: return "darkred";
222 case darkgreen: return "darkgreen";
223 case darkyellow: return "darkyellow";
224 case darkmagenta: return "darkmagenta";
225 case darkcyan: return "darkcyan";
226 case gold: return "gold";
227 case lightgrey: return "lightgrey";
228 case lightblue: return "lightblue";
229 case lightred: return "lightred";
230 case lightgreen: return "lightgreen";
231 case lightyellow: return "lightyellow";
232 case lightmagenta: return "lightmagenta";
233 case lightcyan: return "lightcyan";
234 case lilac: return "lilac";
235 case turquoise: return "turquoise";
236 case aquamarine: return "aquamarine";
237 case khaki: return "khaki";
238 case purple: return "purple";
239 case yellowgreen: return "yellowgreen";
240 case pink: return "pink";
241 case orange: return "orange";
242 case orchid: return "orchid";
243 case black: return "black";
244 default:
245#define A_known_default_color 0
246 assert (A_known_default_color);
247 }
248 return NULL;
249}
250
251static const char *
252get_textmode_str (enum textmode_e t)
253{
254 switch (t)
255 {
256 case centered: return "center";
257 case left_justify: return "left_justify";
258 case right_justify: return "right_justify";
259 default:
260#define A_known_text_mode 0
261 assert (A_known_text_mode);
262 }
263 return NULL;
264}
265
266static const char *
267get_shape_str (enum shape_e s)
268{
269 switch (s)
270 {
271 case box: return "box";
272 case rhomb: return "rhomb";
273 case ellipse: return "ellipse";
274 case triangle: return "triangle";
275 default:
276#define A_known_shape 0
277 assert (A_known_shape);
278 }
279 return NULL;
280}
281
282static const char *
283get_layoutalgorithm_str (enum layoutalgorithm_e l)
284{
285 switch (l)
286 {
287 case normal: return "normal";
288 case maxdepth: return "maxdepth";
289 case mindepth: return "mindepth";
290 case maxdepthslow: return "maxdepthslow";
291 case mindepthslow: return "mindepthslow";
292 case maxdegree: return "maxdegree";
293 case mindegree: return "mindegree";
294 case maxindegree: return "maxindegree";
295 case minindegree: return "minindegree";
296 case maxoutdegree: return "maxoutdegree";
297 case minoutdegree: return "minoutdegree";
298 case minbackward: return "minbackward";
299 case dfs: return "dfs";
300 case tree: return "tree";
301 default:
302#define A_known_layout_algorithm 0
303 assert (A_known_layout_algorithm);
304 }
305 return NULL;
306}
307
308static const char *
309get_decision_str (enum decision_e d)
310{
311 switch (d)
312 {
313 case no: return "no";
314 case yes: return "yes";
315 default:
316#define Either_yes_nor_no 0
317 assert (Either_yes_nor_no);
318 }
319 return NULL;
320}
321
322static const char *
323get_orientation_str (enum orientation_e o)
324{
325 switch (o)
326 {
327 case top_to_bottom: return "top_to_bottom";
328 case bottom_to_top: return "bottom_to_top";
329 case left_to_right: return "left_to_right";
330 case right_to_left: return "right_to_left";
331 default:
332#define A_knownn_orientation 0
333 assert (A_knownn_orientation);
334 }
335 return NULL;
336}
337
338static const char *
339get_node_alignement_str (enum alignement_e a)
340{
341 switch (a)
342 {
343 case center: return "center";
344 case top: return "top";
345 case bottom: return "bottom";
346 default:
347#define A_known_alignement 0
348 assert (A_known_alignement);
349 }
350 return NULL;
351}
352
353static const char *
354get_arrow_mode_str (enum arrow_mode_e a)
355{
356 switch (a)
357 {
358 case fixed: return "fixed";
359 case free_a: return "free";
360 default:
361#define A_known_arrow_mode 0
362 assert (A_known_arrow_mode);
363 }
364 return NULL;
365}
366
367static const char *
368get_crossing_type_str (enum crossing_type_e c)
369{
370 switch (c)
371 {
372 case bary: return "bary";
373 case median: return "median";
374 case barymedian: return "barymedian";
375 case medianbary: return "medianbary";
376 default:
377#define A_known_crossing_type 0
378 assert (A_known_crossing_type);
379 }
380 return NULL;
381}
382
383static const char *
384get_view_str (enum view_e v)
385{
386 switch (v)
387 {
388 case normal_view: return "normal_view";
389 case cfish: return "cfish";
390 case pfish: return "pfish";
391 case fcfish: return "fcfish";
392 case fpfish: return "fpfish";
393 default:
394#define A_known_view 0
395 assert (A_known_view);
396 }
397 return NULL;
398}
399
400static const char *
401get_linestyle_str (enum linestyle_e l)
402{
403 switch (l)
404 {
405 case continuous: return "continuous";
406 case dashed: return "dashed";
407 case dotted: return "dotted";
408 case invisible: return "invisible";
409 default:
410#define A_known_line_style 0
411 assert (A_known_line_style);
412 }
413 return NULL;
414}
415
416static const char *
417get_arrowstyle_str (enum arrowstyle_e a)
418{
419 switch (a)
420 {
421 case solid: return "solid";
422 case line: return "line";
423 case none: return "none";
424 default:
425#define A_known_arrow_style 0
426 assert (A_known_arrow_style);
427 }
428 return NULL;
429}
430
431/*----------------------------.
432| Add functions. |
433| Edge and Nodes int a graph. |
434`----------------------------*/
435
436void
437add_node (graph_t *graph, node_t *node)
438{
439 node->next = graph->node_list;
440 graph->node_list = node;
441}
442
443void
444add_edge (graph_t *graph, edge_t *edge)
445{
446 edge->next = graph->edge_list;
447 graph->edge_list = edge;
448}
449
450void
451add_classname (graph_t *g, int val, const char *name)
452{
453 struct classname_s *classname;
454
455 classname = XMALLOC (struct classname_s, 1);
456 classname->no = val;
457 classname->name = name;
458 classname->next = g->classname;
459 g->classname = classname;
460}
461
462void
463add_infoname (graph_t *g, int integer, const char *string)
464{
465 struct infoname_s *infoname;
466
467 infoname = XMALLOC (struct infoname_s, 1);
468 infoname->integer = integer;
469 infoname->string = string;
470 infoname->next = g->infoname;
471 g->infoname = infoname;
472}
473
474/* Build a colorentry struct and add it to the list. */
475void
476add_colorentry (graph_t *g, int color_idx, int red_cp,
477 int green_cp, int blue_cp)
478{
479 struct colorentry_s *ce;
480
481 ce = XMALLOC (struct colorentry_s, 1);
482 ce->color_index = color_idx;
483 ce->red_cp = red_cp;
484 ce->green_cp = green_cp;
485 ce->blue_cp = blue_cp;
486 ce->next = g->colorentry;
487 g->colorentry = ce;
488}
489
490/*-------------------------------------.
491| Open and close functions (formatted) |
492`-------------------------------------*/
493
494void
495open_edge(edge_t *edge, FILE *fout)
496{
497 switch (edge->type)
498 {
499 case normal_edge:
500 fputs ("\tedge: {\n", fout);
501 break;
502 case back_edge:
503 fputs ("\tbackedge: {\n", fout);
504 break;
505 case near_edge:
506 fputs ("\tnearedge: {\n", fout);
507 break;
508 case bent_near_edge:
509 fputs ("\tbentnearedge: {\n", fout);
510 break;
511 default:
512 fputs ("\tedge: {\n", fout);
513 }
514}
515
516void
517close_edge(FILE *fout)
518{
519 fputs ("\t}\n", fout);
520}
521
522void
523open_node(FILE *fout)
524{
525 fputs ("\tnode: {\n", fout);
526}
527
528void
529close_node(FILE *fout)
530{
531 fputs ("\t}\n", fout);
532}
533
534void
535open_graph(FILE *fout)
536{
537 fputs ("graph: {\n", fout);
538}
539
540void
541close_graph(graph_t *graph, FILE *fout)
542{
543 fputc ('\n', fout);
544
545 /* FIXME: Unallocate nodes and edges if required. */
546 {
547 node_t *node;
548
549 for (node = graph->node_list; node; node = node->next)
550 {
551 open_node (fout);
552 output_node (node, fout);
553 close_node (fout);
554 }
555 }
556
557 fputc ('\n', fout);
558
559 {
560 edge_t *edge;
561
562 for (edge = graph->edge_list; edge; edge = edge->next)
563 {
564 open_edge (edge, fout);
565 output_edge (edge, fout);
566 close_edge (fout);
567 }
568 }
569
570 fputs ("}\n", fout);
571}
572
573/*-------------------------------------------.
574| Output functions (formatted) in file FOUT |
575`-------------------------------------------*/
576
577void
578output_node (node_t *node, FILE *fout)
579{
580 if (node->title != N_TITLE)
581 fprintf (fout, "\t\ttitle:\t%s\n", quote (node->title));
582 if (node->label != N_LABEL)
583 fprintf (fout, "\t\tlabel:\t%s\n", quote (node->label));
584
585 if ((node->locx != N_LOCX) && (node->locy != N_LOCY))
586 fprintf (fout, "\t\tloc { x: %d y: %d }\t\n", node->locx, node->locy);
587
588 if (node->vertical_order != N_VERTICAL_ORDER)
589 fprintf (fout, "\t\tvertical_order:\t%d\n", node->vertical_order);
590 if (node->horizontal_order != N_HORIZONTAL_ORDER)
591 fprintf (fout, "\t\thorizontal_order:\t%d\n", node->horizontal_order);
592
593 if (node->width != N_WIDTH)
594 fprintf (fout, "\t\twidth:\t%d\n", node->width);
595 if (node->height != N_HEIGHT)
596 fprintf (fout, "\t\theight:\t%d\n", node->height);
597
598 if (node->shrink != N_SHRINK)
599 fprintf (fout, "\t\tshrink:\t%d\n", node->shrink);
600 if (node->stretch != N_STRETCH)
601 fprintf (fout, "\t\tstretch:\t%d\n", node->stretch);
602
603 if (node->folding != N_FOLDING)
604 fprintf (fout, "\t\tfolding:\t%d\n", node->folding);
605
606 if (node->textmode != N_TEXTMODE)
607 fprintf (fout, "\t\ttextmode:\t%s\n",
608 get_textmode_str (node->textmode));
609
610 if (node->shape != N_SHAPE)
611 fprintf (fout, "\t\tshape:\t%s\n", get_shape_str (node->shape));
612
613 if (node->borderwidth != N_BORDERWIDTH)
614 fprintf (fout, "\t\tborderwidth:\t%d\n", node->borderwidth);
615
616 if (node->color != N_COLOR)
617 fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (node->color));
618 if (node->textcolor != N_TEXTCOLOR)
619 fprintf (fout, "\t\ttextcolor:\t%s\n",
620 get_color_str (node->textcolor));
621 if (node->bordercolor != N_BORDERCOLOR)
622 fprintf (fout, "\t\tbordercolor:\t%s\n",
623 get_color_str (node->bordercolor));
624
625 {
626 int i;
627 for (i = 0; i < 3; ++i)
628 if (node->infos[i])
629 fprintf (fout, "\t\tinfo%d:\t%s\n",
630 i, quote (node->infos[i]));
631 }
632}
633
634void
635output_edge (edge_t *edge, FILE *fout)
636{
637 /* FIXME: SOURCENAME and TARGETNAME are mandatory
638 so it has to be fatal not to give these informations. */
639 if (edge->sourcename != E_SOURCENAME)
640 fprintf (fout, "\t\tsourcename:\t%s\n", quote (edge->sourcename));
641 if (edge->targetname != E_TARGETNAME)
642 fprintf (fout, "\t\ttargetname:\t%s\n", quote (edge->targetname));
643
644 if (edge->label != E_LABEL)
645 fprintf (fout, "\t\tlabel:\t%s\n", quote (edge->label));
646
647 if (edge->linestyle != E_LINESTYLE)
648 fprintf (fout, "\t\tlinestyle:\t%s\n",
649 quote (get_linestyle_str(edge->linestyle)));
650
651 if (edge->thickness != E_THICKNESS)
652 fprintf (fout, "\t\tthickness:\t%d\n", edge->thickness);
653 if (edge->class != E_CLASS)
654 fprintf (fout, "\t\tclass:\t%d\n", edge->class);
655
656 if (edge->color != E_COLOR)
657 fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (edge->color));
658 if (edge->color != E_TEXTCOLOR)
659 fprintf (fout, "\t\ttextcolor:\t%s\n",
660 get_color_str (edge->textcolor));
661 if (edge->arrowcolor != E_ARROWCOLOR)
662 fprintf (fout, "\t\tarrowcolor:\t%s\n",
663 get_color_str (edge->arrowcolor));
664 if (edge->backarrowcolor != E_BACKARROWCOLOR)
665 fprintf (fout, "\t\tbackarrowcolor:\t%s\n",
666 get_color_str (edge->backarrowcolor));
667
668 if (edge->arrowsize != E_ARROWSIZE)
669 fprintf (fout, "\t\tarrowsize:\t%d\n", edge->arrowsize);
670 if (edge->backarrowsize != E_BACKARROWSIZE)
671 fprintf (fout, "\t\tbackarrowsize:\t%d\n", edge->backarrowsize);
672
673 if (edge->arrowstyle != E_ARROWSTYLE)
674 fprintf (fout, "\t\tarrowstyle:\t%s\n",
675 get_arrowstyle_str(edge->arrowstyle));
676 if (edge->backarrowstyle != E_BACKARROWSTYLE)
677 fprintf (fout, "\t\tbackarrowstyle:\t%s\n",
678 get_arrowstyle_str(edge->backarrowstyle));
679
680 if (edge->priority != E_PRIORITY)
681 fprintf (fout, "\t\tpriority:\t%d\n", edge->priority);
682 if (edge->anchor != E_ANCHOR)
683 fprintf (fout, "\t\tanchor:\t%d\n", edge->anchor);
684 if (edge->horizontal_order != E_HORIZONTAL_ORDER)
685 fprintf (fout, "\t\thorizontal_order:\t%d\n", edge->horizontal_order);
686}
687
688void
689output_graph (graph_t *graph, FILE *fout)
690{
691 if (graph->title)
692 fprintf (fout, "\ttitle:\t%s\n", quote (graph->title));
693 if (graph->label)
694 fprintf (fout, "\tlabel:\t%s\n", quote (graph->label));
695
696 {
697 int i;
698 for (i = 0; i < 3; ++i)
699 if (graph->infos[i])
700 fprintf (fout, "\tinfo%d:\t%s\n", i, quote (graph->infos[i]));
701 }
702
703 if (graph->color != G_COLOR)
704 fprintf (fout, "\tcolor:\t%s\n", get_color_str (graph->color));
705 if (graph->textcolor != G_TEXTCOLOR)
706 fprintf (fout, "\ttextcolor:\t%s\n", get_color_str (graph->textcolor));
707 if (graph->bordercolor != G_BORDERCOLOR)
708 fprintf (fout, "\tbordercolor:\t%s\n",
709 get_color_str (graph->bordercolor));
710
711 if (graph->width != G_WIDTH)
712 fprintf (fout, "\twidth:\t%d\n", graph->width);
713 if (graph->height != G_HEIGHT)
714 fprintf (fout, "\theight:\t%d\n", graph->height);
715 if (graph->borderwidth != G_BORDERWIDTH)
716 fprintf (fout, "\tborderwidth:\t%d\n", graph->borderwidth);
717
718 if (graph->x != G_X)
719 fprintf (fout, "\tx:\t%d\n", graph->x);
720 if (graph->y != G_Y)
721 fprintf (fout, "\ty:\t%d\n", graph->y);
722
723 if (graph->folding != G_FOLDING)
724 fprintf (fout, "\tfolding:\t%d\n", graph->folding);
725
726 if (graph->shrink != G_SHRINK)
727 fprintf (fout, "\tshrink:\t%d\n", graph->shrink);
728 if (graph->stretch != G_STRETCH)
729 fprintf (fout, "\tstretch:\t%d\n", graph->stretch);
730
731 if (graph->textmode != G_TEXTMODE)
732 fprintf (fout, "\ttextmode:\t%s\n",
733 get_textmode_str (graph->textmode));
734
735 if (graph->shape != G_SHAPE)
736 fprintf (fout, "\tshape:\t%s\n", get_shape_str (graph->shape));
737
738 if (graph->vertical_order != G_VERTICAL_ORDER)
739 fprintf (fout, "\tvertical_order:\t%d\n", graph->vertical_order);
740 if (graph->horizontal_order != G_HORIZONTAL_ORDER)
741 fprintf (fout, "\thorizontal_order:\t%d\n", graph->horizontal_order);
742
743 if (graph->xmax != G_XMAX)
744 fprintf (fout, "\txmax:\t%d\n", graph->xmax);
745 if (graph->ymax != G_YMAX)
746 fprintf (fout, "\tymax:\t%d\n", graph->ymax);
747
748 if (graph->xbase != G_XBASE)
749 fprintf (fout, "\txbase:\t%d\n", graph->xbase);
750 if (graph->ybase != G_YBASE)
751 fprintf (fout, "\tybase:\t%d\n", graph->ybase);
752
753 if (graph->xspace != G_XSPACE)
754 fprintf (fout, "\txspace:\t%d\n", graph->xspace);
755 if (graph->yspace != G_YSPACE)
756 fprintf (fout, "\tyspace:\t%d\n", graph->yspace);
757 if (graph->xlspace != G_XLSPACE)
758 fprintf (fout, "\txlspace:\t%d\n", graph->xlspace);
759
760 if (graph->xraster != G_XRASTER)
761 fprintf (fout, "\txraster:\t%d\n", graph->xraster);
762 if (graph->yraster != G_YRASTER)
763 fprintf (fout, "\tyraster:\t%d\n", graph->yraster);
764 if (graph->xlraster != G_XLRASTER)
765 fprintf (fout, "\txlraster:\t%d\n", graph->xlraster);
766
767 if (graph->hidden != G_HIDDEN)
768 fprintf (fout, "\thidden:\t%d\n", graph->hidden);
769
770 /* FIXME: Unallocate struct list if required.
771 Maybe with a little function. */
772 if (graph->classname != G_CLASSNAME)
773 {
774 struct classname_s *ite;
775
776 for (ite = graph->classname; ite; ite = ite->next)
777 fprintf (fout, "\tclassname %d :\t%s\n", ite->no, ite->name);
778 }
779
780 if (graph->infoname != G_INFONAME)
781 {
782 struct infoname_s *ite;
783
784 for (ite = graph->infoname; ite; ite = ite->next)
785 fprintf (fout, "\tinfoname %d :\t%s\n", ite->integer, ite->string);
786 }
787
788 if (graph->colorentry != G_COLORENTRY)
789 {
790 struct colorentry_s *ite;
791
792 for (ite = graph->colorentry; ite; ite = ite->next)
793 {
794 fprintf (fout, "\tcolorentry %d :\t%d %d %d\n",
795 ite->color_index,
796 ite->red_cp,
797 ite->green_cp,
798 ite->blue_cp);
799 }
800 }
801
802 if (graph->layoutalgorithm != G_LAYOUTALGORITHM)
803 fprintf (fout, "\tlayoutalgorithm:\t%s\n",
804 get_layoutalgorithm_str(graph->layoutalgorithm));
805
806 if (graph->layout_downfactor != G_LAYOUT_DOWNFACTOR)
807 fprintf (fout, "\tlayout_downfactor:\t%d\n", graph->layout_downfactor);
808 if (graph->layout_upfactor != G_LAYOUT_UPFACTOR)
809 fprintf (fout, "\tlayout_upfactor:\t%d\n", graph->layout_upfactor);
810 if (graph->layout_nearfactor != G_LAYOUT_NEARFACTOR)
811 fprintf (fout, "\tlayout_nearfactor:\t%d\n", graph->layout_nearfactor);
812 if (graph->layout_splinefactor != G_LAYOUT_SPLINEFACTOR)
813 fprintf (fout, "\tlayout_splinefactor:\t%d\n",
814 graph->layout_splinefactor);
815
816 if (graph->late_edge_labels != G_LATE_EDGE_LABELS)
817 fprintf (fout, "\tlate_edge_labels:\t%s\n",
818 get_decision_str(graph->late_edge_labels));
819 if (graph->display_edge_labels != G_DISPLAY_EDGE_LABELS)
820 fprintf (fout, "\tdisplay_edge_labels:\t%s\n",
821 get_decision_str(graph->display_edge_labels));
822 if (graph->dirty_edge_labels != G_DIRTY_EDGE_LABELS)
823 fprintf (fout, "\tdirty_edge_labels:\t%s\n",
824 get_decision_str(graph->dirty_edge_labels));
825 if (graph->finetuning != G_FINETUNING)
826 fprintf (fout, "\tfinetuning:\t%s\n",
827 get_decision_str(graph->finetuning));
828 if (graph->ignore_singles != G_IGNORE_SINGLES)
829 fprintf (fout, "\tignore_singles:\t%s\n",
830 get_decision_str(graph->ignore_singles));
831 if (graph->straight_phase != G_STRAIGHT_PHASE)
832 fprintf (fout, "\tstraight_phase:\t%s\n",
833 get_decision_str(graph->straight_phase));
834 if (graph->priority_phase != G_PRIORITY_PHASE)
835 fprintf (fout, "\tpriority_phase:\t%s\n",
836 get_decision_str(graph->priority_phase));
837 if (graph->manhattan_edges != G_MANHATTAN_EDGES)
838 fprintf (fout,
839 "\tmanhattan_edges:\t%s\n",
840 get_decision_str(graph->manhattan_edges));
841 if (graph->smanhattan_edges != G_SMANHATTAN_EDGES)
842 fprintf (fout,
843 "\tsmanhattan_edges:\t%s\n",
844 get_decision_str(graph->smanhattan_edges));
845 if (graph->near_edges != G_NEAR_EDGES)
846 fprintf (fout, "\tnear_edges:\t%s\n",
847 get_decision_str(graph->near_edges));
848
849 if (graph->orientation != G_ORIENTATION)
850 fprintf (fout, "\torientation:\t%s\n",
851 get_orientation_str(graph->orientation));
852
853 if (graph->node_alignement != G_NODE_ALIGNEMENT)
854 fprintf (fout, "\tnode_alignement:\t%s\n",
855 get_node_alignement_str(graph->node_alignement));
856
857 if (graph->port_sharing != G_PORT_SHARING)
858 fprintf (fout, "\tport_sharing:\t%s\n",
859 get_decision_str(graph->port_sharing));
860
861 if (graph->arrow_mode != G_ARROW_MODE)
862 fprintf (fout, "\tarrow_mode:\t%s\n",
863 get_arrow_mode_str(graph->arrow_mode));
864
865 if (graph->treefactor != G_TREEFACTOR)
866 fprintf (fout, "\ttreefactor:\t%f\n", graph->treefactor);
867 if (graph->spreadlevel != G_SPREADLEVEL)
868 fprintf (fout, "\tspreadlevel:\t%d\n", graph->spreadlevel);
869
870 if (graph->crossing_weight != G_CROSSING_WEIGHT)
871 fprintf (fout, "\tcrossing_weight:\t%s\n",
872 get_crossing_type_str(graph->crossing_weight));
873 if (graph->crossing_phase2 != G_CROSSING_PHASE2)
874 fprintf (fout, "\tcrossing_phase2:\t%s\n",
875 get_decision_str(graph->crossing_phase2));
876 if (graph->crossing_optimization != G_CROSSING_OPTIMIZATION)
877 fprintf (fout, "\tcrossing_optimization:\t%s\n",
878 get_decision_str(graph->crossing_optimization));
879
880 if (graph->view != G_VIEW)
881 fprintf (fout, "\tview:\t%s\n", get_view_str(graph->view));
882
883 if (graph->edges != G_EDGES)
884 fprintf (fout, "\tedges:\t%s\n", get_decision_str(graph->edges));
885
886 if (graph->nodes != G_NODES)
887 fprintf (fout,"\tnodes:\t%s\n", get_decision_str(graph->nodes));
888
889 if (graph->splines != G_SPLINES)
890 fprintf (fout, "\tsplines:\t%s\n", get_decision_str(graph->splines));
891
892 if (graph->bmax != G_BMAX)
893 fprintf (fout, "\tbmax:\t%d\n", graph->bmax);
894 if (graph->cmin != G_CMIN)
895 fprintf (fout, "\tcmin:\t%d\n", graph->cmin);
896 if (graph->cmax != G_CMAX)
897 fprintf (fout, "\tcmax:\t%d\n", graph->cmax);
898 if (graph->pmin != G_PMIN)
899 fprintf (fout, "\tpmin:\t%d\n", graph->pmin);
900 if (graph->pmax != G_PMAX)
901 fprintf (fout, "\tpmax:\t%d\n", graph->pmax);
902 if (graph->rmin != G_RMIN)
903 fprintf (fout, "\trmin:\t%d\n", graph->rmin);
904 if (graph->rmax != G_RMAX)
905 fprintf (fout, "\trmax:\t%d\n", graph->rmax);
906 if (graph->smax != G_SMAX)
907 fprintf (fout, "\tsmax:\t%d\n", graph->smax);
908}
bison