![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parsedag.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / dag|
Return to parsedag.c CVS log | Up to [Research Unix] / researchv10dc / cmd / dag |
1.1 root 1:
2: # line 2 "parsedag.y"
3: #include "draw_dag.h"
4: #include "dag.h"
5: #define MIN_RANK_SEP 4
6:
7: static pair_t* nodelist;
8: static DAG_edge_t* this_edge;
9: static boolean is_ordered = false;
10:
11: int Syntax_error;
12: DAG_node_t Reset_node,Default_node,Proto_node;
13: DAG_edge_t Reset_edge,Default_edge;
14: static boolean set_pointsize,set_label,set_shape,set_color,set_xsize,set_ysize;
15:
16: static void teardown (pair_t *e) {
17: pair_t *f;
18: while (e) {
19: f = e->next;
20: delete e;
21: e = f;
22: }
23: }
24:
25: static void init_proto() {
26: Proto_node = Default_node;
27: set_pointsize = set_label = set_shape = set_color = set_xsize = set_ysize = false;
28: }
29:
30: static void apply_proto(DAG_node_t *np) {
31: /* label setting has precedence over size! */
32: if (set_pointsize) np->setpointsize(Proto_node.pointsize);
33: if (set_label) np->setlabel(Proto_node.label.type,Proto_node.label.value);
34: if (set_shape) np->setshape(Proto_node.shape.type,Proto_node.shape.value);
35: if (set_color) np->setcolor(Proto_node.color);
36: if (set_xsize) np->setxsize(Proto_node.xsize);
37: if (set_ysize) np->setysize(Proto_node.ysize);
38: np->autosize();
39: }
40:
41: static void install_proto() {
42: Proto_node.autosize();
43: for (pair_t* p = nodelist; p; p = p->next)
44: apply_proto(Node[p->node]);
45: }
46:
47: /* append list1 to list2 */
48: static DAG_edge_t* append(DAG_edge_t *list1, DAG_edge_t *list2) {
49: if (!list2) panic("null list2");
50: DAG_edge_t *e,*f;
51: e = list2;
52: while (f = e->nextof()) e = f;
53: e->next = (edge_t*) list1;
54: return list2;
55: }
56:
57: /* create a new set of same rank nodes within the Options struct */
58: static int* &newset() {
59: const int hunksize = 16;
60: if (!Options.same_nodes)
61: Options.same_nodes = new int*[hunksize];
62: else if (!(Options.n_same_nodes % hunksize))
63: Options.same_nodes = (int**)realloc((char*)Options.same_nodes,
64: (Options.n_same_nodes + hunksize + 1)*sizeof(int*));
65: Options.same_nodes[Options.n_same_nodes] = 0;
66: return(Options.same_nodes[Options.n_same_nodes++]);
67: }
68:
69: /* take the union of same rank nodes */
70: overload set_union;
71: static void set_union (int* &ptr, pair_t *nlist) {
72: pair_t *e;
73: int olen = 0, nlen = 0;
74: for (e = nlist; e; e = e->next) nlen++;
75: if (!nlen) return;
76: if (ptr) {
77: while (ptr[olen++] >= 0);
78: ptr = (int*)realloc((char*)ptr,(nlen+olen)*sizeof(int));
79: }
80: else ptr = new int[nlen + 1];
81:
82: for (e = nlist; e; e = e->next)
83: ptr[olen++] = e->node;
84: ptr[olen] = -1;
85: }
86:
87: static void set_union(int* &ptr, DAG_edge_t *elist) {
88: pair_t *p = 0;
89: while (elist) {
90: p = new pair_t(elist->node,p);
91: elist = elist->nextof();
92: }
93: set_union(ptr,p);
94: teardown(p);
95: }
96:
97: static void make_invis_edge(int fromnode,int tonode) {
98: DAG_edge_t *e = new DAG_edge_t();
99: e->ink = invis_ink;
100: e->node = tonode;
101: e->next = Edge[fromnode];
102: Edge[fromnode] = e;
103: }
104:
105: static void enter_edgelist(int tailnode, DAG_edge_t* elist) {
106: DAG_edge_t *e;
107: if (is_ordered) {
108: set_union(newset(),elist);
109: for (e = elist; e->nextof(); e = e->nextof())
110: make_invis_edge(e->node,e->nextof()->node);
111: is_ordered = false;
112: }
113: Edge[tailnode] = append(Edge[tailnode],elist);
114: }
115:
116: static void enter_backedgelist(int headnode, DAG_edge_t* elist) {
117: DAG_edge_t *e = elist;
118: while (e) {
119: DAG_edge_t *f = e->nextof();
120: e->next = 0;
121: e->flipped = true;
122: int tailnode = e->node;
123: e->node = headnode;
124: Edge[tailnode] = append(Edge[tailnode],e);
125: e = f;
126: }
127: }
128:
129: static void enter_pathlist(int tailnode, DAG_edge_t* elist) {
130: DAG_edge_t *e,*f;
131: e = elist;
132: while (e) {
133: f = e;
134: e = e->nextof();
135: f->next = Edge[tailnode];
136: Edge[tailnode] = f;
137: tailnode = f->node;
138: }
139: is_ordered = false;
140: }
141:
142: static void enter_backpathlist(int headnode, DAG_edge_t *elist) {
143: DAG_edge_t *e = elist;
144: while (e) {
145: DAG_edge_t *f = e->nextof();
146: e->next = 0;
147: e->flipped = true;
148: int tailnode = e->node;
149: e->node = headnode;
150: Edge[tailnode] = append(Edge[tailnode],e);
151: e = f;
152: headnode = tailnode;
153: }
154: }
155:
156:
157: # line 156 "parsedag.y"
158: typedef union {
159: char *s;
160: int i;
161: pair_t *p; // for node lists
162: DAG_edge_t *e; // for edge lists
163: } YYSTYPE;
164: # define AS 257
165: # define BACKEDGE 258
166: # define BACKPATH 259
167: # define COLOR 260
168: # define DASHED 261
169: # define DOTTED 262
170: # define DRAW 263
171: # define EDGE 264
172: # define EDGES 265
173: # define EQUALLY 266
174: # define EXACTLY 267
175: # define FROM 268
176: # define HEIGHT 269
177: # define INVIS 270
178: # define LABEL 271
179: # define MAXIMUM 272
180: # define MINIMUM 273
181: # define NODES 274
182: # define ORDERED 275
183: # define PATH 276
184: # define POINTSIZE 277
185: # define RANK 278
186: # define RANKS 279
187: # define SAME 280
188: # define SEPARATE 281
189: # define SOLID 282
190: # define TO 283
191: # define WEIGHT 284
192: # define WIDTH 285
193: # define STRING 286
194: # define DESC 287
195: #define yyclearin yychar = -1
196: #define yyerrok yyerrflag = 0
197: extern int yychar;
198: extern short yyerrflag;
199: #ifndef YYMAXDEPTH
200: #define YYMAXDEPTH 150
201: #endif
202: YYSTYPE yylval, yyval;
203: # define YYERRCODE 256
204: short yyexca[] ={
205: -1, 0,
206: 0, 4,
207: 258, 4,
208: 259, 4,
209: 263, 4,
210: 264, 4,
211: 272, 4,
212: 273, 4,
213: 275, 4,
214: 276, 4,
215: 280, 4,
216: 281, 4,
217: 286, 4,
218: 59, 4,
219: -2, 0,
220: -1, 1,
221: 0, -1,
222: -2, 0,
223: -1, 36,
224: 283, 46,
225: 286, 46,
226: 59, 46,
227: 44, 46,
228: -2, 44,
229: };
230: # define YYNPROD 72
231: # define YYLAST 282
232: short yyact[]={
233:
234: 20, 81, 84, 85, 117, 58, 45, 111, 115, 114,
235: 72, 86, 79, 73, 108, 107, 58, 104, 80, 45,
236: 98, 92, 69, 83, 71, 78, 58, 58, 110, 89,
237: 70, 97, 58, 99, 105, 106, 20, 45, 68, 45,
238: 31, 96, 95, 35, 24, 39, 21, 56, 109, 88,
239: 102, 101, 91, 23, 90, 87, 21, 49, 30, 29,
240: 28, 119, 118, 21, 3, 21, 77, 103, 67, 76,
241: 36, 66, 33, 15, 50, 34, 10, 22, 27, 25,
242: 60, 26, 47, 46, 43, 7, 6, 38, 38, 38,
243: 38, 5, 4, 44, 37, 2, 1, 15, 82, 25,
244: 25, 25, 0, 48, 0, 57, 53, 54, 55, 32,
245: 62, 59, 40, 41, 42, 0, 74, 0, 75, 0,
246: 0, 0, 0, 0, 44, 44, 44, 0, 0, 0,
247: 94, 93, 0, 0, 57, 100, 57, 57, 57, 0,
248: 0, 0, 0, 112, 100, 0, 113, 61, 116, 0,
249: 63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
250: 0, 112, 0, 0, 0, 0, 0, 0, 0, 0,
251: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
252: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253: 0, 0, 0, 0, 0, 0, 0, 0, 0, 17,
254: 19, 0, 0, 0, 8, 16, 0, 0, 81, 84,
255: 85, 0, 0, 13, 12, 0, 9, 18, 86, 79,
256: 0, 14, 11, 0, 0, 80, 72, 21, 0, 73,
257: 83, 72, 78, 0, 73, 17, 19, 0, 69, 0,
258: 71, 16, 0, 69, 35, 71, 70, 21, 21, 0,
259: 0, 70, 0, 18, 68, 35, 0, 0, 21, 68,
260: 0, 21, 0, 21, 35, 35, 35, 21, 21, 21,
261: 0, 35, 51, 0, 21, 0, 0, 52, 0, 21,
262: 0, 21 };
263: short yypact[]={
264:
265: -192,-1000, -59,-1000,-1000,-1000,-1000,-1000,-221,-1000,
266: -1000,-1000,-218,-219,-220, -19,-223,-223,-223,-223,
267: -1000,-1000, -25,-1000,-1000,-1000, -23, -2,-230,-230,
268: -230,-1000, -12,-1000,-1000,-230,-1000,-240,-1000,-230,
269: -240,-240,-240,-247,-1000,-230,-247,-259,-1000,-1000,
270: -1000,-231,-237, -5, -7, -38,-1000,-1000,-240,-1000,
271: -259, -17,-1000, -18, -28, -39, -26,-1000,-235,-236,
272: -269,-252,-272,-238,-1000, -31, -52,-1000,-269,-278,
273: -269,-282,-1000,-1000,-1000,-1000,-1000,-1000,-205,-1000,
274: -1000,-1000,-1000,-1000,-259,-1000,-1000,-1000,-1000,-1000,
275: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
276: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000 };
277: short yypgo[]={
278:
279: 0, 68, 66, 98, 70, 67, 94, 109, 75, 72,
280: 77, 96, 95, 92, 91, 86, 85, 84, 71, 83,
281: 82, 69, 81, 76, 80, 78, 74 };
282: short yyr1[]={
283:
284: 0, 11, 11, 12, 12, 13, 13, 13, 17, 14,
285: 19, 14, 20, 14, 10, 10, 10, 18, 18, 1,
286: 1, 1, 1, 1, 1, 1, 1, 22, 15, 15,
287: 23, 23, 23, 23, 23, 23, 23, 6, 6, 7,
288: 7, 7, 9, 9, 24, 8, 8, 21, 21, 2,
289: 2, 2, 2, 2, 2, 16, 16, 16, 16, 25,
290: 25, 26, 26, 26, 26, 26, 3, 3, 3, 3,
291: 4, 5 };
292: short yyr2[]={
293:
294: 0, 1, 1, 2, 0, 1, 1, 1, 0, 5,
295: 0, 5, 0, 5, 2, 3, 1, 1, 2, 2,
296: 2, 2, 2, 2, 2, 2, 2, 0, 3, 1,
297: 2, 3, 4, 4, 4, 4, 1, 1, 2, 1,
298: 2, 3, 1, 2, 0, 3, 1, 1, 2, 2,
299: 2, 2, 2, 2, 1, 3, 4, 4, 4, 2,
300: 0, 2, 3, 3, 2, 2, 1, 1, 1, 1,
301: 1, 1 };
302: short yychk[]={
303:
304: -1000, -11, -12, 256, -13, -14, -15, -16, 263, 275,
305: -23, 281, 273, 272, 280, -4, 264, 258, 276, 259,
306: 59, 286, -10, 274, 265, -4, -22, -25, 278, 278,
307: 278, 59, -7, -9, -8, 283, -4, -6, -4, 268,
308: -6, -6, -6, -17, -4, 44, -19, -20, -23, 59,
309: -26, 274, 279, -10, -10, -10, 59, -9, 44, -8,
310: -24, -7, -4, -7, -7, -7, -18, -1, 285, 269,
311: 277, 271, 257, 260, -4, -18, -21, -2, 284, 271,
312: 277, 260, -3, 282, 261, 262, 270, 286, 286, 266,
313: 59, 59, 59, -9, -21, 59, 59, 59, 59, 59,
314: -1, 286, 286, -5, 286, 286, 287, 287, 286, 286,
315: 59, 59, -2, -5, 287, 286, -5, 286, 267, 266 };
316: short yydef[]={
317:
318: -2, -2, 1, 2, 3, 5, 6, 7, 0, 27,
319: 29, 60, 0, 0, 0, 0, 0, 0, 0, 0,
320: 36, 70, 8, 10, 12, 16, 0, 0, 0, 0,
321: 0, 30, 0, 39, 42, 0, -2, 0, 37, 0,
322: 0, 0, 0, 0, 14, 0, 0, 0, 28, 55,
323: 59, 0, 0, 0, 0, 0, 31, 40, 0, 43,
324: 0, 0, 38, 0, 0, 0, 0, 17, 0, 0,
325: 0, 0, 0, 0, 15, 0, 0, 47, 0, 0,
326: 0, 0, 54, 66, 67, 68, 69, 61, 65, 64,
327: 56, 57, 58, 41, 45, 32, 33, 34, 35, 9,
328: 18, 19, 20, 21, 71, 22, 23, 24, 25, 26,
329: 11, 13, 48, 49, 50, 51, 52, 53, 62, 63 };
330: # ifdef YYDEBUG
331: # include "y.debug"
332: # endif
333:
334: # define YYFLAG -1000
335: # define YYERROR goto yyerrlab
336: # define YYACCEPT return(0)
337: # define YYABORT return(1)
338:
339: /* parser for yacc output */
340:
341: #ifdef YYDEBUG
342: int yydebug = 0; /* 1 for debugging */
343: #endif
344: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
345: int yychar = -1; /* current input token number */
346: int yynerrs = 0; /* number of errors */
347: short yyerrflag = 0; /* error recovery flag */
348:
349: yyparse()
350: { short yys[YYMAXDEPTH];
351: int yyj, yym;
352: register YYSTYPE *yypvt;
353: register int yystate, yyn;
354: register short *yyps;
355: register YYSTYPE *yypv;
356: register short *yyxi;
357:
358: yystate = 0;
359: yychar = -1;
360: yynerrs = 0;
361: yyerrflag = 0;
362: yyps= &yys[-1];
363: yypv= &yyv[-1];
364:
365: yystack: /* put a state and value onto the stack */
366: #ifdef YYDEBUG
367: if(yydebug >= 3)
368: if(yychar < 0 || yytoknames[yychar] == 0)
369: printf("char %d in %s", yychar, yystates[yystate]);
370: else
371: printf("%s in %s", yytoknames[yychar], yystates[yystate]);
372: #endif
373: if( ++yyps >= &yys[YYMAXDEPTH] ) {
374: yyerror( "yacc stack overflow" );
375: return(1);
376: }
377: *yyps = yystate;
378: ++yypv;
379: *yypv = yyval;
380: yynewstate:
381: yyn = yypact[yystate];
382: if(yyn <= YYFLAG) goto yydefault; /* simple state */
383: if(yychar<0) {
384: yychar = yylex();
385: #ifdef YYDEBUG
386: if(yydebug >= 2) {
387: if(yychar <= 0)
388: printf("lex EOF\n");
389: else if(yytoknames[yychar])
390: printf("lex %s\n", yytoknames[yychar]);
391: else
392: printf("lex (%c)\n", yychar);
393: }
394: #endif
395: if(yychar < 0)
396: yychar = 0;
397: }
398: if((yyn += yychar) < 0 || yyn >= YYLAST)
399: goto yydefault;
400: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
401: yychar = -1;
402: yyval = yylval;
403: yystate = yyn;
404: if( yyerrflag > 0 ) --yyerrflag;
405: goto yystack;
406: }
407: yydefault:
408: /* default state action */
409: if( (yyn=yydef[yystate]) == -2 ) {
410: if(yychar < 0) {
411: yychar = yylex();
412: #ifdef YYDEBUG
413: if(yydebug >= 2)
414: if(yychar < 0)
415: printf("lex EOF\n");
416: else
417: printf("lex %s\n", yytoknames[yychar]);
418: #endif
419: if(yychar < 0)
420: yychar = 0;
421: }
422: /* look through exception table */
423: for(yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate);
424: yyxi += 2 ) ; /* VOID */
425: while( *(yyxi+=2) >= 0 ){
426: if( *yyxi == yychar ) break;
427: }
428: if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
429: }
430: if( yyn == 0 ){ /* error */
431: /* error ... attempt to resume parsing */
432: switch( yyerrflag ){
433: case 0: /* brand new error */
434: #ifdef YYDEBUG
435: yyerror("syntax error\n%s", yystates[yystate]);
436: if(yytoknames[yychar])
437: yyerror("saw %s\n", yytoknames[yychar]);
438: else if(yychar >= ' ' && yychar < '\177')
439: yyerror("saw `%c'\n", yychar);
440: else if(yychar == 0)
441: yyerror("saw EOF\n");
442: else
443: yyerror("saw char 0%o\n", yychar);
444: #else
445: yyerror( "syntax error" );
446: #endif
447: yyerrlab:
448: ++yynerrs;
449: case 1:
450: case 2: /* incompletely recovered error ... try again */
451: yyerrflag = 3;
452: /* find a state where "error" is a legal shift action */
453: while ( yyps >= yys ) {
454: yyn = yypact[*yyps] + YYERRCODE;
455: if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
456: yystate = yyact[yyn]; /* simulate a shift of "error" */
457: goto yystack;
458: }
459: yyn = yypact[*yyps];
460: /* the current yyps has no shift onn "error", pop stack */
461: #ifdef YYDEBUG
462: if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
463: #endif
464: --yyps;
465: --yypv;
466: }
467: /* there is no state on the stack with an error shift ... abort */
468: yyabort:
469: return(1);
470: case 3: /* no shift yet; clobber input char */
471: #ifdef YYDEBUG
472: if( yydebug ) {
473: printf("error recovery discards ");
474: if(yytoknames[yychar])
475: printf("%s\n", yytoknames[yychar]);
476: else if(yychar >= ' ' && yychar < '\177')
477: printf("`%c'\n", yychar);
478: else if(yychar == 0)
479: printf("EOF\n");
480: else
481: printf("char 0%o\n", yychar);
482: }
483: #endif
484: if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
485: yychar = -1;
486: goto yynewstate; /* try again in the same state */
487: }
488: }
489: /* reduction by production yyn */
490: #ifdef YYDEBUG
491: if(yydebug) { char *s;
492: printf("reduce %d in:\n\t", yyn);
493: for(s = yystates[yystate]; *s; s++) {
494: putchar(*s);
495: if(*s == '\n' && *(s+1))
496: putchar('\t');
497: }
498: }
499: #endif
500: yyps -= yyr2[yyn];
501: yypvt = yypv;
502: yypv -= yyr2[yyn];
503: yyval = yypv[1];
504: yym=yyn;
505: /* consult goto table to find next state */
506: yyn = yyr1[yyn];
507: yyj = yypgo[yyn] + *yyps + 1;
508: if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
509: switch(yym){
510:
511: case 1:
512: # line 171 "parsedag.y"
513: {make_drawing();} break;
514: case 8:
515: # line 184 "parsedag.y"
516: {init_proto(); nodelist = yypvt[-0].p;} break;
517: case 9:
518: # line 185 "parsedag.y"
519: {install_proto(); teardown(yypvt[-3].p);} break;
520: case 10:
521: # line 186 "parsedag.y"
522: {init_proto(); nodelist = 0;} break;
523: case 11:
524: # line 187 "parsedag.y"
525: {apply_proto(&Default_node);} break;
526: case 12:
527: # line 188 "parsedag.y"
528: {this_edge = &Default_edge;} break;
529: case 14:
530: # line 192 "parsedag.y"
531: {yyval.p = new pair_t(yypvt[-0].i,yypvt[-1].p);} break;
532: case 15:
533: # line 194 "parsedag.y"
534: {yyval.p = new pair_t(yypvt[-0].i,yypvt[-2].p);} break;
535: case 16:
536: # line 196 "parsedag.y"
537: {yyval.p = new pair_t(yypvt[-0].i,(pair_t*)0);} break;
538: case 19:
539: # line 205 "parsedag.y"
540: {
541: Proto_node.setxsize((int)(Resolution*atof(yypvt[-0].s)));
542: set_xsize = true;
543: } break;
544: case 20:
545: # line 211 "parsedag.y"
546: {
547: Proto_node.setysize((int)(Resolution*atof(yypvt[-0].s)));
548: set_ysize = true;
549: } break;
550: case 21:
551: # line 216 "parsedag.y"
552: {
553: Proto_node.setpointsize(yypvt[-0].i);
554: set_pointsize = true;
555: } break;
556: case 22:
557: # line 221 "parsedag.y"
558: {
559: Proto_node.setlabel(STRING,yypvt[-0].s);
560: set_label = true;
561: } break;
562: case 23:
563: # line 226 "parsedag.y"
564: {
565: Proto_node.setlabel(DESC,yypvt[-0].s);
566: set_label = true;
567: } break;
568: case 24:
569: # line 231 "parsedag.y"
570: {
571: Proto_node.setshape(DESC,yypvt[-0].s);
572: set_shape = true;
573: } break;
574: case 25:
575: # line 236 "parsedag.y"
576: {
577: Proto_node.setshape(STRING,yypvt[-0].s);
578: set_shape = true;
579: } break;
580: case 26:
581: # line 241 "parsedag.y"
582: {
583: Proto_node.setcolor(yypvt[-0].s);
584: set_color = true;
585: } break;
586: case 27:
587: # line 247 "parsedag.y"
588: {is_ordered = true;} break;
589: case 31:
590: # line 253 "parsedag.y"
591: {enter_edgelist(yypvt[-2].i,yypvt[-1].e);} break;
592: case 32:
593: # line 255 "parsedag.y"
594: {enter_edgelist(yypvt[-2].i,yypvt[-1].e);} break;
595: case 33:
596: # line 257 "parsedag.y"
597: {enter_backedgelist(yypvt[-2].i,yypvt[-1].e);} break;
598: case 34:
599: # line 259 "parsedag.y"
600: {enter_pathlist(yypvt[-2].i,yypvt[-1].e);} break;
601: case 35:
602: # line 261 "parsedag.y"
603: {enter_backpathlist(yypvt[-2].i,yypvt[-1].e);} break;
604: case 38:
605: # line 267 "parsedag.y"
606: {yyval.i = yypvt[-0].i;} break;
607: case 40:
608: # line 271 "parsedag.y"
609: {yyval.e = append(yypvt[-0].e,yypvt[-1].e);} break;
610: case 41:
611: # line 273 "parsedag.y"
612: {yyval.e = append(yypvt[-0].e,yypvt[-2].e);} break;
613: case 43:
614: # line 278 "parsedag.y"
615: {yyval.e = yypvt[-0].e;} break;
616: case 44:
617: # line 282 "parsedag.y"
618: {
619: this_edge = new DAG_edge_t();
620: *this_edge = Default_edge;
621: this_edge->node = yypvt[-0].i;
622: } break;
623: case 45:
624: # line 288 "parsedag.y"
625: {yyval.e = this_edge;} break;
626: case 46:
627: # line 290 "parsedag.y"
628: {
629: this_edge = new DAG_edge_t();
630: *this_edge = Default_edge;
631: this_edge->node = yypvt[-0].i;
632: yyval.e = this_edge;
633: } break;
634: case 49:
635: # line 303 "parsedag.y"
636: {this_edge->setweight(yypvt[-0].i);} break;
637: case 50:
638: # line 305 "parsedag.y"
639: {this_edge->setlabel(DESC,newstring(yypvt[-0].s));} break;
640: case 51:
641: # line 307 "parsedag.y"
642: {this_edge->setlabel(STRING,newstring(yypvt[-0].s));} break;
643: case 52:
644: # line 309 "parsedag.y"
645: {this_edge->setpointsize(yypvt[-0].i);} break;
646: case 53:
647: # line 311 "parsedag.y"
648: {this_edge->setcolor(newstring(yypvt[-0].s));} break;
649: case 54:
650: # line 313 "parsedag.y"
651: {this_edge->setink(yypvt[-0].i);} break;
652: case 56:
653: # line 318 "parsedag.y"
654: {set_union(Options.source_nodes,yypvt[-1].p);teardown(yypvt[-1].p);} break;
655: case 57:
656: # line 320 "parsedag.y"
657: {set_union(Options.sink_nodes,yypvt[-1].p);teardown(yypvt[-1].p);} break;
658: case 58:
659: # line 322 "parsedag.y"
660: {set_union(newset(),yypvt[-1].p);teardown(yypvt[-1].p);} break;
661: case 61:
662: # line 330 "parsedag.y"
663: {
664: Options.nodesep = max(1,round(Resolution*atof(yypvt[-0].s)));
665: } break;
666: case 62:
667: # line 334 "parsedag.y"
668: {
669: Options.ranksep = max(MIN_RANK_SEP,round(Resolution*atof(yypvt[-1].s)));
670: Options.rankadjust = 2;
671: } break;
672: case 63:
673: # line 340 "parsedag.y"
674: {
675: Options.ranksep = max(MIN_RANK_SEP,round(Resolution*atof(yypvt[-1].s)));
676: Options.rankadjust = 1;
677: } break;
678: case 64:
679: # line 345 "parsedag.y"
680: {
681: Options.rankadjust = 1;
682: } break;
683: case 65:
684: # line 349 "parsedag.y"
685: {
686: Options.ranksep = max(MIN_RANK_SEP,round(Resolution*atof(yypvt[-0].s)));
687: } break;
688: case 66:
689: # line 355 "parsedag.y"
690: {yyval.i = solid_ink;} break;
691: case 67:
692: # line 357 "parsedag.y"
693: {yyval.i = dashed_ink;} break;
694: case 68:
695: # line 359 "parsedag.y"
696: {yyval.i = dotted_ink;} break;
697: case 69:
698: # line 361 "parsedag.y"
699: {yyval.i = invis_ink;} break;
700: case 70:
701: # line 365 "parsedag.y"
702: {yyval.i = node_lookup(yypvt[-0].s);} break;
703: case 71:
704: # line 369 "parsedag.y"
705: {yyval.i = atoi(yypvt[-0].s);} break;
706: }
707: goto yystack; /* stack new state and value */
708: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.