1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
4
5 #define YYBYACC 1
6 #define YYMAJOR 1
7 #define YYMINOR 9
8 #define YYCHECK "yyyymmdd"
9
10 #define YYEMPTY (-1)
11 #define yyclearin (yychar = YYEMPTY)
12 #define yyerrok (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
14 #define YYENOMEM (-2)
15 #define YYEOF 0
16
17 #ifndef yyparse
18 #define yyparse expr.oxout_parse
19 #endif /* yyparse */
20
21 #ifndef yylex
22 #define yylex expr.oxout_lex
23 #endif /* yylex */
24
25 #ifndef yyerror
26 #define yyerror expr.oxout_error
27 #endif /* yyerror */
28
29 #ifndef yychar
30 #define yychar expr.oxout_char
31 #endif /* yychar */
32
33 #ifndef yyval
34 #define yyval expr.oxout_val
35 #endif /* yyval */
36
37 #ifndef yylval
38 #define yylval expr.oxout_lval
39 #endif /* yylval */
40
41 #ifndef yydebug
42 #define yydebug expr.oxout_debug
43 #endif /* yydebug */
44
45 #ifndef yynerrs
46 #define yynerrs expr.oxout_nerrs
47 #endif /* yynerrs */
48
49 #ifndef yyerrflag
50 #define yyerrflag expr.oxout_errflag
51 #endif /* yyerrflag */
52
53 #ifndef yylhs
54 #define yylhs expr.oxout_lhs
55 #endif /* yylhs */
56
57 #ifndef yylen
58 #define yylen expr.oxout_len
59 #endif /* yylen */
60
61 #ifndef yydefred
62 #define yydefred expr.oxout_defred
63 #endif /* yydefred */
64
65 #ifndef yydgoto
66 #define yydgoto expr.oxout_dgoto
67 #endif /* yydgoto */
68
69 #ifndef yysindex
70 #define yysindex expr.oxout_sindex
71 #endif /* yysindex */
72
73 #ifndef yyrindex
74 #define yyrindex expr.oxout_rindex
75 #endif /* yyrindex */
76
77 #ifndef yygindex
78 #define yygindex expr.oxout_gindex
79 #endif /* yygindex */
80
81 #ifndef yytable
82 #define yytable expr.oxout_table
83 #endif /* yytable */
84
85 #ifndef yycheck
86 #define yycheck expr.oxout_check
87 #endif /* yycheck */
88
89 #ifndef yyname
90 #define yyname expr.oxout_name
91 #endif /* yyname */
92
93 #ifndef yyrule
94 #define yyrule expr.oxout_rule
95 #endif /* yyrule */
96 #define YYPREFIX "expr.oxout_"
97
98 #define YYPURE 0
99
100 #line 5 "expr.oxout.y"
101 #include <stdlib.h>
102 #include <string.h>
103 #line 8 "expr.Y"
104
105 #include "expr.oxout.h"
106 #include <stdio.h>
107
108 extern int yylex(void);
109 extern void yyerror(const char *);
110 #line 27 "expr.oxout.y"
111 #include <limits.h>
112 #define yyyR USHRT_MAX
113 #ifdef YYSTYPE
114 #undef YYSTYPE_IS_DECLARED
115 #define YYSTYPE_IS_DECLARED 1
116 #endif
117 #ifndef YYSTYPE_IS_DECLARED
118 #define YYSTYPE_IS_DECLARED 1
119 #line 31 "expr.oxout.y"
120 typedef union {
121 struct yyyOxAttrbs {
122 struct yyyStackItem *yyyOxStackItem;
123 } yyyOxAttrbs;
124 } YYSTYPE;
125 #endif /* !YYSTYPE_IS_DECLARED */
126 #line 38 "expr.oxout.y"
127 #include <stdio.h>
128 #include <stdarg.h>
129
130 static int yyyYok = 1;
131
132 extern yyyFT yyyRCIL[];
133
134 void yyyExecuteRRsection(yyyGNT *rootNode);
135 void yyyYoxInit(void);
136 void yyyDecorate(void);
137 struct yyyOxAttrbs; /* hack required to compensate for 'msta' behavior */
138 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...);
139 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...);
140 void yyyCheckUnsolvedInstTrav(yyyGNT *rootNode,long *nNZrc,long *cycleSum);
141 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode);
142 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode);
143 void yyyabort(void);
144
145 #line 146 "expr.oxout.tab.c"
146
147 /* compatibility with bison */
148 #ifdef YYPARSE_PARAM
149 /* compatibility with FreeBSD */
150 # ifdef YYPARSE_PARAM_TYPE
151 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
152 # else
153 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
154 # endif
155 #else
156 # define YYPARSE_DECL() yyparse(void)
157 #endif
158
159 /* Parameters sent to lex. */
160 #ifdef YYLEX_PARAM
161 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
162 # define YYLEX yylex(YYLEX_PARAM)
163 #else
164 # define YYLEX_DECL() yylex(void)
165 # define YYLEX yylex()
166 #endif
167
168 /* Parameters sent to yyerror. */
169 #ifndef YYERROR_DECL
170 #define YYERROR_DECL() yyerror(const char *s)
171 #endif
172 #ifndef YYERROR_CALL
173 #define YYERROR_CALL(msg) yyerror(msg)
174 #endif
175
176 extern int YYPARSE_DECL();
177
178 #define ID 257
179 #define CONST 258
180 #define YYERRCODE 256
181 typedef int YYINT;
182 static const YYINT expr.oxout_lhs[] = { -1,
183 2, 0, 1, 3, 3, 3, 3, 3, 3, 3,
184 };
185 static const YYINT expr.oxout_len[] = { 2,
186 0, 2, 1, 3, 3, 3, 3, 3, 1, 1,
187 };
188 static const YYINT expr.oxout_defred[] = { 1,
189 0, 0, 9, 10, 0, 2, 0, 0, 0, 0,
190 0, 0, 8, 0, 0, 4, 0,
191 };
192 static const YYINT expr.oxout_dgoto[] = { 1,
193 6, 2, 7,
194 };
195 static const YYINT expr.oxout_sindex[] = { 0,
196 0, -40, 0, 0, -40, 0, -18, -24, -40, -40,
197 -40, -40, 0, -37, -37, 0, -39,
198 };
199 static const YYINT expr.oxout_rindex[] = { 0,
200 0, 0, 0, 0, 0, 0, 6, 0, 0, 0,
201 0, 0, 0, 2, 8, 0, 1,
202 };
203 static const YYINT expr.oxout_gindex[] = { 0,
204 0, 0, 4,
205 };
206 #define YYTABLESIZE 218
207 static const YYINT expr.oxout_table[] = { 5,
208 6, 5, 11, 0, 11, 3, 0, 7, 8, 12,
209 0, 0, 14, 15, 16, 17, 13, 11, 9, 0,
210 10, 0, 12, 11, 9, 0, 10, 0, 12, 0,
211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
212 0, 6, 5, 6, 5, 6, 5, 6, 7, 0,
213 7, 0, 7, 0, 0, 0, 0, 0, 0, 0,
214 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
216 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
217 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
218 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
221 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
222 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
223 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
225 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
226 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
227 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
228 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
229 0, 0, 0, 0, 0, 0, 3, 4,
230 };
231 static const YYINT expr.oxout_check[] = { 40,
232 0, 0, 42, -1, 42, 0, -1, 0, 5, 47,
233 -1, -1, 9, 10, 11, 12, 41, 42, 43, -1,
234 45, -1, 47, 42, 43, -1, 45, -1, 47, -1,
235 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
236 -1, 41, 41, 43, 43, 45, 45, 47, 41, -1,
237 43, -1, 45, -1, -1, -1, -1, -1, -1, -1,
238 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
239 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
240 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
241 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
242 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
243 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
244 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
245 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
246 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
247 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
248 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
249 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
250 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
251 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
252 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
253 -1, -1, -1, -1, -1, -1, 257, 258,
254 };
255 #define YYFINAL 1
256 #ifndef YYDEBUG
257 #define YYDEBUG 0
258 #endif
259 #define YYMAXTOKEN 258
260 #define YYUNDFTOKEN 264
261 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
262 #if YYDEBUG
263 static const char *const expr.oxout_name[] = {
264
265 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
266 0,0,0,0,0,0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,
267 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
268 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
269 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
270 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
271 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"ID",
272 "CONST",0,0,0,0,0,"illegal-symbol",
273 };
274 static const char *const expr.oxout_rule[] = {
275 "$accept : yyyAugNonterm",
276 "$$1 :",
277 "yyyAugNonterm : $$1 s",
278 "s : expr",
279 "expr : expr '*' expr",
280 "expr : expr '+' expr",
281 "expr : expr '/' expr",
282 "expr : expr '-' expr",
283 "expr : '(' expr ')'",
284 "expr : ID",
285 "expr : CONST",
286
287 };
288 #endif
289
290 int yydebug;
291 int yynerrs;
292
293 int yyerrflag;
294 int yychar;
295 YYSTYPE yyval;
296 YYSTYPE yylval;
297
298 /* define the initial stack-sizes */
299 #ifdef YYSTACKSIZE
300 #undef YYMAXDEPTH
301 #define YYMAXDEPTH YYSTACKSIZE
302 #else
303 #ifdef YYMAXDEPTH
304 #define YYSTACKSIZE YYMAXDEPTH
305 #else
306 #define YYSTACKSIZE 10000
307 #define YYMAXDEPTH 10000
308 #endif
309 #endif
310
311 #define YYINITSTACKSIZE 200
312
313 typedef struct {
314 unsigned stacksize;
315 YYINT *s_base;
316 YYINT *s_mark;
317 YYINT *s_last;
318 YYSTYPE *l_base;
319 YYSTYPE *l_mark;
320 } YYSTACKDATA;
321 /* variables for the parser stack */
322 static YYSTACKDATA yystack;
323 #line 53 "expr.Y"
324
325
326 int yyparse(void);
327
main()328 int main()
329 {yyparse();
330 }
331
332
333
334 #line 138 "expr.oxout.y"
335 long yyySSALspaceSize = 20000;
336 long yyyRSmaxSize = 1000;
337 long yyyTravStackMaxSize = 2000;
338
339 struct yyySolvedSAlistCell {yyyWAT attrbNum;
340 long next;
341 };
342
343 #define yyyLambdaSSAL 0
344 long yyySSALCfreeList = yyyLambdaSSAL;
345 long yyyNewSSALC = 1;
346
347 struct yyySolvedSAlistCell *yyySSALspace;
348
349 long yyyNbytesStackStg;
350
351
352
353 yyyFT yyyRCIL[1];
354
355 short yyyIIIEL[] = {0,
356 0,2,6,10,14,18,22,24,
357 };
358
359 long yyyIIEL[] = {
360 0,0,0,0,0,0,0,0,0,0,0,0,
361 0,0,0,0,0,0,0,0,0,0,0,0,
362 1,1,
363 };
364
365 long yyyIEL[] = {
366 0,0,0,
367 };
368
369 yyyFT yyyEntL[1];
370
yyyfatal(char * msg)371 void yyyfatal(char *msg)
372 {fputs(msg,stderr);exit(-1);}
373
374
375
376 #define yyySSALof 'S'
377 #define yyyRSof 'q'
378 #define yyyTSof 't'
379
380
381
yyyHandleOverflow(char which)382 void yyyHandleOverflow(char which)
383 {char *msg1,*msg2;
384 long oldSize,newSize;
385 switch(which)
386 {
387 case yyySSALof :
388 msg1 = "SSAL overflow: ";
389 oldSize = yyySSALspaceSize;
390 break;
391 case yyyRSof :
392 msg1 = "ready set overflow: ";
393 oldSize = yyyRSmaxSize;
394 break;
395 case yyyTSof :
396 msg1 = "traversal stack overflow: ";
397 oldSize = yyyTravStackMaxSize;
398 break;
399 default :;
400 }
401 newSize = (3*oldSize)/2;
402 if (newSize < 100) newSize = 100;
403 fputs(msg1,stderr);
404 fprintf(stderr,"size was %ld.\n",oldSize);
405 msg2 = " Have to modify evaluator: -Y%c%ld.\n";
406 fprintf(stderr,msg2,which,newSize);
407 exit(-1);
408 }
409
410
411
yyySignalEnts(yyyGNT * node,long startP,long stopP)412 void yyySignalEnts(yyyGNT *node,long startP,long stopP)
413 {yyyGNT *dumNode;
414
415 while (startP < stopP)
416 {
417 if (!yyyEntL[startP]) dumNode = node;
418 else dumNode = (node->cL)[yyyEntL[startP]-1];
419 if (!(--((dumNode->refCountList)[yyyEntL[startP+1]]
420 )
421 )
422 )
423 {
424 if (++yyyRSTop == yyyAfterRS)
425 {yyyHandleOverflow(yyyRSof);
426 break;
427 }
428 yyyRSTop->node = dumNode;
429 yyyRSTop->whichSym = yyyEntL[startP];
430 yyyRSTop->wa = yyyEntL[startP+1];
431 }
432 startP += 2;
433 }
434 }
435
436
437
438
439
440
yyySolveAndSignal()441 void yyySolveAndSignal() {
442 long yyyiDum,*yyypL;
443 int yyyws,yyywa;
444 yyyGNT *yyyRSTopN,*yyyRefN;
445 yyyParent yyyRSTopNp;
446
447
448 yyyRSTopNp = (yyyRSTopN = yyyRSTop->node)->parent;
449 yyyRefN= (yyyws = (yyyRSTop->whichSym))?yyyRSTopNp.noderef:yyyRSTopN;
450 yyywa = yyyRSTop->wa;
451 yyyRSTop--;
452 switch(yyyRefN->prodNum) {
453 case 1: /***yacc rule 1***/
454 switch (yyyws) {
455 }
456 break;
457 case 2: /***yacc rule 2***/
458 switch (yyyws) {
459 }
460 break;
461 case 3: /***yacc rule 3***/
462 switch (yyyws) {
463 }
464 break;
465 case 4: /***yacc rule 4***/
466 switch (yyyws) {
467 }
468 break;
469 case 5: /***yacc rule 5***/
470 switch (yyyws) {
471 }
472 break;
473 case 6: /***yacc rule 6***/
474 switch (yyyws) {
475 }
476 break;
477 case 7: /***yacc rule 7***/
478 switch (yyyws) {
479 case 1: /**/
480 switch (yyywa) {
481 }
482 break;
483 }
484 break;
485 case 8: /***yacc rule 8***/
486 switch (yyyws) {
487 case 1: /**/
488 switch (yyywa) {
489 }
490 break;
491 }
492 break;
493 } /* switch */
494
495 if (yyyws) /* the just-solved instance was inherited. */
496 {if (yyyRSTopN->prodNum)
497 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopN->prodNum]] + yyywa;
498 yyySignalEnts(yyyRSTopN,yyyIEL[yyyiDum],
499 yyyIEL[yyyiDum+1]
500 );
501 }
502 }
503 else /* the just-solved instance was synthesized. */
504 {if (!(yyyRSTopN->parentIsStack)) /* node has a parent. */
505 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopNp.noderef->prodNum] +
506 yyyRSTopN->whichSym
507 ] +
508 yyywa;
509 yyySignalEnts(yyyRSTopNp.noderef,
510 yyyIEL[yyyiDum],
511 yyyIEL[yyyiDum+1]
512 );
513 }
514 else /* node is still on the stack--it has no parent yet. */
515 {yyypL = &(yyyRSTopNp.stackref->solvedSAlist);
516 if (yyySSALCfreeList == yyyLambdaSSAL)
517 {yyySSALspace[yyyNewSSALC].next = *yyypL;
518 if ((*yyypL = yyyNewSSALC++) == yyySSALspaceSize)
519 yyyHandleOverflow(yyySSALof);
520 }
521 else
522 {yyyiDum = yyySSALCfreeList;
523 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
524 yyySSALspace[yyyiDum].next = *yyypL;
525 *yyypL = yyyiDum;
526 }
527 yyySSALspace[*yyypL].attrbNum = yyywa;
528 }
529 }
530
531 } /* yyySolveAndSignal */
532
533
534
535
536
537
538 #define condStg unsigned int conds;
539 #define yyyClearConds {yyyTST->conds = 0;}
540 #define yyySetCond(n) {yyyTST->conds += (1<<(n));}
541 #define yyyCond(n) ((yyyTST->conds & (1<<(n)))?1:0)
542
543
544
545 struct yyyTravStackItem {yyyGNT *node;
546 char isReady;
547 condStg
548 };
549
550
551
yyyDoTraversals(yyyGNT * rootNode)552 void yyyDoTraversals(yyyGNT *rootNode)
553 {struct yyyTravStackItem *yyyTravStack,*yyyTST,*yyyAfterTravStack;
554 yyyGNT *yyyTSTn,**yyyCLptr2;
555 int yyyi,yyyRL,yyyPass;
556 int i;
557
558 if (!yyyYok) return;
559 if ((yyyTravStack =
560 ((struct yyyTravStackItem *)
561 calloc((size_t)yyyTravStackMaxSize,
562 (size_t)sizeof(struct yyyTravStackItem)
563 )
564 )
565 )
566 ==
567 (struct yyyTravStackItem *)NULL
568 )
569 {fputs("malloc error in traversal stack allocation\n",stderr);
570 exit(-1);
571 }
572
573 yyyAfterTravStack = yyyTravStack + yyyTravStackMaxSize;
574 yyyTravStack++;
575
576
577 for (yyyi=0; yyyi<2; yyyi++) {
578 yyyTST = yyyTravStack;
579 yyyTST->node = rootNode;
580 yyyTST->isReady = 0;
581 yyyClearConds
582
583 while(yyyTST >= yyyTravStack)
584 {yyyTSTn = yyyTST->node;
585 if (yyyTST->isReady)
586 {yyyPass = 1;
587 goto yyyTravSwitch;
588 yyyTpop:
589 yyyTST--;
590 }
591 else
592 {yyyPass = 0;
593 goto yyyTravSwitch;
594 yyyTpush:
595 yyyTST->isReady = 1;
596 if (yyyTSTn->prodNum)
597 {if (yyyRL)
598 {yyyCLptr2 = yyyTSTn->cL;
599 i = yyyTSTn->cLlen;
600 while (i--)
601 {if (++yyyTST == yyyAfterTravStack)
602 yyyHandleOverflow(yyyTSof);
603 else
604 {yyyTST->node = *yyyCLptr2;
605 yyyTST->isReady = 0;
606 yyyClearConds
607 }
608 yyyCLptr2++;
609 }
610 } /* right to left */
611 else /* left to right */
612 {i = yyyTSTn->cLlen;
613 yyyCLptr2 = yyyTSTn->cL + i;
614 while (i--)
615 {yyyCLptr2--;
616 if (++yyyTST == yyyAfterTravStack)
617 yyyHandleOverflow(yyyTSof);
618 else
619 {yyyTST->node = *yyyCLptr2;
620 yyyTST->isReady = 0;
621 yyyClearConds
622 }
623 }
624 } /* left to right */
625 }
626 } /* else */
627 continue;
628 yyyTravSwitch:
629 switch(yyyTSTn->prodNum) {
630 case 1:
631 switch(yyyi) {
632 case 0:
633 switch(yyyPass) {
634 case 0:
635 yyyRL = 0;yyySetCond(0)
636
637 if (!
638 #line 24 "expr.Y"
639 (1)
640 #line 444 "expr.oxout.y"
641 ) yyySetCond(1)
642 yyySetCond(2)
643
644 case 1:
645
646 if (yyyCond(0) != yyyPass) {
647 #line 24 "expr.Y"
648
649 #line 453 "expr.oxout.y"
650 }
651 if (yyyCond(1) != yyyPass) {
652 #line 24 "expr.Y"
653 printf("\n");
654
655 #line 459 "expr.oxout.y"
656 }
657 if (yyyCond(2) != yyyPass) {
658 #line 25 "expr.Y"
659 printf("prefix: ");
660
661 #line 465 "expr.oxout.y"
662 }
663 break;
664 }
665 break;
666 case 1:
667 switch(yyyPass) {
668 case 0:
669 yyyRL = 0;
670 if (
671 #line 23 "expr.Y"
672 (1)
673 #line 477 "expr.oxout.y"
674 ) yyySetCond(2)
675
676 case 1:
677
678 if (yyyCond(0) != yyyPass) {
679 #line 22 "expr.Y"
680 printf("\n");
681
682 #line 486 "expr.oxout.y"
683 }
684 if (yyyCond(1) != yyyPass) {
685 #line 23 "expr.Y"
686
687 #line 491 "expr.oxout.y"
688 }
689 if (yyyCond(2) != yyyPass) {
690 #line 23 "expr.Y"
691 printf("postfix: ")/* missing ; */
692
693 #line 497 "expr.oxout.y"
694 }
695 break;
696 }
697 break;
698 }
699
700 break;
701 case 2:
702 switch(yyyi) {
703 case 0:
704 switch(yyyPass) {
705 case 0:
706 yyyRL = 0;yyySetCond(0)
707
708 case 1:
709
710 if (yyyCond(0) != yyyPass) {
711 #line 29 "expr.Y"
712 printf(" * ");
713
714 #line 518 "expr.oxout.y"
715 }
716 break;
717 }
718 break;
719 case 1:
720 switch(yyyPass) {
721 case 0:
722 yyyRL = 0;
723 case 1:
724
725 if (yyyCond(0) != yyyPass) {
726 #line 28 "expr.Y"
727 printf(" * ");
728
729 #line 533 "expr.oxout.y"
730 }
731 break;
732 }
733 break;
734 }
735
736 break;
737 case 3:
738 switch(yyyi) {
739 case 0:
740 switch(yyyPass) {
741 case 0:
742 yyyRL = 0;yyySetCond(0)
743
744 case 1:
745
746 if (yyyCond(0) != yyyPass) {
747 #line 32 "expr.Y"
748 printf(" + ");
749
750 #line 554 "expr.oxout.y"
751 }
752 break;
753 }
754 break;
755 case 1:
756 switch(yyyPass) {
757 case 0:
758 yyyRL = 0;
759 case 1:
760
761 if (yyyCond(0) != yyyPass) {
762 #line 33 "expr.Y"
763 printf(" + ");
764
765 #line 569 "expr.oxout.y"
766 }
767 break;
768 }
769 break;
770 }
771
772 break;
773 case 4:
774 switch(yyyi) {
775 case 0:
776 switch(yyyPass) {
777 case 0:
778 yyyRL = 0;yyySetCond(0)
779
780 case 1:
781
782 if (yyyCond(0) != yyyPass) {
783 #line 37 "expr.Y"
784 printf(" / ");
785
786 #line 590 "expr.oxout.y"
787 }
788 break;
789 }
790 break;
791 case 1:
792 switch(yyyPass) {
793 case 0:
794 yyyRL = 0;
795 case 1:
796
797 if (yyyCond(0) != yyyPass) {
798 #line 36 "expr.Y"
799 printf(" / ");
800
801 #line 605 "expr.oxout.y"
802 }
803 break;
804 }
805 break;
806 }
807
808 break;
809 case 5:
810 switch(yyyi) {
811 case 0:
812 switch(yyyPass) {
813 case 0:
814 yyyRL = 0;yyySetCond(0)
815
816 case 1:
817
818 if (yyyCond(0) != yyyPass) {
819 #line 41 "expr.Y"
820 printf(" - ");
821
822 #line 626 "expr.oxout.y"
823 }
824 break;
825 }
826 break;
827 case 1:
828 switch(yyyPass) {
829 case 0:
830 yyyRL = 0;
831 case 1:
832
833 if (yyyCond(0) != yyyPass) {
834 #line 40 "expr.Y"
835 printf(" - ");
836
837 #line 641 "expr.oxout.y"
838 }
839 break;
840 }
841 break;
842 }
843
844 break;
845 case 6:
846 switch(yyyi) {
847 case 0:
848 switch(yyyPass) {
849 case 0:
850 yyyRL = 0;
851 case 1:
852
853 break;
854 }
855 break;
856 case 1:
857 switch(yyyPass) {
858 case 0:
859 yyyRL = 0;
860 case 1:
861
862 break;
863 }
864 break;
865 }
866
867 break;
868 case 7:
869 switch(yyyi) {
870 case 0:
871 switch(yyyPass) {
872 case 0:
873 yyyRL = 0;yyySetCond(0)
874
875 case 1:
876
877 if (yyyCond(0) != yyyPass) {
878 #line 46 "expr.Y"
879 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
880
881 #line 685 "expr.oxout.y"
882 }
883 break;
884 }
885 break;
886 case 1:
887 switch(yyyPass) {
888 case 0:
889 yyyRL = 0;
890 case 1:
891
892 if (yyyCond(0) != yyyPass) {
893 #line 45 "expr.Y"
894 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
895
896 #line 700 "expr.oxout.y"
897 }
898 break;
899 }
900 break;
901 }
902
903 break;
904 case 8:
905 switch(yyyi) {
906 case 0:
907 switch(yyyPass) {
908 case 0:
909 yyyRL = 0;yyySetCond(0)
910
911 case 1:
912
913 if (yyyCond(0) != yyyPass) {
914 #line 50 "expr.Y"
915 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
916
917 #line 721 "expr.oxout.y"
918 }
919 break;
920 }
921 break;
922 case 1:
923 switch(yyyPass) {
924 case 0:
925 yyyRL = 0;
926 case 1:
927
928 if (yyyCond(0) != yyyPass) {
929 #line 49 "expr.Y"
930 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
931
932 #line 736 "expr.oxout.y"
933 }
934 break;
935 }
936 break;
937 }
938
939 break;
940 } /* switch */
941 if (yyyPass) goto yyyTpop; else goto yyyTpush;
942 } /* while */
943 } /* for */
944 } /* yyyDoTraversals */
945
yyyExecuteRRsection(yyyGNT * rootNode)946 void yyyExecuteRRsection(yyyGNT *rootNode) {
947 int yyyi;
948 long cycleSum = 0;
949 long nNZrc = 0;
950
951 if (!yyyYok) return;
952 yyyCheckUnsolvedInstTrav(rootNode,&nNZrc,&cycleSum);
953 if (nNZrc)
954 {
955 fputs("\n\n\n**********\n",stderr);
956 fputs("cycle detected in completed parse tree",stderr);
957 fputs(" after decoration.\n",stderr);
958 #if CYCLE_VERBOSE
959 fprintf(stderr,
960 "number of unsolved attribute instances == %ld.\n",
961 nNZrc
962 );
963 fprintf(stderr,
964 "total number of remaining dependencies == %ld.\n",
965 cycleSum
966 );
967 fputs("average number of remaining dependencies\n",stderr);
968 fprintf(stderr," per unsolved instance == %f.\n",
969 ((float)(cycleSum)/(float)(nNZrc))
970 );
971 #endif
972 fprintf(stderr,
973 "searching parse tree for %ld unsolved instances:\n",
974 nNZrc
975 );
976 yyyUnsolvedInstSearchTravAux(rootNode);
977 }
978 yyyDoTraversals(rootNode);
979 } /* yyyExecuteRRsection */
980
981
982
983 yyyWAT yyyLRCIL[2] = {0,0,
984 };
985
986
987
yyyYoxInit(void)988 void yyyYoxInit(void)
989 {
990 static int yyyInitDone = 0;
991 if (yyyInitDone) return;
992
993 if ((yyyRS = (struct yyyRSitem *)
994 calloc((size_t)(yyyRSmaxSize+1), (size_t)sizeof(struct yyyRSitem))
995 )
996 ==
997 ((struct yyyRSitem *) NULL)
998 )
999 yyyfatal("malloc error in ox ready set space allocation\n");
1000 yyyRS++;
1001 yyyAfterRS = yyyRS + yyyRSmaxSize;
1002
1003
1004 if ((yyySSALspace = (struct yyySolvedSAlistCell *)
1005 calloc((size_t)(yyySSALspaceSize+1), (size_t)sizeof(struct yyySolvedSAlistCell))
1006 )
1007 ==
1008 ((struct yyySolvedSAlistCell *) NULL)
1009 )
1010 yyyfatal("malloc error in stack solved list space allocation\n");
1011 yyyInitDone = 1;
1012
1013 yyyRSTop = yyyRS - 1;
1014 } /* yyyYoxInit */
1015
1016
1017
yyyDecorate(void)1018 void yyyDecorate(void)
1019 {
1020 while (yyyRSTop >= yyyRS)
1021 yyySolveAndSignal();
1022 }
1023
1024
1025
yyyGenIntNode(long yyyProdNum,int yyyRHSlength,int yyyNattrbs,struct yyyOxAttrbs * yyval_OxAttrbs,...)1026 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1027 {yyyWST i;
1028 yyySIT **yyyOxStackItem = &yyval_OxAttrbs->yyyOxStackItem;
1029 yyyGNT *gnpDum;
1030 va_list ap;
1031
1032 *yyyOxStackItem = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1033 if (*yyyOxStackItem == (yyySIT *) NULL)
1034 yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1035 (*yyyOxStackItem)->node =
1036 (yyyGNT *) malloc((size_t)sizeof(yyyGNT));
1037 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1038 yyyfatal("malloc error in ox node space allocation\n");
1039 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1040 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1041 (*yyyOxStackItem)->node->parentIsStack = 1;
1042 (*yyyOxStackItem)->node->cLlen = yyyRHSlength;
1043 (*yyyOxStackItem)->node->cL =
1044 (yyyGNT **) calloc((size_t)yyyRHSlength, (size_t)sizeof(yyyGNT *));
1045 if ((*yyyOxStackItem)->node->cL == (yyyGNT **) NULL)
1046 yyyfatal("malloc error in ox child list space allocation\n");
1047 (*yyyOxStackItem)->node->refCountListLen = yyyNattrbs;
1048 (*yyyOxStackItem)->node->refCountList =
1049 (yyyRCT *) calloc((size_t)yyyNattrbs, (size_t)sizeof(yyyRCT));
1050 if ((*yyyOxStackItem)->node->refCountList == (yyyRCT *) NULL)
1051 yyyfatal("malloc error in ox reference count list space allocation\n");
1052 (*yyyOxStackItem)->node->prodNum = yyyProdNum;
1053 va_start(ap, yyval_OxAttrbs);
1054 for (i=1;i<=yyyRHSlength;i++)
1055 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1056 gnpDum = (*yyyOxStackItem)->node->cL[i-1] = yaccStDum->node;
1057 gnpDum->whichSym = i;
1058 gnpDum->parent.noderef = (*yyyOxStackItem)->node;
1059 gnpDum->parentIsStack = 0;
1060 }
1061 va_end(ap);
1062 }
1063
1064
1065
1066 #define yyyDECORfREQ 50
1067
1068
1069
yyyAdjustINRC(long yyyProdNum,int yyyRHSlength,long startP,long stopP,struct yyyOxAttrbs * yyval_OxAttrbs,...)1070 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1071 {yyyWST i;
1072 yyySIT *yyyOxStackItem = yyval_OxAttrbs->yyyOxStackItem;
1073 long SSALptr,SSALptrHead,*cPtrPtr;
1074 long *pL;
1075 yyyGNT *gnpDum;
1076 long iTemp;
1077 long nextP;
1078 static unsigned short intNodeCount = yyyDECORfREQ;
1079 va_list ap;
1080
1081 nextP = startP;
1082 while (nextP < stopP)
1083 {if (yyyRCIL[nextP] == yyyR)
1084 {(yyyOxStackItem->node->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1085 }
1086 else
1087 {(((yyyOxStackItem->node->cL)[yyyRCIL[nextP]])->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1088 }
1089 nextP += 3;
1090 }
1091 pL = yyyIIEL + yyyIIIEL[yyyProdNum];
1092 va_start(ap, yyval_OxAttrbs);
1093 for (i=1;i<=yyyRHSlength;i++)
1094 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1095 pL++;
1096 SSALptrHead = SSALptr = *(cPtrPtr = &(yaccStDum->solvedSAlist));
1097 if (SSALptr != yyyLambdaSSAL)
1098 {*cPtrPtr = yyyLambdaSSAL;
1099 do
1100 {
1101 iTemp = (*pL+yyySSALspace[SSALptr].attrbNum);
1102 yyySignalEnts(yyyOxStackItem->node,
1103 yyyIEL[iTemp],
1104 yyyIEL[iTemp+1]
1105 );
1106 SSALptr = *(cPtrPtr = &(yyySSALspace[SSALptr].next));
1107 }
1108 while (SSALptr != yyyLambdaSSAL);
1109 *cPtrPtr = yyySSALCfreeList;
1110 yyySSALCfreeList = SSALptrHead;
1111 }
1112 }
1113 va_end(ap);
1114 nextP = startP + 2;
1115 while (nextP < stopP)
1116 {if (!yyyRCIL[nextP])
1117 {if (yyyRCIL[nextP-2] == yyyR)
1118 {pL = &(yyyOxStackItem->solvedSAlist);
1119 if (yyySSALCfreeList == yyyLambdaSSAL)
1120 {yyySSALspace[yyyNewSSALC].next = *pL;
1121 if ((*pL = yyyNewSSALC++) == yyySSALspaceSize)
1122 yyyHandleOverflow(yyySSALof);
1123 }
1124 else
1125 {iTemp = yyySSALCfreeList;
1126 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
1127 yyySSALspace[iTemp].next = *pL;
1128 *pL = iTemp;
1129 }
1130 yyySSALspace[*pL].attrbNum = yyyRCIL[nextP-1];
1131 }
1132 else
1133 {if ((gnpDum = (yyyOxStackItem->node->cL)[yyyRCIL[nextP-2]])->prodNum != 0)
1134 {
1135 iTemp = yyyIIEL[yyyIIIEL[gnpDum->prodNum]] + yyyRCIL[nextP-1];
1136 yyySignalEnts(gnpDum,
1137 yyyIEL[iTemp],
1138 yyyIEL[iTemp+1]
1139 );
1140 }
1141 }
1142 }
1143 nextP += 3;
1144 }
1145 if (!--intNodeCount)
1146 {intNodeCount = yyyDECORfREQ;
1147 yyyDecorate();
1148 }
1149 }
1150
1151
1152
yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE * yylval)1153 void yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE *yylval)
1154 {yyyRCT *rcPdum;
1155 yyySIT **yyyOxStackItem = &yylval->yyyOxAttrbs.yyyOxStackItem;
1156 (*yyyOxStackItem) = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1157 if ((*yyyOxStackItem) == (yyySIT *) NULL)
1158 yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1159 (*yyyOxStackItem)->node =
1160 (yyyGNT *) malloc((size_t)sizeof(yyyGNT))
1161 ;
1162 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1163 yyyfatal("malloc error in ox node space allocation\n");
1164 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1165 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1166 (*yyyOxStackItem)->node->parentIsStack = 1;
1167 (*yyyOxStackItem)->node->cLlen = 0;
1168 (*yyyOxStackItem)->node->cL = (yyyGNT **)NULL;
1169 (*yyyOxStackItem)->node->refCountListLen = nAttrbs;
1170 rcPdum = (*yyyOxStackItem)->node->refCountList =
1171 (yyyRCT *) calloc((size_t)nAttrbs, (size_t)sizeof(yyyRCT));
1172 if (rcPdum == (yyyRCT *) NULL)
1173 yyyfatal("malloc error in ox reference count list space allocation\n");
1174 while (startP < stopP) rcPdum[yyyLRCIL[startP++]] = 0;
1175 (*yyyOxStackItem)->node->prodNum = 0;
1176 (*yyyOxStackItem)->node->whichSym = 0;
1177 }
1178
1179
1180
yyyabort(void)1181 void yyyabort(void)
1182 {yyyYok = 0;
1183 }
1184
1185
1186
1187
1188
1189 #define yyyLastProdNum 8
1190
1191
1192 #define yyyNsorts 1
1193
1194
1195 int yyyProdsInd[] = {
1196 0,
1197 0, 2, 6, 10, 14, 18, 22, 24,
1198 26,
1199 };
1200
1201
1202 int yyyProds[][2] = {
1203 { 116, 0},{ 462, 0},{ 462, 0},{ 462, 0},{ 412, 0},
1204 { 462, 0},{ 462, 0},{ 462, 0},{ 420, 0},{ 462, 0},
1205 { 462, 0},{ 462, 0},{ 452, 0},{ 462, 0},{ 462, 0},
1206 { 462, 0},{ 436, 0},{ 462, 0},{ 462, 0},{ 396, 0},
1207 { 462, 0},{ 404, 0},{ 462, 0},{ 619, 1},{ 462, 0},
1208 { 567, 1},
1209 };
1210
1211
1212 int yyySortsInd[] = {
1213 0,
1214 0,
1215 1,
1216 };
1217
1218
1219 int yyySorts[] = {
1220 413,
1221 };
1222
1223
1224
1225 char *yyyStringTab[] = {
1226 0,0,0,0,0,
1227 0,0,0,0,0,
1228 0,0,0,0,0,
1229 0,0,0,0,0,
1230 0,0,0,0,0,
1231 0,0,0,0,0,
1232 0,0,0,0,0,
1233 0,0,0,0,0,
1234 0,0,0,0,0,
1235 0,0,0,0,0,
1236 0,0,0,0,0,
1237 0,0,0,0,0,
1238 0,0,0,0,0,
1239 0,0,0,0,0,
1240 0,0,0,0,0,
1241 0,0,0,0,0,
1242 0,0,0,0,0,
1243 0,0,0,0,0,
1244 0,0,0,0,0,
1245 0,0,0,0,0,
1246 0,0,0,0,0,
1247 0,0,0,0,0,
1248 0,0,0,0,0,
1249 0,"s",0,0,0,
1250 0,0,"y",0,0,
1251 0,0,0,0,0,
1252 0,0,0,0,0,
1253 0,0,0,0,0,
1254 0,0,0,0,0,
1255 0,0,0,0,0,
1256 0,0,0,0,0,
1257 0,0,0,0,0,
1258 0,0,0,0,0,
1259 0,0,0,0,0,
1260 0,0,0,0,0,
1261 0,0,0,0,0,
1262 0,0,0,0,0,
1263 0,0,0,0,0,
1264 0,0,0,0,0,
1265 0,0,0,0,0,
1266 0,0,0,0,0,
1267 0,0,0,0,0,
1268 0,0,0,0,0,
1269 0,0,0,0,0,
1270 0,0,0,0,0,
1271 0,0,0,0,0,
1272 0,0,0,0,0,
1273 0,0,0,0,0,
1274 0,0,0,0,0,
1275 0,0,0,0,0,
1276 0,0,0,0,0,
1277 0,0,0,0,0,
1278 0,0,0,0,0,
1279 0,0,0,0,0,
1280 0,0,0,0,0,
1281 0,0,0,0,0,
1282 0,0,0,0,0,
1283 0,0,0,0,0,
1284 0,0,0,0,0,
1285 0,0,0,0,0,
1286 0,0,0,0,0,
1287 0,0,0,0,0,
1288 0,0,0,0,0,
1289 0,0,0,0,0,
1290 0,0,0,0,0,
1291 0,"LRpre",0,0,0,
1292 0,0,0,0,0,
1293 0,0,0,0,0,
1294 0,0,0,0,0,
1295 0,0,0,0,0,
1296 0,0,0,0,0,
1297 0,0,0,0,0,
1298 0,0,0,0,0,
1299 0,0,0,0,0,
1300 0,0,0,0,0,
1301 0,0,0,0,0,
1302 0,0,0,0,0,
1303 0,0,0,0,0,
1304 0,0,0,0,0,
1305 0,"'('",0,0,0,
1306 0,0,0,0,"')'",
1307 0,0,0,0,0,
1308 0,0,"'*'","lexeme",0,
1309 0,0,0,0,0,
1310 "'+'",0,0,0,0,
1311 0,0,0,0,0,
1312 0,0,0,0,0,
1313 0,"'-'",0,0,0,
1314 0,0,0,0,0,
1315 0,0,0,0,0,
1316 0,0,"'/'",0,0,
1317 0,0,0,0,0,
1318 0,0,"expr",0,0,
1319 0,0,0,0,0,
1320 0,0,0,0,0,
1321 0,"printf",0,0,0,
1322 0,0,0,0,0,
1323 0,0,0,0,0,
1324 0,0,0,0,0,
1325 0,0,0,0,0,
1326 0,0,0,0,0,
1327 0,0,0,0,0,
1328 0,0,0,0,0,
1329 0,0,0,0,0,
1330 0,0,0,0,0,
1331 0,0,0,0,0,
1332 0,0,0,0,0,
1333 0,0,0,0,0,
1334 0,0,0,0,0,
1335 0,0,0,0,0,
1336 0,0,0,0,0,
1337 0,0,0,0,0,
1338 0,0,0,0,0,
1339 0,0,"CONST","LRpost",0,
1340 0,0,0,0,0,
1341 0,0,0,0,0,
1342 0,0,0,0,0,
1343 0,0,0,0,0,
1344 0,0,0,0,0,
1345 0,0,0,0,0,
1346 0,0,0,0,0,
1347 0,0,0,0,0,
1348 0,0,0,0,0,
1349 0,0,0,0,"ID",
1350 0,0,0,0,0,
1351 0,0,0,0,0,
1352 0,0,0,0,0,
1353 0,0,0,0,0,
1354 0,0,0,0,0,
1355 0,0,0,0,0,
1356 0,0,0,0,0,
1357 0,0,0,0,0,
1358 0,0,0,0,0,
1359 0,0,0,0,0,
1360 0,0,0,0,0,
1361 0,0,0,0,0,
1362 0,0,0,0,0,
1363 0,0,0,0,0,
1364 0,0,0,0,0,
1365 0,0,0,0,0,
1366 0,0,0,0,0,
1367 0,0,0,0,0,
1368 0,0,0,0,0,
1369 0,0,0,0,0,
1370 0,0,0,0,0,
1371 0,0,0,0,0,
1372 0,0,0,0,0,
1373 0,0,0,0,0,
1374 0,0,0,0,0,
1375 0,0,0,0,0,
1376 0,0,0,0,0,
1377 0,0,0,0,0,
1378 0,0,0,0,0,
1379 0,0,0,0,0,
1380 0,0,0,0,0,
1381 0,0,0,0,0,
1382 0,0,0,0,0,
1383 0,0,0,0,0,
1384 0,0,0,0,0,
1385 0,0,0,0,0,
1386 0,0,0,0,0,
1387 0,0,0,0,0,
1388 0,0,0,0,0,
1389 0,0,0,0,0,
1390 0,0,0,0,0,
1391 0,0,0,0,0,
1392 0,0,0,0,0,
1393 0,0,0,0,0,
1394 0,0,0,0,0,
1395 0,0,0,0,0,
1396 0,0,0,0,0,
1397 0,0,0,0,0,
1398 0,0,0,0,0,
1399 0,0,0,0,0,
1400 0,0,0,0,0,
1401 0,0,0,0,0,
1402 0,0,0,0,0,
1403 0,0,0,0,0,
1404 0,0,0,0,0,
1405 0,0,0,0,0,
1406 0,0,0,0,0,
1407 0,0,0,0,0,
1408 0,0,0,0,0,
1409 0,0,0,0,0,
1410 0,0,0,0,0,
1411 0,0,0,0,0,
1412 0,0,0,0,0,
1413 0,0,0,0,0,
1414 0,0,0,0,0,
1415 0,0,0,0,0,
1416 0,0,0,0,0,
1417 0,0,0,0,0,
1418 0,0,0,0,0,
1419 0,0,0,0,0,
1420 0,0,0,0,0,
1421 0,0,0,0,0,
1422 0,0,0,0,0,
1423 0,0,0,0,0,
1424 0,0,0,0,0,
1425 0,0,0,0,0,
1426 0,0,0,0,0,
1427 0,0,0,0,0,
1428 0,0,0,0,0,
1429 0,0,0,0,0,
1430 0,0,0,0,0,
1431 0,0,0,0,0,
1432 0,0,0,0,0,
1433 0,0,0,0,0,
1434 0,0,0,0,0,
1435 0,0,0,0,0,
1436 0,0,0,0,0,
1437 0,0,0,0,0,
1438 0,0,0,0,0,
1439 0,0,0,0,0,
1440 0,0,0,0,0,
1441 0,0,0,0,0,
1442 0,0,0,0,0,
1443 0,0,0,0,0,
1444 0,0,0,0,0,
1445 0,0,0,0,0,
1446 0,0,0,0,0,
1447 0,0,0,0,0,
1448 0,0,0,0,0,
1449 0,0,0,0,0,
1450 0,0,0,0,0,
1451 0,0,0,0,0,
1452 0,0,0,0,0,
1453 0,0,0,0,0,
1454 0,0,0,0,0,
1455 0,0,0,0,0,
1456 0,0,0,0,0,
1457 0,0,0,0,0,
1458 0,0,0,0,0,
1459 0,0,0,0,0,
1460 0,0,0,0,0,
1461 0,0,0,0,0,
1462 0,0,0,0,0,
1463 0,0,0,0,0,
1464 0,0,0,0,0,
1465 0,0,0,0,0,
1466 0,0,0,0,0,
1467 0,0,0,0,0,
1468 0,0,0,0,0,
1469 0,0,0,0,0,
1470 0,0,0,0,0,
1471 0,0,0,0,0,
1472 0,
1473 };
1474
1475
1476
1477 #define yyySizeofProd(num) (yyyProdsInd[(num)+1] - yyyProdsInd[(num)])
1478
1479 #define yyyGSoccurStr(prodNum,symPos) \
1480 (yyyStringTab[yyyProds[yyyProdsInd[(prodNum)] + (symPos)][0]])
1481
1482 #define yyySizeofSort(num) (yyySortsInd[(num)+1] - yyySortsInd[(num)])
1483
1484 #define yyySortOf(prodNum,symPos) \
1485 (yyyProds[yyyProdsInd[(prodNum)] + (symPos)][1])
1486
1487 #define yyyAttrbStr(prodNum,symPos,attrbNum) \
1488 (yyyStringTab[yyySorts[yyySortsInd[yyySortOf(prodNum,symPos)] + \
1489 (attrbNum) \
1490 ] \
1491 ] \
1492 )
1493
1494
1495
yyyShowProd(int i)1496 void yyyShowProd(int i)
1497 {int j,nSyms;
1498
1499 nSyms = yyySizeofProd(i);
1500 for (j=0; j<nSyms; j++)
1501 {
1502 fprintf(stderr,"%s",yyyGSoccurStr(i,j));
1503 if (j == 0) fputs(" : ",stderr); else putc(' ',stderr);
1504 }
1505 fputs(";\n",stderr);
1506 }
1507
1508
1509
yyyShowProds()1510 void yyyShowProds()
1511 {int i; for (i=1; i<=yyyLastProdNum; i++) yyyShowProd(i);}
1512
1513
1514
yyyShowSymsAndSorts()1515 void yyyShowSymsAndSorts()
1516 {int i;
1517
1518 for (i=1; i<=yyyLastProdNum; i++)
1519 {int j, nSyms;
1520
1521 fprintf(stderr,
1522 "\n\n\n---------------------------------- %3.1d\n",i);
1523 /* yyyShowProd(i); */
1524 nSyms = yyySizeofProd(i);
1525 for (j=0; j<nSyms; j++)
1526 {int k, sortSize;
1527
1528 fprintf(stderr,"%s\n",yyyGSoccurStr(i,j));
1529 sortSize = yyySizeofSort(yyySortOf(i,j));
1530 for (k=0; k<sortSize; k++)
1531 fprintf(stderr," %s\n",yyyAttrbStr(i,j,k));
1532 if (j == 0) fputs("->\n",stderr);
1533 else
1534 putc('\n',stderr);
1535 }
1536 }
1537 }
1538
1539
1540
yyyCheckNodeInstancesSolved(yyyGNT * np)1541 void yyyCheckNodeInstancesSolved(yyyGNT *np)
1542 {int mysort,sortSize,i,prodNum,symPos,inTerminalNode;
1543 int nUnsolvedInsts = 0;
1544
1545 if (np->prodNum != 0)
1546 {inTerminalNode = 0;
1547 prodNum = np->prodNum;
1548 symPos = 0;
1549 }
1550 else
1551 {inTerminalNode = 1;
1552 prodNum = np->parent.noderef->prodNum;
1553 symPos = np->whichSym;
1554 }
1555 mysort = yyySortOf(prodNum,symPos);
1556 sortSize = yyySizeofSort(mysort);
1557 for (i=0; i<sortSize; i++)
1558 if ((np->refCountList)[i] != 0) nUnsolvedInsts += 1;
1559 if (nUnsolvedInsts)
1560 {fprintf(stderr,
1561 "\nFound node that has %d unsolved attribute instance(s).\n",
1562 nUnsolvedInsts
1563 );
1564 fprintf(stderr,"Node is labeled \"%s\".\n",
1565 yyyGSoccurStr(prodNum,symPos));
1566 if (inTerminalNode)
1567 {fputs("Node is terminal. Its parent production is:\n ",stderr);
1568 yyyShowProd(prodNum);
1569 }
1570 else
1571 {fputs("Node is nonterminal. ",stderr);
1572 if (!(np->parentIsStack))
1573 {fprintf(stderr,
1574 "Node is %dth child in its parent production:\n ",
1575 np->whichSym
1576 );
1577 yyyShowProd(np->parent.noderef->prodNum);
1578 }
1579 fputs("Node is on left hand side of this production:\n ",stderr);
1580 yyyShowProd(np->prodNum);
1581 }
1582 fputs("The following instances are unsolved:\n",stderr);
1583 for (i=0; i<sortSize; i++)
1584 if ((np->refCountList)[i] != 0)
1585 fprintf(stderr," %-16s still has %1d dependencies.\n",
1586 yyyAttrbStr(prodNum,symPos,i),(np->refCountList)[i]);
1587 }
1588 }
1589
1590
1591
yyyCheckUnsolvedInstTrav(yyyGNT * pNode,long * nNZrc,long * cycleSum)1592 void yyyCheckUnsolvedInstTrav(yyyGNT *pNode,long *nNZrc,long *cycleSum)
1593 {yyyGNT **yyyCLpdum;
1594 yyyRCT *rcp;
1595 int i;
1596
1597 /* visit the refCountList of each node in the tree, and sum the non-zero refCounts */
1598 rcp = pNode->refCountList;
1599 i = pNode->refCountListLen;
1600 while (i--)
1601 if (*rcp++) {*cycleSum += *(rcp - 1); (*nNZrc)++;}
1602 yyyCLpdum = pNode->cL;
1603 i = pNode->cLlen;
1604 while (i--)
1605 {
1606 yyyCheckUnsolvedInstTrav(*yyyCLpdum,nNZrc,cycleSum);
1607 yyyCLpdum++;
1608 }
1609 }
1610
1611
1612
yyyUnsolvedInstSearchTravAux(yyyGNT * pNode)1613 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode)
1614 {yyyGNT **yyyCLpdum;
1615 int i;
1616
1617 yyyCheckNodeInstancesSolved(pNode);
1618 yyyCLpdum = pNode->cL;
1619 i = pNode->cLlen;
1620 while (i--)
1621 {
1622 yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1623 yyyCLpdum++;
1624 }
1625 }
1626
1627
1628
yyyUnsolvedInstSearchTrav(yyyGNT * pNode)1629 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode)
1630 {yyyGNT **yyyCLpdum;
1631 int i;
1632
1633 yyyCLpdum = pNode->cL;
1634 i = pNode->cLlen;
1635 while (i--)
1636 {
1637 yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1638 yyyCLpdum++;
1639 }
1640 }
1641
1642
1643
1644 #line 1645 "expr.oxout.tab.c"
1645
1646 #if YYDEBUG
1647 #include <stdio.h> /* needed for printf */
1648 #endif
1649
1650 #include <stdlib.h> /* needed for malloc, etc */
1651 #include <string.h> /* needed for memset */
1652
1653 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)1654 static int yygrowstack(YYSTACKDATA *data)
1655 {
1656 int i;
1657 unsigned newsize;
1658 YYINT *newss;
1659 YYSTYPE *newvs;
1660
1661 if ((newsize = data->stacksize) == 0)
1662 newsize = YYINITSTACKSIZE;
1663 else if (newsize >= YYMAXDEPTH)
1664 return YYENOMEM;
1665 else if ((newsize *= 2) > YYMAXDEPTH)
1666 newsize = YYMAXDEPTH;
1667
1668 i = (int) (data->s_mark - data->s_base);
1669 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
1670 if (newss == 0)
1671 return YYENOMEM;
1672
1673 data->s_base = newss;
1674 data->s_mark = newss + i;
1675
1676 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1677 if (newvs == 0)
1678 return YYENOMEM;
1679
1680 data->l_base = newvs;
1681 data->l_mark = newvs + i;
1682
1683 data->stacksize = newsize;
1684 data->s_last = data->s_base + newsize - 1;
1685 return 0;
1686 }
1687
1688 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)1689 static void yyfreestack(YYSTACKDATA *data)
1690 {
1691 free(data->s_base);
1692 free(data->l_base);
1693 memset(data, 0, sizeof(*data));
1694 }
1695 #else
1696 #define yyfreestack(data) /* nothing */
1697 #endif
1698
1699 #define YYABORT goto yyabort
1700 #define YYREJECT goto yyabort
1701 #define YYACCEPT goto yyaccept
1702 #define YYERROR goto yyerrlab
1703
1704 int
YYPARSE_DECL()1705 YYPARSE_DECL()
1706 {
1707 int yym, yyn, yystate;
1708 #if YYDEBUG
1709 const char *yys;
1710
1711 if ((yys = getenv("YYDEBUG")) != 0)
1712 {
1713 yyn = *yys;
1714 if (yyn >= '0' && yyn <= '9')
1715 yydebug = yyn - '0';
1716 }
1717 #endif
1718
1719 yym = 0;
1720 yyn = 0;
1721 yynerrs = 0;
1722 yyerrflag = 0;
1723 yychar = YYEMPTY;
1724 yystate = 0;
1725
1726 #if YYPURE
1727 memset(&yystack, 0, sizeof(yystack));
1728 #endif
1729
1730 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1731 yystack.s_mark = yystack.s_base;
1732 yystack.l_mark = yystack.l_base;
1733 yystate = 0;
1734 *yystack.s_mark = 0;
1735
1736 yyloop:
1737 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1738 if (yychar < 0)
1739 {
1740 yychar = YYLEX;
1741 if (yychar < 0) yychar = YYEOF;
1742 #if YYDEBUG
1743 if (yydebug)
1744 {
1745 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1746 printf("%sdebug: state %d, reading %d (%s)\n",
1747 YYPREFIX, yystate, yychar, yys);
1748 }
1749 #endif
1750 }
1751 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1752 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1753 {
1754 #if YYDEBUG
1755 if (yydebug)
1756 printf("%sdebug: state %d, shifting to state %d\n",
1757 YYPREFIX, yystate, yytable[yyn]);
1758 #endif
1759 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1760 yystate = yytable[yyn];
1761 *++yystack.s_mark = yytable[yyn];
1762 *++yystack.l_mark = yylval;
1763 yychar = YYEMPTY;
1764 if (yyerrflag > 0) --yyerrflag;
1765 goto yyloop;
1766 }
1767 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1768 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1769 {
1770 yyn = yytable[yyn];
1771 goto yyreduce;
1772 }
1773 if (yyerrflag != 0) goto yyinrecovery;
1774
1775 YYERROR_CALL("syntax error");
1776
1777 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1778 yyerrlab:
1779 ++yynerrs;
1780
1781 yyinrecovery:
1782 if (yyerrflag < 3)
1783 {
1784 yyerrflag = 3;
1785 for (;;)
1786 {
1787 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1788 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1789 {
1790 #if YYDEBUG
1791 if (yydebug)
1792 printf("%sdebug: state %d, error recovery shifting\
1793 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
1794 #endif
1795 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1796 yystate = yytable[yyn];
1797 *++yystack.s_mark = yytable[yyn];
1798 *++yystack.l_mark = yylval;
1799 goto yyloop;
1800 }
1801 else
1802 {
1803 #if YYDEBUG
1804 if (yydebug)
1805 printf("%sdebug: error recovery discarding state %d\n",
1806 YYPREFIX, *yystack.s_mark);
1807 #endif
1808 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1809 --yystack.s_mark;
1810 --yystack.l_mark;
1811 }
1812 }
1813 }
1814 else
1815 {
1816 if (yychar == YYEOF) goto yyabort;
1817 #if YYDEBUG
1818 if (yydebug)
1819 {
1820 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1821 printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
1822 YYPREFIX, yystate, yychar, yys);
1823 }
1824 #endif
1825 yychar = YYEMPTY;
1826 goto yyloop;
1827 }
1828
1829 yyreduce:
1830 #if YYDEBUG
1831 if (yydebug)
1832 printf("%sdebug: state %d, reducing by rule %d (%s)\n",
1833 YYPREFIX, yystate, yyn, yyrule[yyn]);
1834 #endif
1835 yym = yylen[yyn];
1836 if (yym > 0)
1837 yyval = yystack.l_mark[1-yym];
1838 else
1839 memset(&yyval, 0, sizeof yyval);
1840
1841 switch (yyn)
1842 {
1843 case 1:
1844 #line 64 "expr.oxout.y"
1845 {yyyYoxInit();}
1846 break;
1847 case 2:
1848 #line 66 "expr.oxout.y"
1849 {
1850 yyyDecorate(); yyyExecuteRRsection(yystack.l_mark[0].yyyOxAttrbs.yyyOxStackItem->node);
1851 }
1852 break;
1853 case 3:
1854 #line 73 "expr.oxout.y"
1855 {if(yyyYok){
1856 yyyGenIntNode(1,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1857 yyyAdjustINRC(1,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1858 break;
1859 case 4:
1860 #line 80 "expr.oxout.y"
1861 {if(yyyYok){
1862 yyyGenIntNode(2,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1863 yyyAdjustINRC(2,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1864 break;
1865 case 5:
1866 #line 87 "expr.oxout.y"
1867 {if(yyyYok){
1868 yyyGenIntNode(3,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1869 yyyAdjustINRC(3,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1870 break;
1871 case 6:
1872 #line 94 "expr.oxout.y"
1873 {if(yyyYok){
1874 yyyGenIntNode(4,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1875 yyyAdjustINRC(4,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1876 break;
1877 case 7:
1878 #line 101 "expr.oxout.y"
1879 {if(yyyYok){
1880 yyyGenIntNode(5,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1881 yyyAdjustINRC(5,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1882 break;
1883 case 8:
1884 #line 108 "expr.oxout.y"
1885 {if(yyyYok){
1886 yyyGenIntNode(6,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1887 yyyAdjustINRC(6,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1888 break;
1889 case 9:
1890 #line 114 "expr.oxout.y"
1891 {if(yyyYok){
1892 yyyGenIntNode(7,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1893 yyyAdjustINRC(7,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1894 break;
1895 case 10:
1896 #line 121 "expr.oxout.y"
1897 {if(yyyYok){
1898 yyyGenIntNode(8,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1899 yyyAdjustINRC(8,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1900 break;
1901 #line 1902 "expr.oxout.tab.c"
1902 }
1903 yystack.s_mark -= yym;
1904 yystate = *yystack.s_mark;
1905 yystack.l_mark -= yym;
1906 yym = yylhs[yyn];
1907 if (yystate == 0 && yym == 0)
1908 {
1909 #if YYDEBUG
1910 if (yydebug)
1911 printf("%sdebug: after reduction, shifting from state 0 to\
1912 state %d\n", YYPREFIX, YYFINAL);
1913 #endif
1914 yystate = YYFINAL;
1915 *++yystack.s_mark = YYFINAL;
1916 *++yystack.l_mark = yyval;
1917 if (yychar < 0)
1918 {
1919 yychar = YYLEX;
1920 if (yychar < 0) yychar = YYEOF;
1921 #if YYDEBUG
1922 if (yydebug)
1923 {
1924 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1925 printf("%sdebug: state %d, reading %d (%s)\n",
1926 YYPREFIX, YYFINAL, yychar, yys);
1927 }
1928 #endif
1929 }
1930 if (yychar == YYEOF) goto yyaccept;
1931 goto yyloop;
1932 }
1933 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1934 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1935 yystate = yytable[yyn];
1936 else
1937 yystate = yydgoto[yym];
1938 #if YYDEBUG
1939 if (yydebug)
1940 printf("%sdebug: after reduction, shifting from state %d \
1941 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
1942 #endif
1943 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1944 *++yystack.s_mark = (YYINT) yystate;
1945 *++yystack.l_mark = yyval;
1946 goto yyloop;
1947
1948 yyoverflow:
1949 YYERROR_CALL("yacc stack overflow");
1950
1951 yyabort:
1952 yyfreestack(&yystack);
1953 return (1);
1954
1955 yyaccept:
1956 yyfreestack(&yystack);
1957 return (0);
1958 }
1959