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