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 #if YYDEBUG 291 int yydebug; 292 #endif 293 294 int yyerrflag; 295 int yychar; 296 YYSTYPE yyval; 297 YYSTYPE yylval; 298 int yynerrs; 299 300 /* define the initial stack-sizes */ 301 #ifdef YYSTACKSIZE 302 #undef YYMAXDEPTH 303 #define YYMAXDEPTH YYSTACKSIZE 304 #else 305 #ifdef YYMAXDEPTH 306 #define YYSTACKSIZE YYMAXDEPTH 307 #else 308 #define YYSTACKSIZE 10000 309 #define YYMAXDEPTH 10000 310 #endif 311 #endif 312 313 #define YYINITSTACKSIZE 200 314 315 typedef struct { 316 unsigned stacksize; 317 YYINT *s_base; 318 YYINT *s_mark; 319 YYINT *s_last; 320 YYSTYPE *l_base; 321 YYSTYPE *l_mark; 322 } YYSTACKDATA; 323 /* variables for the parser stack */ 324 static YYSTACKDATA yystack; 325 #line 53 "expr.Y" 326 327 328 int yyparse(void); 329 330 int main() 331 {yyparse(); 332 } 333 334 335 336 #line 138 "expr.oxout.y" 337 long yyySSALspaceSize = 20000; 338 long yyyRSmaxSize = 1000; 339 long yyyTravStackMaxSize = 2000; 340 341 struct yyySolvedSAlistCell {yyyWAT attrbNum; 342 long next; 343 }; 344 345 #define yyyLambdaSSAL 0 346 long yyySSALCfreeList = yyyLambdaSSAL; 347 long yyyNewSSALC = 1; 348 349 struct yyySolvedSAlistCell *yyySSALspace; 350 351 long yyyNbytesStackStg; 352 353 354 355 yyyFT yyyRCIL[1]; 356 357 short yyyIIIEL[] = {0, 358 0,2,6,10,14,18,22,24, 359 }; 360 361 long yyyIIEL[] = { 362 0,0,0,0,0,0,0,0,0,0,0,0, 363 0,0,0,0,0,0,0,0,0,0,0,0, 364 1,1, 365 }; 366 367 long yyyIEL[] = { 368 0,0,0, 369 }; 370 371 yyyFT yyyEntL[1]; 372 373 void yyyfatal(char *msg) 374 {fputs(msg,stderr);exit(-1);} 375 376 377 378 #define yyySSALof 'S' 379 #define yyyRSof 'q' 380 #define yyyTSof 't' 381 382 383 384 void yyyHandleOverflow(char which) 385 {char *msg1,*msg2; 386 long oldSize,newSize; 387 switch(which) 388 { 389 case yyySSALof : 390 msg1 = "SSAL overflow: "; 391 oldSize = yyySSALspaceSize; 392 break; 393 case yyyRSof : 394 msg1 = "ready set overflow: "; 395 oldSize = yyyRSmaxSize; 396 break; 397 case yyyTSof : 398 msg1 = "traversal stack overflow: "; 399 oldSize = yyyTravStackMaxSize; 400 break; 401 default :; 402 } 403 newSize = (3*oldSize)/2; 404 if (newSize < 100) newSize = 100; 405 fputs(msg1,stderr); 406 fprintf(stderr,"size was %ld.\n",oldSize); 407 msg2 = " Have to modify evaluator: -Y%c%ld.\n"; 408 fprintf(stderr,msg2,which,newSize); 409 exit(-1); 410 } 411 412 413 414 void yyySignalEnts(yyyGNT *node,long startP,long stopP) 415 {yyyGNT *dumNode; 416 417 while (startP < stopP) 418 { 419 if (!yyyEntL[startP]) dumNode = node; 420 else dumNode = (node->cL)[yyyEntL[startP]-1]; 421 if (!(--((dumNode->refCountList)[yyyEntL[startP+1]] 422 ) 423 ) 424 ) 425 { 426 if (++yyyRSTop == yyyAfterRS) 427 {yyyHandleOverflow(yyyRSof); 428 break; 429 } 430 yyyRSTop->node = dumNode; 431 yyyRSTop->whichSym = yyyEntL[startP]; 432 yyyRSTop->wa = yyyEntL[startP+1]; 433 } 434 startP += 2; 435 } 436 } 437 438 439 440 441 442 443 void yyySolveAndSignal() { 444 long yyyiDum,*yyypL; 445 int yyyws,yyywa; 446 yyyGNT *yyyRSTopN,*yyyRefN; 447 yyyParent yyyRSTopNp; 448 449 450 yyyRSTopNp = (yyyRSTopN = yyyRSTop->node)->parent; 451 yyyRefN= (yyyws = (yyyRSTop->whichSym))?yyyRSTopNp.noderef:yyyRSTopN; 452 yyywa = yyyRSTop->wa; 453 yyyRSTop--; 454 switch(yyyRefN->prodNum) { 455 case 1: /***yacc rule 1***/ 456 switch (yyyws) { 457 } 458 break; 459 case 2: /***yacc rule 2***/ 460 switch (yyyws) { 461 } 462 break; 463 case 3: /***yacc rule 3***/ 464 switch (yyyws) { 465 } 466 break; 467 case 4: /***yacc rule 4***/ 468 switch (yyyws) { 469 } 470 break; 471 case 5: /***yacc rule 5***/ 472 switch (yyyws) { 473 } 474 break; 475 case 6: /***yacc rule 6***/ 476 switch (yyyws) { 477 } 478 break; 479 case 7: /***yacc rule 7***/ 480 switch (yyyws) { 481 case 1: /**/ 482 switch (yyywa) { 483 } 484 break; 485 } 486 break; 487 case 8: /***yacc rule 8***/ 488 switch (yyyws) { 489 case 1: /**/ 490 switch (yyywa) { 491 } 492 break; 493 } 494 break; 495 } /* switch */ 496 497 if (yyyws) /* the just-solved instance was inherited. */ 498 {if (yyyRSTopN->prodNum) 499 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopN->prodNum]] + yyywa; 500 yyySignalEnts(yyyRSTopN,yyyIEL[yyyiDum], 501 yyyIEL[yyyiDum+1] 502 ); 503 } 504 } 505 else /* the just-solved instance was synthesized. */ 506 {if (!(yyyRSTopN->parentIsStack)) /* node has a parent. */ 507 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopNp.noderef->prodNum] + 508 yyyRSTopN->whichSym 509 ] + 510 yyywa; 511 yyySignalEnts(yyyRSTopNp.noderef, 512 yyyIEL[yyyiDum], 513 yyyIEL[yyyiDum+1] 514 ); 515 } 516 else /* node is still on the stack--it has no parent yet. */ 517 {yyypL = &(yyyRSTopNp.stackref->solvedSAlist); 518 if (yyySSALCfreeList == yyyLambdaSSAL) 519 {yyySSALspace[yyyNewSSALC].next = *yyypL; 520 if ((*yyypL = yyyNewSSALC++) == yyySSALspaceSize) 521 yyyHandleOverflow(yyySSALof); 522 } 523 else 524 {yyyiDum = yyySSALCfreeList; 525 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next; 526 yyySSALspace[yyyiDum].next = *yyypL; 527 *yyypL = yyyiDum; 528 } 529 yyySSALspace[*yyypL].attrbNum = yyywa; 530 } 531 } 532 533 } /* yyySolveAndSignal */ 534 535 536 537 538 539 540 #define condStg unsigned int conds; 541 #define yyyClearConds {yyyTST->conds = 0;} 542 #define yyySetCond(n) {yyyTST->conds += (1<<(n));} 543 #define yyyCond(n) ((yyyTST->conds & (1<<(n)))?1:0) 544 545 546 547 struct yyyTravStackItem {yyyGNT *node; 548 char isReady; 549 condStg 550 }; 551 552 553 554 void yyyDoTraversals(yyyGNT *rootNode) 555 {struct yyyTravStackItem *yyyTravStack,*yyyTST,*yyyAfterTravStack; 556 yyyGNT *yyyTSTn,**yyyCLptr2; 557 int yyyi,yyyRL,yyyPass; 558 int i; 559 560 if (!yyyYok) return; 561 if ((yyyTravStack = 562 ((struct yyyTravStackItem *) 563 calloc((size_t)yyyTravStackMaxSize, 564 (size_t)sizeof(struct yyyTravStackItem) 565 ) 566 ) 567 ) 568 == 569 (struct yyyTravStackItem *)NULL 570 ) 571 {fputs("malloc error in traversal stack allocation\n",stderr); 572 exit(-1); 573 } 574 575 yyyAfterTravStack = yyyTravStack + yyyTravStackMaxSize; 576 yyyTravStack++; 577 578 579 for (yyyi=0; yyyi<2; yyyi++) { 580 yyyTST = yyyTravStack; 581 yyyTST->node = rootNode; 582 yyyTST->isReady = 0; 583 yyyClearConds 584 585 while(yyyTST >= yyyTravStack) 586 {yyyTSTn = yyyTST->node; 587 if (yyyTST->isReady) 588 {yyyPass = 1; 589 goto yyyTravSwitch; 590 yyyTpop: 591 yyyTST--; 592 } 593 else 594 {yyyPass = 0; 595 goto yyyTravSwitch; 596 yyyTpush: 597 yyyTST->isReady = 1; 598 if (yyyTSTn->prodNum) 599 {if (yyyRL) 600 {yyyCLptr2 = yyyTSTn->cL; 601 i = yyyTSTn->cLlen; 602 while (i--) 603 {if (++yyyTST == yyyAfterTravStack) 604 yyyHandleOverflow(yyyTSof); 605 else 606 {yyyTST->node = *yyyCLptr2; 607 yyyTST->isReady = 0; 608 yyyClearConds 609 } 610 yyyCLptr2++; 611 } 612 } /* right to left */ 613 else /* left to right */ 614 {i = yyyTSTn->cLlen; 615 yyyCLptr2 = yyyTSTn->cL + i; 616 while (i--) 617 {yyyCLptr2--; 618 if (++yyyTST == yyyAfterTravStack) 619 yyyHandleOverflow(yyyTSof); 620 else 621 {yyyTST->node = *yyyCLptr2; 622 yyyTST->isReady = 0; 623 yyyClearConds 624 } 625 } 626 } /* left to right */ 627 } 628 } /* else */ 629 continue; 630 yyyTravSwitch: 631 switch(yyyTSTn->prodNum) { 632 case 1: 633 switch(yyyi) { 634 case 0: 635 switch(yyyPass) { 636 case 0: 637 yyyRL = 0;yyySetCond(0) 638 639 if (! 640 #line 24 "expr.Y" 641 (1) 642 #line 444 "expr.oxout.y" 643 ) yyySetCond(1) 644 yyySetCond(2) 645 646 case 1: 647 648 if (yyyCond(0) != yyyPass) { 649 #line 24 "expr.Y" 650 651 #line 453 "expr.oxout.y" 652 } 653 if (yyyCond(1) != yyyPass) { 654 #line 24 "expr.Y" 655 printf("\n"); 656 657 #line 459 "expr.oxout.y" 658 } 659 if (yyyCond(2) != yyyPass) { 660 #line 25 "expr.Y" 661 printf("prefix: "); 662 663 #line 465 "expr.oxout.y" 664 } 665 break; 666 } 667 break; 668 case 1: 669 switch(yyyPass) { 670 case 0: 671 yyyRL = 0; 672 if ( 673 #line 23 "expr.Y" 674 (1) 675 #line 477 "expr.oxout.y" 676 ) yyySetCond(2) 677 678 case 1: 679 680 if (yyyCond(0) != yyyPass) { 681 #line 22 "expr.Y" 682 printf("\n"); 683 684 #line 486 "expr.oxout.y" 685 } 686 if (yyyCond(1) != yyyPass) { 687 #line 23 "expr.Y" 688 689 #line 491 "expr.oxout.y" 690 } 691 if (yyyCond(2) != yyyPass) { 692 #line 23 "expr.Y" 693 printf("postfix: ")/* missing ; */ 694 695 #line 497 "expr.oxout.y" 696 } 697 break; 698 } 699 break; 700 } 701 702 break; 703 case 2: 704 switch(yyyi) { 705 case 0: 706 switch(yyyPass) { 707 case 0: 708 yyyRL = 0;yyySetCond(0) 709 710 case 1: 711 712 if (yyyCond(0) != yyyPass) { 713 #line 29 "expr.Y" 714 printf(" * "); 715 716 #line 518 "expr.oxout.y" 717 } 718 break; 719 } 720 break; 721 case 1: 722 switch(yyyPass) { 723 case 0: 724 yyyRL = 0; 725 case 1: 726 727 if (yyyCond(0) != yyyPass) { 728 #line 28 "expr.Y" 729 printf(" * "); 730 731 #line 533 "expr.oxout.y" 732 } 733 break; 734 } 735 break; 736 } 737 738 break; 739 case 3: 740 switch(yyyi) { 741 case 0: 742 switch(yyyPass) { 743 case 0: 744 yyyRL = 0;yyySetCond(0) 745 746 case 1: 747 748 if (yyyCond(0) != yyyPass) { 749 #line 32 "expr.Y" 750 printf(" + "); 751 752 #line 554 "expr.oxout.y" 753 } 754 break; 755 } 756 break; 757 case 1: 758 switch(yyyPass) { 759 case 0: 760 yyyRL = 0; 761 case 1: 762 763 if (yyyCond(0) != yyyPass) { 764 #line 33 "expr.Y" 765 printf(" + "); 766 767 #line 569 "expr.oxout.y" 768 } 769 break; 770 } 771 break; 772 } 773 774 break; 775 case 4: 776 switch(yyyi) { 777 case 0: 778 switch(yyyPass) { 779 case 0: 780 yyyRL = 0;yyySetCond(0) 781 782 case 1: 783 784 if (yyyCond(0) != yyyPass) { 785 #line 37 "expr.Y" 786 printf(" / "); 787 788 #line 590 "expr.oxout.y" 789 } 790 break; 791 } 792 break; 793 case 1: 794 switch(yyyPass) { 795 case 0: 796 yyyRL = 0; 797 case 1: 798 799 if (yyyCond(0) != yyyPass) { 800 #line 36 "expr.Y" 801 printf(" / "); 802 803 #line 605 "expr.oxout.y" 804 } 805 break; 806 } 807 break; 808 } 809 810 break; 811 case 5: 812 switch(yyyi) { 813 case 0: 814 switch(yyyPass) { 815 case 0: 816 yyyRL = 0;yyySetCond(0) 817 818 case 1: 819 820 if (yyyCond(0) != yyyPass) { 821 #line 41 "expr.Y" 822 printf(" - "); 823 824 #line 626 "expr.oxout.y" 825 } 826 break; 827 } 828 break; 829 case 1: 830 switch(yyyPass) { 831 case 0: 832 yyyRL = 0; 833 case 1: 834 835 if (yyyCond(0) != yyyPass) { 836 #line 40 "expr.Y" 837 printf(" - "); 838 839 #line 641 "expr.oxout.y" 840 } 841 break; 842 } 843 break; 844 } 845 846 break; 847 case 6: 848 switch(yyyi) { 849 case 0: 850 switch(yyyPass) { 851 case 0: 852 yyyRL = 0; 853 case 1: 854 855 break; 856 } 857 break; 858 case 1: 859 switch(yyyPass) { 860 case 0: 861 yyyRL = 0; 862 case 1: 863 864 break; 865 } 866 break; 867 } 868 869 break; 870 case 7: 871 switch(yyyi) { 872 case 0: 873 switch(yyyPass) { 874 case 0: 875 yyyRL = 0;yyySetCond(0) 876 877 case 1: 878 879 if (yyyCond(0) != yyyPass) { 880 #line 46 "expr.Y" 881 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme); 882 883 #line 685 "expr.oxout.y" 884 } 885 break; 886 } 887 break; 888 case 1: 889 switch(yyyPass) { 890 case 0: 891 yyyRL = 0; 892 case 1: 893 894 if (yyyCond(0) != yyyPass) { 895 #line 45 "expr.Y" 896 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme); 897 898 #line 700 "expr.oxout.y" 899 } 900 break; 901 } 902 break; 903 } 904 905 break; 906 case 8: 907 switch(yyyi) { 908 case 0: 909 switch(yyyPass) { 910 case 0: 911 yyyRL = 0;yyySetCond(0) 912 913 case 1: 914 915 if (yyyCond(0) != yyyPass) { 916 #line 50 "expr.Y" 917 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme); 918 919 #line 721 "expr.oxout.y" 920 } 921 break; 922 } 923 break; 924 case 1: 925 switch(yyyPass) { 926 case 0: 927 yyyRL = 0; 928 case 1: 929 930 if (yyyCond(0) != yyyPass) { 931 #line 49 "expr.Y" 932 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme); 933 934 #line 736 "expr.oxout.y" 935 } 936 break; 937 } 938 break; 939 } 940 941 break; 942 } /* switch */ 943 if (yyyPass) goto yyyTpop; else goto yyyTpush; 944 } /* while */ 945 } /* for */ 946 } /* yyyDoTraversals */ 947 948 void yyyExecuteRRsection(yyyGNT *rootNode) { 949 int yyyi; 950 long cycleSum = 0; 951 long nNZrc = 0; 952 953 if (!yyyYok) return; 954 yyyCheckUnsolvedInstTrav(rootNode,&nNZrc,&cycleSum); 955 if (nNZrc) 956 { 957 fputs("\n\n\n**********\n",stderr); 958 fputs("cycle detected in completed parse tree",stderr); 959 fputs(" after decoration.\n",stderr); 960 #if CYCLE_VERBOSE 961 fprintf(stderr, 962 "number of unsolved attribute instances == %ld.\n", 963 nNZrc 964 ); 965 fprintf(stderr, 966 "total number of remaining dependencies == %ld.\n", 967 cycleSum 968 ); 969 fputs("average number of remaining dependencies\n",stderr); 970 fprintf(stderr," per unsolved instance == %f.\n", 971 ((float)(cycleSum)/(float)(nNZrc)) 972 ); 973 #endif 974 fprintf(stderr, 975 "searching parse tree for %ld unsolved instances:\n", 976 nNZrc 977 ); 978 yyyUnsolvedInstSearchTravAux(rootNode); 979 } 980 yyyDoTraversals(rootNode); 981 } /* yyyExecuteRRsection */ 982 983 984 985 yyyWAT yyyLRCIL[2] = {0,0, 986 }; 987 988 989 990 void yyyYoxInit(void) 991 { 992 static int yyyInitDone = 0; 993 if (yyyInitDone) return; 994 995 if ((yyyRS = (struct yyyRSitem *) 996 calloc((size_t)(yyyRSmaxSize+1), (size_t)sizeof(struct yyyRSitem)) 997 ) 998 == 999 ((struct yyyRSitem *) NULL) 1000 ) 1001 yyyfatal("malloc error in ox ready set space allocation\n"); 1002 yyyRS++; 1003 yyyAfterRS = yyyRS + yyyRSmaxSize; 1004 1005 1006 if ((yyySSALspace = (struct yyySolvedSAlistCell *) 1007 calloc((size_t)(yyySSALspaceSize+1), (size_t)sizeof(struct yyySolvedSAlistCell)) 1008 ) 1009 == 1010 ((struct yyySolvedSAlistCell *) NULL) 1011 ) 1012 yyyfatal("malloc error in stack solved list space allocation\n"); 1013 yyyInitDone = 1; 1014 1015 yyyRSTop = yyyRS - 1; 1016 } /* yyyYoxInit */ 1017 1018 1019 1020 void yyyDecorate(void) 1021 { 1022 while (yyyRSTop >= yyyRS) 1023 yyySolveAndSignal(); 1024 } 1025 1026 1027 1028 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...) 1029 {yyyWST i; 1030 yyySIT **yyyOxStackItem = &yyval_OxAttrbs->yyyOxStackItem; 1031 yyyGNT *gnpDum; 1032 va_list ap; 1033 1034 *yyyOxStackItem = (yyySIT *) malloc((size_t)sizeof(yyySIT)); 1035 if (*yyyOxStackItem == (yyySIT *) NULL) 1036 yyyfatal("malloc error in ox yacc semantic stack space allocation\n"); 1037 (*yyyOxStackItem)->node = 1038 (yyyGNT *) malloc((size_t)sizeof(yyyGNT)); 1039 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL) 1040 yyyfatal("malloc error in ox node space allocation\n"); 1041 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL; 1042 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem; 1043 (*yyyOxStackItem)->node->parentIsStack = 1; 1044 (*yyyOxStackItem)->node->cLlen = yyyRHSlength; 1045 (*yyyOxStackItem)->node->cL = 1046 (yyyGNT **) calloc((size_t)yyyRHSlength, (size_t)sizeof(yyyGNT *)); 1047 if ((*yyyOxStackItem)->node->cL == (yyyGNT **) NULL) 1048 yyyfatal("malloc error in ox child list space allocation\n"); 1049 (*yyyOxStackItem)->node->refCountListLen = yyyNattrbs; 1050 (*yyyOxStackItem)->node->refCountList = 1051 (yyyRCT *) calloc((size_t)yyyNattrbs, (size_t)sizeof(yyyRCT)); 1052 if ((*yyyOxStackItem)->node->refCountList == (yyyRCT *) NULL) 1053 yyyfatal("malloc error in ox reference count list space allocation\n"); 1054 (*yyyOxStackItem)->node->prodNum = yyyProdNum; 1055 va_start(ap, yyval_OxAttrbs); 1056 for (i=1;i<=yyyRHSlength;i++) 1057 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem; 1058 gnpDum = (*yyyOxStackItem)->node->cL[i-1] = yaccStDum->node; 1059 gnpDum->whichSym = i; 1060 gnpDum->parent.noderef = (*yyyOxStackItem)->node; 1061 gnpDum->parentIsStack = 0; 1062 } 1063 va_end(ap); 1064 } 1065 1066 1067 1068 #define yyyDECORfREQ 50 1069 1070 1071 1072 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...) 1073 {yyyWST i; 1074 yyySIT *yyyOxStackItem = yyval_OxAttrbs->yyyOxStackItem; 1075 long SSALptr,SSALptrHead,*cPtrPtr; 1076 long *pL; 1077 yyyGNT *gnpDum; 1078 long iTemp; 1079 long nextP; 1080 static unsigned short intNodeCount = yyyDECORfREQ; 1081 va_list ap; 1082 1083 nextP = startP; 1084 while (nextP < stopP) 1085 {if (yyyRCIL[nextP] == yyyR) 1086 {(yyyOxStackItem->node->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2]; 1087 } 1088 else 1089 {(((yyyOxStackItem->node->cL)[yyyRCIL[nextP]])->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2]; 1090 } 1091 nextP += 3; 1092 } 1093 pL = yyyIIEL + yyyIIIEL[yyyProdNum]; 1094 va_start(ap, yyval_OxAttrbs); 1095 for (i=1;i<=yyyRHSlength;i++) 1096 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem; 1097 pL++; 1098 SSALptrHead = SSALptr = *(cPtrPtr = &(yaccStDum->solvedSAlist)); 1099 if (SSALptr != yyyLambdaSSAL) 1100 {*cPtrPtr = yyyLambdaSSAL; 1101 do 1102 { 1103 iTemp = (*pL+yyySSALspace[SSALptr].attrbNum); 1104 yyySignalEnts(yyyOxStackItem->node, 1105 yyyIEL[iTemp], 1106 yyyIEL[iTemp+1] 1107 ); 1108 SSALptr = *(cPtrPtr = &(yyySSALspace[SSALptr].next)); 1109 } 1110 while (SSALptr != yyyLambdaSSAL); 1111 *cPtrPtr = yyySSALCfreeList; 1112 yyySSALCfreeList = SSALptrHead; 1113 } 1114 } 1115 va_end(ap); 1116 nextP = startP + 2; 1117 while (nextP < stopP) 1118 {if (!yyyRCIL[nextP]) 1119 {if (yyyRCIL[nextP-2] == yyyR) 1120 {pL = &(yyyOxStackItem->solvedSAlist); 1121 if (yyySSALCfreeList == yyyLambdaSSAL) 1122 {yyySSALspace[yyyNewSSALC].next = *pL; 1123 if ((*pL = yyyNewSSALC++) == yyySSALspaceSize) 1124 yyyHandleOverflow(yyySSALof); 1125 } 1126 else 1127 {iTemp = yyySSALCfreeList; 1128 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next; 1129 yyySSALspace[iTemp].next = *pL; 1130 *pL = iTemp; 1131 } 1132 yyySSALspace[*pL].attrbNum = yyyRCIL[nextP-1]; 1133 } 1134 else 1135 {if ((gnpDum = (yyyOxStackItem->node->cL)[yyyRCIL[nextP-2]])->prodNum != 0) 1136 { 1137 iTemp = yyyIIEL[yyyIIIEL[gnpDum->prodNum]] + yyyRCIL[nextP-1]; 1138 yyySignalEnts(gnpDum, 1139 yyyIEL[iTemp], 1140 yyyIEL[iTemp+1] 1141 ); 1142 } 1143 } 1144 } 1145 nextP += 3; 1146 } 1147 if (!--intNodeCount) 1148 {intNodeCount = yyyDECORfREQ; 1149 yyyDecorate(); 1150 } 1151 } 1152 1153 1154 1155 void yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE *yylval) 1156 {yyyRCT *rcPdum; 1157 yyySIT **yyyOxStackItem = &yylval->yyyOxAttrbs.yyyOxStackItem; 1158 (*yyyOxStackItem) = (yyySIT *) malloc((size_t)sizeof(yyySIT)); 1159 if ((*yyyOxStackItem) == (yyySIT *) NULL) 1160 yyyfatal("malloc error in ox yacc semantic stack space allocation\n"); 1161 (*yyyOxStackItem)->node = 1162 (yyyGNT *) malloc((size_t)sizeof(yyyGNT)) 1163 ; 1164 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL) 1165 yyyfatal("malloc error in ox node space allocation\n"); 1166 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL; 1167 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem; 1168 (*yyyOxStackItem)->node->parentIsStack = 1; 1169 (*yyyOxStackItem)->node->cLlen = 0; 1170 (*yyyOxStackItem)->node->cL = (yyyGNT **)NULL; 1171 (*yyyOxStackItem)->node->refCountListLen = nAttrbs; 1172 rcPdum = (*yyyOxStackItem)->node->refCountList = 1173 (yyyRCT *) calloc((size_t)nAttrbs, (size_t)sizeof(yyyRCT)); 1174 if (rcPdum == (yyyRCT *) NULL) 1175 yyyfatal("malloc error in ox reference count list space allocation\n"); 1176 while (startP < stopP) rcPdum[yyyLRCIL[startP++]] = 0; 1177 (*yyyOxStackItem)->node->prodNum = 0; 1178 (*yyyOxStackItem)->node->whichSym = 0; 1179 } 1180 1181 1182 1183 void yyyabort(void) 1184 {yyyYok = 0; 1185 } 1186 1187 1188 1189 1190 1191 #define yyyLastProdNum 8 1192 1193 1194 #define yyyNsorts 1 1195 1196 1197 int yyyProdsInd[] = { 1198 0, 1199 0, 2, 6, 10, 14, 18, 22, 24, 1200 26, 1201 }; 1202 1203 1204 int yyyProds[][2] = { 1205 { 116, 0},{ 462, 0},{ 462, 0},{ 462, 0},{ 412, 0}, 1206 { 462, 0},{ 462, 0},{ 462, 0},{ 420, 0},{ 462, 0}, 1207 { 462, 0},{ 462, 0},{ 452, 0},{ 462, 0},{ 462, 0}, 1208 { 462, 0},{ 436, 0},{ 462, 0},{ 462, 0},{ 396, 0}, 1209 { 462, 0},{ 404, 0},{ 462, 0},{ 619, 1},{ 462, 0}, 1210 { 567, 1}, 1211 }; 1212 1213 1214 int yyySortsInd[] = { 1215 0, 1216 0, 1217 1, 1218 }; 1219 1220 1221 int yyySorts[] = { 1222 413, 1223 }; 1224 1225 1226 1227 char *yyyStringTab[] = { 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,0,0,0,0, 1250 0,0,0,0,0, 1251 0,"s",0,0,0, 1252 0,0,"y",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,0,0,0,0, 1292 0,0,0,0,0, 1293 0,"LRpre",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,0, 1306 0,0,0,0,0, 1307 0,"'('",0,0,0, 1308 0,0,0,0,"')'", 1309 0,0,0,0,0, 1310 0,0,"'*'","lexeme",0, 1311 0,0,0,0,0, 1312 "'+'",0,0,0,0, 1313 0,0,0,0,0, 1314 0,0,0,0,0, 1315 0,"'-'",0,0,0, 1316 0,0,0,0,0, 1317 0,0,0,0,0, 1318 0,0,"'/'",0,0, 1319 0,0,0,0,0, 1320 0,0,"expr",0,0, 1321 0,0,0,0,0, 1322 0,0,0,0,0, 1323 0,"printf",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,0,0,0, 1340 0,0,0,0,0, 1341 0,0,"CONST","LRpost",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,0, 1350 0,0,0,0,0, 1351 0,0,0,0,"ID", 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,0,0,0,0, 1473 0,0,0,0,0, 1474 0, 1475 }; 1476 1477 1478 1479 #define yyySizeofProd(num) (yyyProdsInd[(num)+1] - yyyProdsInd[(num)]) 1480 1481 #define yyyGSoccurStr(prodNum,symPos) \ 1482 (yyyStringTab[yyyProds[yyyProdsInd[(prodNum)] + (symPos)][0]]) 1483 1484 #define yyySizeofSort(num) (yyySortsInd[(num)+1] - yyySortsInd[(num)]) 1485 1486 #define yyySortOf(prodNum,symPos) \ 1487 (yyyProds[yyyProdsInd[(prodNum)] + (symPos)][1]) 1488 1489 #define yyyAttrbStr(prodNum,symPos,attrbNum) \ 1490 (yyyStringTab[yyySorts[yyySortsInd[yyySortOf(prodNum,symPos)] + \ 1491 (attrbNum) \ 1492 ] \ 1493 ] \ 1494 ) 1495 1496 1497 1498 void yyyShowProd(int i) 1499 {int j,nSyms; 1500 1501 nSyms = yyySizeofProd(i); 1502 for (j=0; j<nSyms; j++) 1503 { 1504 fprintf(stderr,"%s",yyyGSoccurStr(i,j)); 1505 if (j == 0) fputs(" : ",stderr); else putc(' ',stderr); 1506 } 1507 fputs(";\n",stderr); 1508 } 1509 1510 1511 1512 void yyyShowProds() 1513 {int i; for (i=1; i<=yyyLastProdNum; i++) yyyShowProd(i);} 1514 1515 1516 1517 void yyyShowSymsAndSorts() 1518 {int i; 1519 1520 for (i=1; i<=yyyLastProdNum; i++) 1521 {int j, nSyms; 1522 1523 fprintf(stderr, 1524 "\n\n\n---------------------------------- %3.1d\n",i); 1525 /* yyyShowProd(i); */ 1526 nSyms = yyySizeofProd(i); 1527 for (j=0; j<nSyms; j++) 1528 {int k, sortSize; 1529 1530 fprintf(stderr,"%s\n",yyyGSoccurStr(i,j)); 1531 sortSize = yyySizeofSort(yyySortOf(i,j)); 1532 for (k=0; k<sortSize; k++) 1533 fprintf(stderr," %s\n",yyyAttrbStr(i,j,k)); 1534 if (j == 0) fputs("->\n",stderr); 1535 else 1536 putc('\n',stderr); 1537 } 1538 } 1539 } 1540 1541 1542 1543 void yyyCheckNodeInstancesSolved(yyyGNT *np) 1544 {int mysort,sortSize,i,prodNum,symPos,inTerminalNode; 1545 int nUnsolvedInsts = 0; 1546 1547 if (np->prodNum != 0) 1548 {inTerminalNode = 0; 1549 prodNum = np->prodNum; 1550 symPos = 0; 1551 } 1552 else 1553 {inTerminalNode = 1; 1554 prodNum = np->parent.noderef->prodNum; 1555 symPos = np->whichSym; 1556 } 1557 mysort = yyySortOf(prodNum,symPos); 1558 sortSize = yyySizeofSort(mysort); 1559 for (i=0; i<sortSize; i++) 1560 if ((np->refCountList)[i] != 0) nUnsolvedInsts += 1; 1561 if (nUnsolvedInsts) 1562 {fprintf(stderr, 1563 "\nFound node that has %d unsolved attribute instance(s).\n", 1564 nUnsolvedInsts 1565 ); 1566 fprintf(stderr,"Node is labeled \"%s\".\n", 1567 yyyGSoccurStr(prodNum,symPos)); 1568 if (inTerminalNode) 1569 {fputs("Node is terminal. Its parent production is:\n ",stderr); 1570 yyyShowProd(prodNum); 1571 } 1572 else 1573 {fputs("Node is nonterminal. ",stderr); 1574 if (!(np->parentIsStack)) 1575 {fprintf(stderr, 1576 "Node is %dth child in its parent production:\n ", 1577 np->whichSym 1578 ); 1579 yyyShowProd(np->parent.noderef->prodNum); 1580 } 1581 fputs("Node is on left hand side of this production:\n ",stderr); 1582 yyyShowProd(np->prodNum); 1583 } 1584 fputs("The following instances are unsolved:\n",stderr); 1585 for (i=0; i<sortSize; i++) 1586 if ((np->refCountList)[i] != 0) 1587 fprintf(stderr," %-16s still has %1d dependencies.\n", 1588 yyyAttrbStr(prodNum,symPos,i),(np->refCountList)[i]); 1589 } 1590 } 1591 1592 1593 1594 void yyyCheckUnsolvedInstTrav(yyyGNT *pNode,long *nNZrc,long *cycleSum) 1595 {yyyGNT **yyyCLpdum; 1596 yyyRCT *rcp; 1597 int i; 1598 1599 /* visit the refCountList of each node in the tree, and sum the non-zero refCounts */ 1600 rcp = pNode->refCountList; 1601 i = pNode->refCountListLen; 1602 while (i--) 1603 if (*rcp++) {*cycleSum += *(rcp - 1); (*nNZrc)++;} 1604 yyyCLpdum = pNode->cL; 1605 i = pNode->cLlen; 1606 while (i--) 1607 { 1608 yyyCheckUnsolvedInstTrav(*yyyCLpdum,nNZrc,cycleSum); 1609 yyyCLpdum++; 1610 } 1611 } 1612 1613 1614 1615 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode) 1616 {yyyGNT **yyyCLpdum; 1617 int i; 1618 1619 yyyCheckNodeInstancesSolved(pNode); 1620 yyyCLpdum = pNode->cL; 1621 i = pNode->cLlen; 1622 while (i--) 1623 { 1624 yyyUnsolvedInstSearchTravAux(*yyyCLpdum); 1625 yyyCLpdum++; 1626 } 1627 } 1628 1629 1630 1631 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode) 1632 {yyyGNT **yyyCLpdum; 1633 int i; 1634 1635 yyyCLpdum = pNode->cL; 1636 i = pNode->cLlen; 1637 while (i--) 1638 { 1639 yyyUnsolvedInstSearchTravAux(*yyyCLpdum); 1640 yyyCLpdum++; 1641 } 1642 } 1643 1644 1645 1646 #line 1647 "expr.oxout.tab.c" 1647 1648 #if YYDEBUG 1649 #include <stdio.h> /* needed for printf */ 1650 #endif 1651 1652 #include <stdlib.h> /* needed for malloc, etc */ 1653 #include <string.h> /* needed for memset */ 1654 1655 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 1656 static int yygrowstack(YYSTACKDATA *data) 1657 { 1658 int i; 1659 unsigned newsize; 1660 YYINT *newss; 1661 YYSTYPE *newvs; 1662 1663 if ((newsize = data->stacksize) == 0) 1664 newsize = YYINITSTACKSIZE; 1665 else if (newsize >= YYMAXDEPTH) 1666 return YYENOMEM; 1667 else if ((newsize *= 2) > YYMAXDEPTH) 1668 newsize = YYMAXDEPTH; 1669 1670 i = (int) (data->s_mark - data->s_base); 1671 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 1672 if (newss == 0) 1673 return YYENOMEM; 1674 1675 data->s_base = newss; 1676 data->s_mark = newss + i; 1677 1678 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 1679 if (newvs == 0) 1680 return YYENOMEM; 1681 1682 data->l_base = newvs; 1683 data->l_mark = newvs + i; 1684 1685 data->stacksize = newsize; 1686 data->s_last = data->s_base + newsize - 1; 1687 return 0; 1688 } 1689 1690 #if YYPURE || defined(YY_NO_LEAKS) 1691 static void yyfreestack(YYSTACKDATA *data) 1692 { 1693 free(data->s_base); 1694 free(data->l_base); 1695 memset(data, 0, sizeof(*data)); 1696 } 1697 #else 1698 #define yyfreestack(data) /* nothing */ 1699 #endif 1700 1701 #define YYABORT goto yyabort 1702 #define YYREJECT goto yyabort 1703 #define YYACCEPT goto yyaccept 1704 #define YYERROR goto yyerrlab 1705 1706 int 1707 YYPARSE_DECL() 1708 { 1709 int yym, yyn, yystate; 1710 #if YYDEBUG 1711 const char *yys; 1712 1713 if ((yys = getenv("YYDEBUG")) != 0) 1714 { 1715 yyn = *yys; 1716 if (yyn >= '0' && yyn <= '9') 1717 yydebug = yyn - '0'; 1718 } 1719 #endif 1720 1721 yym = 0; 1722 yyn = 0; 1723 yynerrs = 0; 1724 yyerrflag = 0; 1725 yychar = YYEMPTY; 1726 yystate = 0; 1727 1728 #if YYPURE 1729 memset(&yystack, 0, sizeof(yystack)); 1730 #endif 1731 1732 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1733 yystack.s_mark = yystack.s_base; 1734 yystack.l_mark = yystack.l_base; 1735 yystate = 0; 1736 *yystack.s_mark = 0; 1737 1738 yyloop: 1739 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 1740 if (yychar < 0) 1741 { 1742 yychar = YYLEX; 1743 if (yychar < 0) yychar = YYEOF; 1744 #if YYDEBUG 1745 if (yydebug) 1746 { 1747 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1748 printf("%sdebug: state %d, reading %d (%s)\n", 1749 YYPREFIX, yystate, yychar, yys); 1750 } 1751 #endif 1752 } 1753 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1754 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1755 { 1756 #if YYDEBUG 1757 if (yydebug) 1758 printf("%sdebug: state %d, shifting to state %d\n", 1759 YYPREFIX, yystate, yytable[yyn]); 1760 #endif 1761 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1762 yystate = yytable[yyn]; 1763 *++yystack.s_mark = yytable[yyn]; 1764 *++yystack.l_mark = yylval; 1765 yychar = YYEMPTY; 1766 if (yyerrflag > 0) --yyerrflag; 1767 goto yyloop; 1768 } 1769 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1770 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1771 { 1772 yyn = yytable[yyn]; 1773 goto yyreduce; 1774 } 1775 if (yyerrflag != 0) goto yyinrecovery; 1776 1777 YYERROR_CALL("syntax error"); 1778 1779 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1780 yyerrlab: 1781 ++yynerrs; 1782 1783 yyinrecovery: 1784 if (yyerrflag < 3) 1785 { 1786 yyerrflag = 3; 1787 for (;;) 1788 { 1789 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1790 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1791 { 1792 #if YYDEBUG 1793 if (yydebug) 1794 printf("%sdebug: state %d, error recovery shifting\ 1795 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]); 1796 #endif 1797 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1798 yystate = yytable[yyn]; 1799 *++yystack.s_mark = yytable[yyn]; 1800 *++yystack.l_mark = yylval; 1801 goto yyloop; 1802 } 1803 else 1804 { 1805 #if YYDEBUG 1806 if (yydebug) 1807 printf("%sdebug: error recovery discarding state %d\n", 1808 YYPREFIX, *yystack.s_mark); 1809 #endif 1810 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1811 --yystack.s_mark; 1812 --yystack.l_mark; 1813 } 1814 } 1815 } 1816 else 1817 { 1818 if (yychar == YYEOF) goto yyabort; 1819 #if YYDEBUG 1820 if (yydebug) 1821 { 1822 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1823 printf("%sdebug: state %d, error recovery discards token %d (%s)\n", 1824 YYPREFIX, yystate, yychar, yys); 1825 } 1826 #endif 1827 yychar = YYEMPTY; 1828 goto yyloop; 1829 } 1830 1831 yyreduce: 1832 #if YYDEBUG 1833 if (yydebug) 1834 printf("%sdebug: state %d, reducing by rule %d (%s)\n", 1835 YYPREFIX, yystate, yyn, yyrule[yyn]); 1836 #endif 1837 yym = yylen[yyn]; 1838 if (yym > 0) 1839 yyval = yystack.l_mark[1-yym]; 1840 else 1841 memset(&yyval, 0, sizeof yyval); 1842 1843 switch (yyn) 1844 { 1845 case 1: 1846 #line 64 "expr.oxout.y" 1847 {yyyYoxInit();} 1848 break; 1849 case 2: 1850 #line 66 "expr.oxout.y" 1851 { 1852 yyyDecorate(); yyyExecuteRRsection(yystack.l_mark[0].yyyOxAttrbs.yyyOxStackItem->node); 1853 } 1854 break; 1855 case 3: 1856 #line 73 "expr.oxout.y" 1857 {if(yyyYok){ 1858 yyyGenIntNode(1,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 1859 yyyAdjustINRC(1,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 1860 break; 1861 case 4: 1862 #line 80 "expr.oxout.y" 1863 {if(yyyYok){ 1864 yyyGenIntNode(2,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 1865 yyyAdjustINRC(2,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 1866 break; 1867 case 5: 1868 #line 87 "expr.oxout.y" 1869 {if(yyyYok){ 1870 yyyGenIntNode(3,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 1871 yyyAdjustINRC(3,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 1872 break; 1873 case 6: 1874 #line 94 "expr.oxout.y" 1875 {if(yyyYok){ 1876 yyyGenIntNode(4,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 1877 yyyAdjustINRC(4,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 1878 break; 1879 case 7: 1880 #line 101 "expr.oxout.y" 1881 {if(yyyYok){ 1882 yyyGenIntNode(5,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 1883 yyyAdjustINRC(5,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 1884 break; 1885 case 8: 1886 #line 108 "expr.oxout.y" 1887 {if(yyyYok){ 1888 yyyGenIntNode(6,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 1889 yyyAdjustINRC(6,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 1890 break; 1891 case 9: 1892 #line 114 "expr.oxout.y" 1893 {if(yyyYok){ 1894 yyyGenIntNode(7,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 1895 yyyAdjustINRC(7,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 1896 break; 1897 case 10: 1898 #line 121 "expr.oxout.y" 1899 {if(yyyYok){ 1900 yyyGenIntNode(8,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 1901 yyyAdjustINRC(8,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 1902 break; 1903 #line 1904 "expr.oxout.tab.c" 1904 } 1905 yystack.s_mark -= yym; 1906 yystate = *yystack.s_mark; 1907 yystack.l_mark -= yym; 1908 yym = yylhs[yyn]; 1909 if (yystate == 0 && yym == 0) 1910 { 1911 #if YYDEBUG 1912 if (yydebug) 1913 printf("%sdebug: after reduction, shifting from state 0 to\ 1914 state %d\n", YYPREFIX, YYFINAL); 1915 #endif 1916 yystate = YYFINAL; 1917 *++yystack.s_mark = YYFINAL; 1918 *++yystack.l_mark = yyval; 1919 if (yychar < 0) 1920 { 1921 yychar = YYLEX; 1922 if (yychar < 0) yychar = YYEOF; 1923 #if YYDEBUG 1924 if (yydebug) 1925 { 1926 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1927 printf("%sdebug: state %d, reading %d (%s)\n", 1928 YYPREFIX, YYFINAL, yychar, yys); 1929 } 1930 #endif 1931 } 1932 if (yychar == YYEOF) goto yyaccept; 1933 goto yyloop; 1934 } 1935 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1936 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1937 yystate = yytable[yyn]; 1938 else 1939 yystate = yydgoto[yym]; 1940 #if YYDEBUG 1941 if (yydebug) 1942 printf("%sdebug: after reduction, shifting from state %d \ 1943 to state %d\n", YYPREFIX, *yystack.s_mark, yystate); 1944 #endif 1945 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1946 *++yystack.s_mark = (YYINT) yystate; 1947 *++yystack.l_mark = yyval; 1948 goto yyloop; 1949 1950 yyoverflow: 1951 YYERROR_CALL("yacc stack overflow"); 1952 1953 yyabort: 1954 yyfreestack(&yystack); 1955 return (1); 1956 1957 yyaccept: 1958 yyfreestack(&yystack); 1959 return (0); 1960 } 1961