![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to y.tab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / twig|
Return to y.tab.c CVS log | Up to [Research Unix] / researchv10no / cmd / twig |
1.1 root 1: # define ERROR 257
2:
3: # line 3 "twig.y"
4: #include "common.h"
5: #include "code.h"
6: #include "sym.h"
7: #define UNDEFINED -1
8: #define GIVENUP -2
9:
10: int debug_flag = 0;
11: int Dflag = 0;
12: int tflag = 0;
13: int line_xref_flag = 0;
14: int ntrees = 0;
15: int nerrors = 0;
16: int fatalerrors = 0;
17: int tree_lineno;
18: FILE *outfile;
19: FILE *symfile;
20: Code *epilogue;
21:
22: SymbolEntry ErrorSymbol;
23:
24: # line 23 "twig.y"
25: typedef union {
26: Node *y_nodep;
27: SymbolEntry *y_symp;
28: Code *y_code;
29: int y_int;
30: } YYSTYPE;
31: # define K_NODE 258
32: # define K_LABEL 259
33: # define K_PROLOGUE 260
34: # define K_CONST 261
35: # define K_INSERT 262
36: # define K_COST 263
37: # define K_ACTION 264
38: # define ID 265
39: # define NUMBER 266
40: # define CBLOCK 267
41: #define yyclearin yychar = -1
42: #define yyerrok yyerrflag = 0
43: extern int yychar;
44: extern short yyerrflag;
45: #ifndef YYMAXDEPTH
46: #define YYMAXDEPTH 150
47: #endif
48: YYSTYPE yylval, yyval;
49: # define YYERRCODE 256
50:
51: # line 255 "twig.y"
52:
53:
54: extern char *process_suffix();
55:
56: set_arity(symp, arityp, count)
57: SymbolEntry *symp;
58: int *arityp;
59: int count;
60: {
61: if(*arityp!=GIVENUP) {
62: if (*arityp==UNDEFINED)
63: *arityp = count;
64: else if (*arityp!=count) {
65: sem_error("inconsistent arity for %s", symp->name);
66: *arityp = GIVENUP;
67: }
68: }
69: }
70:
71: is_node(symp)
72: SymbolEntry *symp;
73: { return(symp->attr==A_NODE); }
74:
75: is_label(symp)
76: SymbolEntry *symp;
77: { return(symp->attr==A_LABEL); }
78:
79: CheckIsNodeOrPred (symp)
80: SymbolEntry *symp;
81: {
82: if (symp->attr==A_ERROR)
83: return;
84: if (symp->attr!=A_NODE)
85: sem_error ("non-node identifier %s", symp->name);
86: }
87:
88: CheckIsUndefined(symp)
89: SymbolEntry *symp;
90: {
91: if (symp->attr==A_ERROR)
92: return(0);
93: if (symp->attr!=A_UNDEFINED) {
94: sem_error ("multiple declaration: %s", symp->name);
95: return(0);
96: } else return(1);
97: }
98:
99: CheckIsDefined(symp)
100: SymbolEntry *symp;
101: {
102: if (symp->attr==A_ERROR)
103: return(0);
104: if (symp->attr==A_UNDEFINED) {
105: sem_error ("undefined identifier: %s", symp->name);
106: symp->attr=A_ERROR;
107: return(0);
108: } else return(1);
109: }
110:
111:
112:
113: /*VARARGS*/
114: yyerror(fmt, s1, s2, s3)
115: char *fmt, *s1, *s2, *s3;
116: {
117: fprintf(stderr, "line %d: ", yyline);
118: fprintf(stderr, fmt, s1, s2, s3);
119: if (token_buffer[0]!=0)
120: fprintf(stderr, " at \"%s\"\n", token_buffer);
121: }
122:
123: /*VARARGS*/
124: yyerror2 (fmt, s1, s2, s3)
125: char *fmt, *s1, *s2, *s3;
126: {
127: fprintf(stderr, "line %d: ", yyline);
128: fprintf(stderr, fmt, s1, s2, s3);
129: putchar('\n');
130: }
131:
132: char *cmdnam;
133: char *inFileName;
134: char *outFileName;
135: char prefixFile[100];
136: static char usage[] = "usage: mt [-d] file";
137: #define USAGE error(1, usage)
138: char *prefix_base = PREFIX_BASE;
139: char *suffix = "c1";
140:
141: main(argc, argv)
142: int argc;
143: char **argv;
144: {
145: int i;
146: char *cp;
147:
148: #ifndef PREFIX_BASE
149: error(1,"PREFIX_BASE has not been defined; recompile twig");
150: #endif
151:
152: cmdnam = argv[0];
153: argv++;
154: inFileName = NULL;
155:
156: while(--argc > 0) {
157: if (*argv[0]=='-')
158: switch(argv[0][1]) {
159: /* to see what each of these flags mean...
160: * see common.h */
161: case 'd': {
162: char *cp;
163: for(cp = &argv[0][2]; *cp!='\0'; cp++)
164: switch(*cp) {
165: case 'l': debug_flag |= DB_LEX; break;
166: case 'm': debug_flag |= DB_MACH; break;
167: case 's': debug_flag |= DB_SYM; break;
168: case 't': debug_flag |= DB_TREE; break;
169: case 'M': debug_flag |= DB_MEM; break;
170: }
171: }
172: break;
173: case 'D': Dflag++; break;
174: case 't': tflag++; break;
175: case 'w': suffix = process_suffix(&argv[0][2]); break;
176: case 'l': prefix_base = &argv[0][2]; break;
177: case 'x': line_xref_flag++; break;
178: default:
179: USAGE;
180: }
181: else inFileName = argv[0];
182: argv++;
183: }
184: if(inFileName==NULL)
185: USAGE;
186:
187: if(freopen(inFileName, "r", stdin)==NULL)
188: error(1, "can't open %s", inFileName);
189: if((cp=strrchr(inFileName, '.'))!=NULL && strcmp(cp,".mt")==0) {
190: if ((outfile = fopen("walker.c" , "w"))==NULL)
191: error(1, "can't write %s", outFileName);
192: if ((symfile = fopen("symbols.h", "w"))==NULL)
193: error(1, "can't write %s", outFileName);
194: } else error(1, "input file must have suffix .mt");
195:
196: ErrorSymbol.attr = A_LABEL;
197: TreeInit();
198: SymbolInit();
199: LexInit();
200: yyparse();
201:
202: SymbolDump();
203: if(nerrors == 0) {
204: if(!tflag) {
205: FILE *prefix;
206: char c;
207: sprintf(prefixFile, "%s.%s", prefix_base, suffix);
208: prefix = fopen(prefixFile, "r");
209: assert(prefix!=NULL);
210: if(Dflag)
211: fputs("#define DEBUG 1\n", outfile);
212: if(line_xref_flag)
213: fputs("#define LINE_XREF 1\n", outfile);
214: fprintf(outfile,"# line 1 \"%s\"\n", prefixFile);
215: while((c=getc(prefix))!=EOF) putc(c, outfile);
216: }
217: MachineGen();
218: SymbolGenerateWalkerCode();
219: CodeWrite(outfile, epilogue);
220: CodeFreeBlock(epilogue);
221: }
222:
223: /* cleanup */
224: cleanup(0);
225: }
226:
227: cleanup(retcode)
228: int retcode;
229: {
230: lexCleanup();
231: if(retcode==0) {
232: SymbolFinish();
233: }
234: exit(retcode);
235: }
236:
237: /*VARARGS*/
238: error(rc, fmt, a1, a2, a3)
239: int rc;
240: char *fmt, *a1, *a2, *a3;
241: {
242: fprintf(stderr, "%s: ", cmdnam);
243: fprintf(stderr, fmt, a1, a2, a3);
244: putc ('\n', stderr);
245: if(rc)
246: exit (rc);
247: }
248:
249: /*VARARGS*/
250: sem_error (fmt, a1, a2, a3)
251: char *fmt, *a1, *a2, *a3;
252: {
253: fprintf (stderr, "line %d: ", yyline);
254: sem_error2(fmt, a1, a2, a3);
255: nerrors++;
256: fatalerrors++;
257: }
258:
259: /*VARARGS*/
260: sem_error2(fmt, a1, a2, a3)
261: char *fmt, *a1, *a2, *a3;
262: {
263: fprintf (stderr, fmt, a1, a2, a3);
264: putc('\n', stderr);
265: nerrors++;
266: }
267:
268: char *
269: process_suffix(suf)
270: char *suf;
271: {
272: extern int gen_table2;
273: if(strcmp(suf,"exper")==0) {
274: /* experimental walker */
275: /* expect this to change alot */
276: gen_table2++;
277: }
278: return(suf);
279: }
280: short yyexca[] ={
281: -1, 1,
282: 0, -1,
283: -2, 0,
284: -1, 10,
285: 0, 1,
286: -2, 0,
287: -1, 66,
288: 40, 49,
289: -2, 51,
290: };
291: # define YYNPROD 56
292: # define YYLAST 261
293: short yyact[]={
294:
295: 16, 71, 4, 6, 7, 5, 14, 8, 9, 17,
296: 4, 6, 7, 5, 37, 8, 9, 29, 89, 79,
297: 88, 78, 73, 72, 54, 36, 61, 59, 28, 50,
298: 44, 40, 16, 92, 33, 31, 66, 27, 14, 25,
299: 22, 17, 66, 32, 30, 93, 65, 70, 94, 85,
300: 69, 53, 87, 76, 75, 64, 63, 62, 60, 58,
301: 57, 39, 48, 38, 83, 82, 86, 49, 24, 21,
302: 12, 20, 13, 3, 80, 10, 11, 2, 77, 84,
303: 23, 35, 19, 34, 18, 15, 26, 90, 1, 45,
304: 41, 0, 51, 0, 0, 0, 0, 0, 0, 0,
305: 0, 74, 0, 0, 0, 0, 67, 0, 0, 0,
306: 68, 0, 0, 0, 0, 0, 0, 81, 0, 0,
307: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
308: 0, 0, 0, 91, 0, 0, 0, 0, 0, 0,
309: 0, 96, 0, 0, 0, 0, 0, 0, 0, 0,
310: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
311: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
312: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
313: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
314: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
315: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
316: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
317: 0, 56, 0, 0, 73, 72, 52, 46, 42, 0,
318: 55, 0, 0, 0, 0, 25, 47, 43, 0, 0,
319: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
320: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
321: 95 };
322: short yypact[]={
323:
324: -248,-1000,-256,-1000,-225,-226,-228,-239,-221,-222,
325: -224,-1000,-1000,-1000,-242, 5, 2,-1000, -28, -29,
326: -1000,-1000, 27, -30,-1000, -10, -35,-1000, 1, 0,
327: -240, -1,-241, -2,-1000,-1000, -3, -4,-229,-1000,
328: -1000,-1000,-1000, 27,-1000,-1000,-1000, 27, -11, -41,
329: -1000,-1000,-1000,-243,-1000,-1000,-1000,-1000,-1000, -5,
330: -1000, -6,-1000,-1000,-1000,-246,-1000,-1000, -11,-243,
331: 24, 23,-1000,-1000,-1000,-1000,-1000, -12,-1000,-1000,
332: 26,-1000,-1000,-1000, -7,-247,-223,-1000,-1000,-1000,
333: 4,-1000,-1000,-1000,-229,-1000,-1000 };
334: short yypgo[]={
335:
336: 0, 88, 46, 87, 86, 85, 84, 71, 82, 69,
337: 80, 68, 62, 47, 79, 78, 77, 75, 73, 72,
338: 70, 74 };
339: short yyr1[]={
340:
341: 0, 1, 16, 16, 18, 18, 18, 18, 18, 18,
342: 18, 18, 18, 18, 4, 4, 4, 8, 8, 8,
343: 6, 6, 6, 7, 9, 12, 12, 12, 10, 10,
344: 10, 11, 13, 13, 17, 17, 17, 17, 20, 20,
345: 19, 19, 14, 14, 14, 15, 15, 15, 5, 21,
346: 2, 2, 3, 3, 3, 3 };
347: short yyr2[]={
348:
349: 0, 2, 2, 1, 3, 3, 3, 3, 3, 4,
350: 4, 3, 3, 3, 2, 1, 2, 2, 1, 2,
351: 2, 1, 2, 2, 4, 3, 3, 0, 2, 1,
352: 2, 3, 1, 1, 2, 2, 1, 1, 3, 3,
353: 6, 2, 2, 2, 0, 1, 1, 0, 1, 0,
354: 5, 1, 3, 1, 1, 2 };
355: short yychk[]={
356:
357: -1000, -1, -16, -18, 258, 261, 259, 260, 263, 264,
358: -17, -18, -20, -19, 262, -5, 256, 265, -6, -8,
359: -7, -9, 265, -10, -11, 265, -4, 265, 267, 256,
360: 265, 256, 265, 256, -19, -20, 267, 256, 58, 59,
361: 59, -7, 256, 265, 59, -9, 256, 265, -12, 40,
362: 59, -11, 256, 61, 59, 265, 256, 59, 59, 267,
363: 59, 267, 59, 59, 59, -2, 265, -12, -12, 61,
364: -13, 42, 266, 265, -13, 59, 59, -15, 267, 265,
365: -21, -13, 41, 41, -14, 61, 40, 59, 267, 265,
366: -3, -2, 256, 41, 44, 256, -2 };
367: short yydef[]={
368:
369: 0, -2, 0, 3, 0, 0, 0, 0, 0, 0,
370: -2, 2, 36, 37, 0, 0, 0, 48, 0, 0,
371: 21, 18, 27, 0, 29, 0, 0, 15, 0, 0,
372: 0, 0, 0, 0, 34, 35, 0, 0, 0, 41,
373: 4, 20, 22, 27, 5, 17, 19, 27, 23, 0,
374: 6, 28, 30, 0, 7, 14, 16, 8, 11, 0,
375: 13, 0, 12, 38, 39, 47, -2, 23, 0, 0,
376: 0, 0, 32, 33, 31, 9, 10, 44, 45, 46,
377: 0, 24, 25, 26, 0, 0, 0, 40, 42, 43,
378: 0, 53, 54, 50, 0, 55, 52 };
379: # ifdef YYDEBUG
380: # include "y.debug"
381: # endif
382:
383: # define YYFLAG -1000
384: # define YYERROR goto yyerrlab
385: # define YYACCEPT return(0)
386: # define YYABORT return(1)
387:
388: /* parser for yacc output */
389:
390: #ifdef YYDEBUG
391: int yydebug = 0; /* 1 for debugging */
392: #endif
393: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
394: int yychar = -1; /* current input token number */
395: int yynerrs = 0; /* number of errors */
396: short yyerrflag = 0; /* error recovery flag */
397:
398: yyparse()
399: { short yys[YYMAXDEPTH];
400: int yyj, yym;
401: register YYSTYPE *yypvt;
402: register int yystate, yyn;
403: register short *yyps;
404: register YYSTYPE *yypv;
405: register short *yyxi;
406:
407: yystate = 0;
408: yychar = -1;
409: yynerrs = 0;
410: yyerrflag = 0;
411: yyps= &yys[-1];
412: yypv= &yyv[-1];
413:
414: yystack: /* put a state and value onto the stack */
415: #ifdef YYDEBUG
416: if(yydebug >= 3)
417: if(yychar < 0 || yytoknames[yychar] == 0)
418: printf("char %d in %s", yychar, yystates[yystate]);
419: else
420: printf("%s in %s", yytoknames[yychar], yystates[yystate]);
421: #endif
422: if( ++yyps >= &yys[YYMAXDEPTH] ) {
423: yyerror( "yacc stack overflow" );
424: return(1);
425: }
426: *yyps = yystate;
427: ++yypv;
428: *yypv = yyval;
429: yynewstate:
430: yyn = yypact[yystate];
431: if(yyn <= YYFLAG) goto yydefault; /* simple state */
432: if(yychar<0) {
433: yychar = yylex();
434: #ifdef YYDEBUG
435: if(yydebug >= 2) {
436: if(yychar <= 0)
437: printf("lex EOF\n");
438: else if(yytoknames[yychar])
439: printf("lex %s\n", yytoknames[yychar]);
440: else
441: printf("lex (%c)\n", yychar);
442: }
443: #endif
444: if(yychar < 0)
445: yychar = 0;
446: }
447: if((yyn += yychar) < 0 || yyn >= YYLAST)
448: goto yydefault;
449: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
450: yychar = -1;
451: yyval = yylval;
452: yystate = yyn;
453: if( yyerrflag > 0 ) --yyerrflag;
454: goto yystack;
455: }
456: yydefault:
457: /* default state action */
458: if( (yyn=yydef[yystate]) == -2 ) {
459: if(yychar < 0) {
460: yychar = yylex();
461: #ifdef YYDEBUG
462: if(yydebug >= 2)
463: if(yychar < 0)
464: printf("lex EOF\n");
465: else
466: printf("lex %s\n", yytoknames[yychar]);
467: #endif
468: if(yychar < 0)
469: yychar = 0;
470: }
471: /* look through exception table */
472: for(yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate);
473: yyxi += 2 ) ; /* VOID */
474: while( *(yyxi+=2) >= 0 ){
475: if( *yyxi == yychar ) break;
476: }
477: if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
478: }
479: if( yyn == 0 ){ /* error */
480: /* error ... attempt to resume parsing */
481: switch( yyerrflag ){
482: case 0: /* brand new error */
483: #ifdef YYDEBUG
484: yyerror("syntax error\n%s", yystates[yystate]);
485: if(yytoknames[yychar])
486: yyerror("saw %s\n", yytoknames[yychar]);
487: else if(yychar >= ' ' && yychar < '\177')
488: yyerror("saw `%c'\n", yychar);
489: else if(yychar == 0)
490: yyerror("saw EOF\n");
491: else
492: yyerror("saw char 0%o\n", yychar);
493: #else
494: yyerror( "syntax error" );
495: #endif
496: yyerrlab:
497: ++yynerrs;
498: case 1:
499: case 2: /* incompletely recovered error ... try again */
500: yyerrflag = 3;
501: /* find a state where "error" is a legal shift action */
502: while ( yyps >= yys ) {
503: yyn = yypact[*yyps] + YYERRCODE;
504: if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
505: yystate = yyact[yyn]; /* simulate a shift of "error" */
506: goto yystack;
507: }
508: yyn = yypact[*yyps];
509: /* the current yyps has no shift onn "error", pop stack */
510: #ifdef YYDEBUG
511: if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
512: #endif
513: --yyps;
514: --yypv;
515: }
516: /* there is no state on the stack with an error shift ... abort */
517: yyabort:
518: return(1);
519: case 3: /* no shift yet; clobber input char */
520: #ifdef YYDEBUG
521: if( yydebug ) {
522: printf("error recovery discards ");
523: if(yytoknames[yychar])
524: printf("%s\n", yytoknames[yychar]);
525: else if(yychar >= ' ' && yychar < '\177')
526: printf("`%c'\n", yychar);
527: else if(yychar == 0)
528: printf("EOF\n");
529: else
530: printf("char 0%o\n", yychar);
531: }
532: #endif
533: if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
534: yychar = -1;
535: goto yynewstate; /* try again in the same state */
536: }
537: }
538: /* reduction by production yyn */
539: #ifdef YYDEBUG
540: if(yydebug) { char *s;
541: printf("reduce %d in:\n\t", yyn);
542: for(s = yystates[yystate]; *s; s++) {
543: putchar(*s);
544: if(*s == '\n' && *(s+1))
545: putchar('\t');
546: }
547: }
548: #endif
549: yyps -= yyr2[yyn];
550: yypvt = yypv;
551: yypv -= yyr2[yyn];
552: yyval = yypv[1];
553: yym=yyn;
554: /* consult goto table to find next state */
555: yyn = yyr1[yyn];
556: yyj = yypgo[yyn] + *yyps + 1;
557: if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
558: switch(yym){
559:
560: case 1:
561: # line 42 "twig.y"
562:
563: { if (nerrors==0) machine_build(); } break;
564: case 4:
565: # line 48 "twig.y"
566: { SymbolEnterList (yypvt[-1].y_symp, A_NODE); } break;
567: case 5:
568: # line 51 "twig.y"
569: {
570: SymbolEnterList(yypvt[-1].y_symp, A_NODE);
571: SymbolCheckNodeValues();
572: } break;
573: case 6:
574: # line 56 "twig.y"
575: { SymbolEnterList (yypvt[-1].y_symp, A_CONST); } break;
576: case 7:
577: # line 58 "twig.y"
578: { SymbolEnterList (yypvt[-1].y_symp, A_LABEL); } break;
579: case 8:
580: # line 60 "twig.y"
581: { CodeWrite(outfile, yypvt[-1].y_code); CodeFreeBlock(yypvt[-1].y_code); } break;
582: case 9:
583: # line 63 "twig.y"
584: { yypvt[-2].y_symp->sd.ca.code = yypvt[-1].y_code; yypvt[-2].y_symp->sd.ca.assoc = NULL;
585: SymbolEnter (yypvt[-2].y_symp, A_COST); } break;
586: case 10:
587: # line 67 "twig.y"
588: { yypvt[-2].y_symp->sd.ca.code = yypvt[-1].y_code; yypvt[-2].y_symp->sd.ca.assoc = NULL;
589: SymbolEnter (yypvt[-2].y_symp, A_ACTION); } break;
590: case 14:
591: # line 83 "twig.y"
592: {
593: if(CheckIsUndefined(yypvt[-0].y_symp)) {
594: yypvt[-0].y_symp->next = yypvt[-1].y_symp;
595: yyval.y_symp = yypvt[-0].y_symp;
596: } else yyval.y_symp = yypvt[-1].y_symp;
597: } break;
598: case 15:
599: # line 89 "twig.y"
600: { if(CheckIsUndefined(yypvt[-0].y_symp)) yyval.y_symp = yypvt[-0].y_symp; else yyval.y_symp = NULL; } break;
601: case 17:
602: # line 97 "twig.y"
603: {
604: if(yypvt[-0].y_symp->attr==A_ERROR)
605: yyval.y_symp = yypvt[-1].y_symp;
606: else { yypvt[-0].y_symp->next = yypvt[-1].y_symp; yyval.y_symp = yypvt[-0].y_symp; }
607: } break;
608: case 18:
609: # line 102 "twig.y"
610: { yyval.y_symp = yypvt[-0].y_symp->attr==A_ERROR ? NULL : yypvt[-0].y_symp; } break;
611: case 20:
612: # line 106 "twig.y"
613: {
614: if(yypvt[-0].y_symp->attr==A_ERROR) yyval.y_symp = yypvt[-1].y_symp;
615: else { yypvt[-0].y_symp->next = yypvt[-1].y_symp; yyval.y_symp = yypvt[-0].y_symp; }
616: } break;
617: case 21:
618: # line 110 "twig.y"
619: { yyval.y_symp = yypvt[-0].y_symp->attr==A_ERROR ? NULL : yypvt[-0].y_symp; } break;
620: case 23:
621: # line 114 "twig.y"
622: {
623: if (CheckIsUndefined(yypvt[-1].y_symp)) {
624: yypvt[-1].y_symp->sd.arity = yypvt[-0].y_int; yyval.y_symp = yypvt[-1].y_symp;
625: } else yyval.y_symp = &ErrorSymbol;
626: } break;
627: case 24:
628: # line 121 "twig.y"
629: {
630: if(CheckIsUndefined(yypvt[-3].y_symp)) {
631: yypvt[-3].y_symp->unique = yypvt[-0].y_int; yypvt[-3].y_symp->sd.arity = yypvt[-2].y_int;
632: yyval.y_symp = yypvt[-3].y_symp;
633: } else yyval.y_symp = &ErrorSymbol;
634: } break;
635: case 25:
636: # line 129 "twig.y"
637: { yyval.y_int = yypvt[-1].y_int; } break;
638: case 26:
639: # line 130 "twig.y"
640: { yyval.y_int=GIVENUP; } break;
641: case 27:
642: # line 131 "twig.y"
643: { yyval.y_int = UNDEFINED; } break;
644: case 28:
645: # line 134 "twig.y"
646: {
647: if (yypvt[-0].y_symp->attr==A_ERROR) yyval.y_symp = yypvt[-1].y_symp;
648: else { yypvt[-0].y_symp->next = yypvt[-1].y_symp; yyval.y_symp = yypvt[-0].y_symp; }
649: } break;
650: case 29:
651: # line 138 "twig.y"
652: { yyval.y_symp = yypvt[-0].y_symp->attr==A_ERROR ? NULL : yypvt[-0].y_symp; } break;
653: case 31:
654: # line 142 "twig.y"
655: {
656: if(CheckIsUndefined(yypvt[-2].y_symp)) {
657: yypvt[-2].y_symp->sd.cvalue = yypvt[-0].y_int; yyval.y_symp = yypvt[-2].y_symp;
658: } else yyval.y_symp = &ErrorSymbol;
659: } break;
660: case 33:
661: # line 150 "twig.y"
662: {
663: if(!CheckIsDefined(yypvt[-0].y_symp)) yyval.y_int = UNDEFINED;
664: else if(yypvt[-0].y_symp->attr!=A_CONST) {
665: sem_error("non-constant id used");
666: yyval.y_int = -1;
667: } else yyval.y_int = yypvt[-0].y_symp->sd.cvalue;
668: } break;
669: case 38:
670: # line 164 "twig.y"
671: { epilogue = CodeAppend(epilogue, yypvt[-1].y_code); } break;
672: case 40:
673: # line 169 "twig.y"
674: {
675: if (yypvt[-5].y_symp->attr==A_ERROR) {
676: error(0, "\"label: tree\" pair ignored");
677: TreeFree(yypvt[-3].y_nodep);
678: } else {
679: if(nerrors==0)
680: cgotofn(SymbolEnterTreeIntoLabel(yypvt[-5].y_symp,
681: yypvt[-3].y_nodep, yypvt[-2].y_symp, yypvt[-1].y_symp, tree_lineno));
682: if(debug_flag&DB_TREE)
683: TreePrint(yypvt[-3].y_nodep, 1);
684: }
685: } break;
686: case 42:
687: # line 183 "twig.y"
688: { SymbolEntry *sp = SymbolAllocate (SymbolGenUnique());
689: sp->sd.ca.code = yypvt[-0].y_code; sp->sd.ca.assoc = NULL;
690: SymbolEnter(sp, A_ACTION); yyval.y_symp = sp; } break;
691: case 43:
692: # line 186 "twig.y"
693: { if(CheckIsDefined(yypvt[-0].y_symp)) {
694: if (yypvt[-0].y_symp->attr!=A_ACTION) {
695: sem_error ("non action id: %s", yypvt[-0].y_symp->name);
696: yyval.y_symp = &ErrorSymbol;
697: } else yyval.y_symp = yypvt[-0].y_symp;
698: } else yyval.y_symp = &ErrorSymbol; } break;
699: case 44:
700: # line 192 "twig.y"
701: { yyval.y_symp = NULL;} break;
702: case 45:
703: # line 194 "twig.y"
704: { SymbolEntry *sp = SymbolAllocate (SymbolGenUnique());
705: sp->sd.ca.code = yypvt[-0].y_code; sp->sd.ca.assoc = NULL;
706: SymbolEnter (sp, A_COST); yyval.y_symp = sp;
707: } break;
708: case 46:
709: # line 198 "twig.y"
710: { if (CheckIsDefined(yypvt[-0].y_symp)) {
711: if (yypvt[-0].y_symp->attr!=A_COST) {
712: sem_error ("non cost id: %s", yypvt[-0].y_symp->name);
713: yyval.y_symp = &ErrorSymbol;
714: } else yyval.y_symp = yypvt[-0].y_symp;
715: } else yyval.y_symp = &ErrorSymbol; } break;
716: case 47:
717: # line 204 "twig.y"
718: { yyval.y_symp = NULL; } break;
719: case 48:
720: # line 207 "twig.y"
721: {
722: tree_lineno = yyline; /* record line no */
723: if(!CheckIsDefined(yypvt[-0].y_symp))
724: yypvt[-0].y_symp->attr = A_ERROR;
725: else if(!is_label(yypvt[-0].y_symp)) {
726: sem_error("non label id: %s", yypvt[-0].y_symp->name);
727: yypvt[-0].y_symp->attr = A_ERROR;
728: }
729: yyval.y_symp = yypvt[-0].y_symp;
730: } break;
731: case 49:
732: # line 218 "twig.y"
733: {CheckIsNodeOrPred(yypvt[-0].y_symp);} break;
734: case 50:
735: # line 219 "twig.y"
736: {
737: int count;
738: Node *ap;
739: /* check the arity of the node */
740: for(count=0, ap = yypvt[-1].y_nodep; ap!=NULL; ap=ap->siblings) count++;
741: switch(yypvt[-4].y_symp->attr) {
742: case A_NODE:
743: set_arity(yypvt[-4].y_symp, &yypvt[-4].y_symp->sd.arity, count);
744: break;
745: }
746:
747: yyval.y_nodep = TreeBuild (yypvt[-4].y_symp, yypvt[-1].y_nodep);
748: } break;
749: case 51:
750: # line 233 "twig.y"
751: {
752: CheckIsDefined(yypvt[-0].y_symp);
753: switch (yypvt[-0].y_symp->attr) {
754: case A_NODE:
755: set_arity(yypvt[-0].y_symp, &yypvt[-0].y_symp->sd.arity, 0);
756: break;
757: }
758: yyval.y_nodep = TreeBuild (yypvt[-0].y_symp, NULL);
759: } break;
760: case 52:
761: # line 243 "twig.y"
762: {
763: /*
764: * build sibling list in reverse order TreeBuild will
765: * put it right later.
766: */
767: yypvt[-0].y_nodep->siblings = yypvt[-2].y_nodep;
768: yyval.y_nodep = yypvt[-0].y_nodep;
769: } break;
770: case 53:
771: # line 251 "twig.y"
772: { yypvt[-0].y_nodep->siblings = NULL; yyval.y_nodep = yypvt[-0].y_nodep; } break;
773: case 54:
774: # line 252 "twig.y"
775: { yyval.y_nodep = NULL; } break;
776: }
777: goto yystack; /* stack new state and value */
778: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.