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 #undef YYBTYACC 17 #define YYBTYACC 0 18 #define YYDEBUGSTR YYPREFIX "debug" 19 20 #ifndef yyparse 21 #define yyparse expr.oxout_parse 22 #endif /* yyparse */ 23 24 #ifndef yylex 25 #define yylex expr.oxout_lex 26 #endif /* yylex */ 27 28 #ifndef yyerror 29 #define yyerror expr.oxout_error 30 #endif /* yyerror */ 31 32 #ifndef yychar 33 #define yychar expr.oxout_char 34 #endif /* yychar */ 35 36 #ifndef yyval 37 #define yyval expr.oxout_val 38 #endif /* yyval */ 39 40 #ifndef yylval 41 #define yylval expr.oxout_lval 42 #endif /* yylval */ 43 44 #ifndef yydebug 45 #define yydebug expr.oxout_debug 46 #endif /* yydebug */ 47 48 #ifndef yynerrs 49 #define yynerrs expr.oxout_nerrs 50 #endif /* yynerrs */ 51 52 #ifndef yyerrflag 53 #define yyerrflag expr.oxout_errflag 54 #endif /* yyerrflag */ 55 56 #ifndef yylhs 57 #define yylhs expr.oxout_lhs 58 #endif /* yylhs */ 59 60 #ifndef yylen 61 #define yylen expr.oxout_len 62 #endif /* yylen */ 63 64 #ifndef yydefred 65 #define yydefred expr.oxout_defred 66 #endif /* yydefred */ 67 68 #ifndef yystos 69 #define yystos expr.oxout_stos 70 #endif /* yystos */ 71 72 #ifndef yydgoto 73 #define yydgoto expr.oxout_dgoto 74 #endif /* yydgoto */ 75 76 #ifndef yysindex 77 #define yysindex expr.oxout_sindex 78 #endif /* yysindex */ 79 80 #ifndef yyrindex 81 #define yyrindex expr.oxout_rindex 82 #endif /* yyrindex */ 83 84 #ifndef yygindex 85 #define yygindex expr.oxout_gindex 86 #endif /* yygindex */ 87 88 #ifndef yytable 89 #define yytable expr.oxout_table 90 #endif /* yytable */ 91 92 #ifndef yycheck 93 #define yycheck expr.oxout_check 94 #endif /* yycheck */ 95 96 #ifndef yyname 97 #define yyname expr.oxout_name 98 #endif /* yyname */ 99 100 #ifndef yyrule 101 #define yyrule expr.oxout_rule 102 #endif /* yyrule */ 103 104 #if YYBTYACC 105 106 #ifndef yycindex 107 #define yycindex expr.oxout_cindex 108 #endif /* yycindex */ 109 110 #ifndef yyctable 111 #define yyctable expr.oxout_ctable 112 #endif /* yyctable */ 113 114 #endif /* YYBTYACC */ 115 116 #define YYPREFIX "expr.oxout_" 117 118 #define YYPURE 0 119 120 #line 5 "expr.oxout.y" 121 #include <stdlib.h> 122 #include <string.h> 123 #line 8 "expr.Y" 124 125 #include "expr.oxout.h" 126 #include <stdio.h> 127 128 extern int yylex(void); 129 extern void yyerror(const char *); 130 #line 27 "expr.oxout.y" 131 #include <limits.h> 132 #define yyyR USHRT_MAX 133 #ifdef YYSTYPE 134 #undef YYSTYPE_IS_DECLARED 135 #define YYSTYPE_IS_DECLARED 1 136 #endif 137 #ifndef YYSTYPE_IS_DECLARED 138 #define YYSTYPE_IS_DECLARED 1 139 #line 31 "expr.oxout.y" 140 typedef union { 141 struct yyyOxAttrbs { 142 struct yyyStackItem *yyyOxStackItem; 143 } yyyOxAttrbs; 144 } YYSTYPE; 145 #endif /* !YYSTYPE_IS_DECLARED */ 146 #line 38 "expr.oxout.y" 147 #include <stdio.h> 148 #include <stdarg.h> 149 150 static int yyyYok = 1; 151 152 extern yyyFT yyyRCIL[]; 153 154 void yyyExecuteRRsection(yyyGNT *rootNode); 155 void yyyYoxInit(void); 156 void yyyDecorate(void); 157 struct yyyOxAttrbs; /* hack required to compensate for 'msta' behavior */ 158 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...); 159 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...); 160 void yyyCheckUnsolvedInstTrav(yyyGNT *rootNode,long *nNZrc,long *cycleSum); 161 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode); 162 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode); 163 void yyyabort(void); 164 165 #line 166 "expr.oxout.tab.c" 166 167 /* compatibility with bison */ 168 #ifdef YYPARSE_PARAM 169 /* compatibility with FreeBSD */ 170 # ifdef YYPARSE_PARAM_TYPE 171 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 172 # else 173 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 174 # endif 175 #else 176 # define YYPARSE_DECL() yyparse(void) 177 #endif 178 179 /* Parameters sent to lex. */ 180 #ifdef YYLEX_PARAM 181 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 182 # define YYLEX yylex(YYLEX_PARAM) 183 #else 184 # define YYLEX_DECL() yylex(void) 185 # define YYLEX yylex() 186 #endif 187 188 /* Parameters sent to yyerror. */ 189 #ifndef YYERROR_DECL 190 #define YYERROR_DECL() yyerror(const char *s) 191 #endif 192 #ifndef YYERROR_CALL 193 #define YYERROR_CALL(msg) yyerror(msg) 194 #endif 195 196 extern int YYPARSE_DECL(); 197 198 #define ID 257 199 #define CONST 258 200 #define YYERRCODE 256 201 typedef int YYINT; 202 static const YYINT expr.oxout_lhs[] = { -1, 203 2, 0, 1, 3, 3, 3, 3, 3, 3, 3, 204 }; 205 static const YYINT expr.oxout_len[] = { 2, 206 0, 2, 1, 3, 3, 3, 3, 3, 1, 1, 207 }; 208 static const YYINT expr.oxout_defred[] = { 1, 209 0, 0, 9, 10, 0, 2, 0, 0, 0, 0, 210 0, 0, 8, 0, 0, 4, 0, 211 }; 212 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) 213 static const YYINT expr.oxout_stos[] = { 0, 214 260, 262, 257, 258, 40, 261, 263, 263, 43, 45, 215 42, 47, 41, 263, 263, 263, 263, 216 }; 217 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ 218 static const YYINT expr.oxout_dgoto[] = { 1, 219 6, 2, 7, 220 }; 221 static const YYINT expr.oxout_sindex[] = { 0, 222 0, -40, 0, 0, -40, 0, -18, -24, -40, -40, 223 -40, -40, 0, -37, -37, 0, -39, 224 }; 225 static const YYINT expr.oxout_rindex[] = { 0, 226 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 227 0, 0, 0, 2, 8, 0, 1, 228 }; 229 #if YYBTYACC 230 static const YYINT expr.oxout_cindex[] = { 0, 231 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232 0, 0, 0, 0, 0, 0, 0, 233 }; 234 #endif 235 static const YYINT expr.oxout_gindex[] = { 0, 236 0, 0, 4, 237 }; 238 #define YYTABLESIZE 218 239 static const YYINT expr.oxout_table[] = { 5, 240 6, 5, 11, 0, 11, 3, 0, 7, 8, 12, 241 0, 0, 14, 15, 16, 17, 13, 11, 9, 0, 242 10, 0, 12, 11, 9, 0, 10, 0, 12, 0, 243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 244 0, 6, 5, 6, 5, 6, 5, 6, 7, 0, 245 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 246 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 247 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 250 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 251 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 260 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 261 0, 0, 0, 0, 0, 0, 3, 4, 262 }; 263 static const YYINT expr.oxout_check[] = { 40, 264 0, 0, 42, -1, 42, 0, -1, 0, 5, 47, 265 -1, -1, 9, 10, 11, 12, 41, 42, 43, -1, 266 45, -1, 47, 42, 43, -1, 45, -1, 47, -1, 267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 268 -1, 41, 41, 43, 43, 45, 45, 47, 41, -1, 269 43, -1, 45, -1, -1, -1, -1, -1, -1, -1, 270 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 271 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 274 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 275 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 276 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 280 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 281 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 285 -1, -1, -1, -1, -1, -1, 257, 258, 286 }; 287 #if YYBTYACC 288 static const YYINT expr.oxout_ctable[] = { -1, 289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 294 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 295 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 296 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 297 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 298 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 299 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 300 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 301 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 302 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 303 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 306 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 310 -1, -1, -1, -1, -1, -1, -1, 311 }; 312 #endif 313 #define YYFINAL 1 314 #ifndef YYDEBUG 315 #define YYDEBUG 0 316 #endif 317 #define YYMAXTOKEN 258 318 #define YYUNDFTOKEN 264 319 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 320 #if YYDEBUG 321 static const char *const expr.oxout_name[] = { 322 323 "$end",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, 324 0,0,0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 325 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, 326 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, 327 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, 328 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, 329 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,"error","ID", 330 "CONST","$accept","yyyAugNonterm","s","$$1","expr","illegal-symbol", 331 }; 332 static const char *const expr.oxout_rule[] = { 333 "$accept : yyyAugNonterm", 334 "$$1 :", 335 "yyyAugNonterm : $$1 s", 336 "s : expr", 337 "expr : expr '*' expr", 338 "expr : expr '+' expr", 339 "expr : expr '/' expr", 340 "expr : expr '-' expr", 341 "expr : '(' expr ')'", 342 "expr : ID", 343 "expr : CONST", 344 345 }; 346 #endif 347 348 #if YYDEBUG 349 int yydebug; 350 #endif 351 352 int yyerrflag; 353 int yychar; 354 YYSTYPE yyval; 355 YYSTYPE yylval; 356 int yynerrs; 357 358 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 359 YYLTYPE yyloc; /* position returned by actions */ 360 YYLTYPE yylloc; /* position from the lexer */ 361 #endif 362 363 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 364 #ifndef YYLLOC_DEFAULT 365 #define YYLLOC_DEFAULT(loc, rhs, n) \ 366 do \ 367 { \ 368 if (n == 0) \ 369 { \ 370 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \ 371 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \ 372 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \ 373 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \ 374 } \ 375 else \ 376 { \ 377 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \ 378 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \ 379 (loc).last_line = YYRHSLOC(rhs, n).last_line; \ 380 (loc).last_column = YYRHSLOC(rhs, n).last_column; \ 381 } \ 382 } while (0) 383 #endif /* YYLLOC_DEFAULT */ 384 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 385 #if YYBTYACC 386 387 #ifndef YYLVQUEUEGROWTH 388 #define YYLVQUEUEGROWTH 32 389 #endif 390 #endif /* YYBTYACC */ 391 392 /* define the initial stack-sizes */ 393 #ifdef YYSTACKSIZE 394 #undef YYMAXDEPTH 395 #define YYMAXDEPTH YYSTACKSIZE 396 #else 397 #ifdef YYMAXDEPTH 398 #define YYSTACKSIZE YYMAXDEPTH 399 #else 400 #define YYSTACKSIZE 10000 401 #define YYMAXDEPTH 10000 402 #endif 403 #endif 404 405 #ifndef YYINITSTACKSIZE 406 #define YYINITSTACKSIZE 200 407 #endif 408 409 typedef struct { 410 unsigned stacksize; 411 YYINT *s_base; 412 YYINT *s_mark; 413 YYINT *s_last; 414 YYSTYPE *l_base; 415 YYSTYPE *l_mark; 416 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 417 YYLTYPE *p_base; 418 YYLTYPE *p_mark; 419 #endif 420 } YYSTACKDATA; 421 #if YYBTYACC 422 423 struct YYParseState_s 424 { 425 struct YYParseState_s *save; /* Previously saved parser state */ 426 YYSTACKDATA yystack; /* saved parser stack */ 427 int state; /* saved parser state */ 428 int errflag; /* saved error recovery status */ 429 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 430 YYINT ctry; /* saved index in yyctable[] for this conflict */ 431 }; 432 typedef struct YYParseState_s YYParseState; 433 #endif /* YYBTYACC */ 434 /* variables for the parser stack */ 435 static YYSTACKDATA yystack; 436 #if YYBTYACC 437 438 /* Current parser state */ 439 static YYParseState *yyps = 0; 440 441 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 442 static YYParseState *yypath = 0; 443 444 /* Base of the lexical value queue */ 445 static YYSTYPE *yylvals = 0; 446 447 /* Current position at lexical value queue */ 448 static YYSTYPE *yylvp = 0; 449 450 /* End position of lexical value queue */ 451 static YYSTYPE *yylve = 0; 452 453 /* The last allocated position at the lexical value queue */ 454 static YYSTYPE *yylvlim = 0; 455 456 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 457 /* Base of the lexical position queue */ 458 static YYLTYPE *yylpsns = 0; 459 460 /* Current position at lexical position queue */ 461 static YYLTYPE *yylpp = 0; 462 463 /* End position of lexical position queue */ 464 static YYLTYPE *yylpe = 0; 465 466 /* The last allocated position at the lexical position queue */ 467 static YYLTYPE *yylplim = 0; 468 #endif 469 470 /* Current position at lexical token queue */ 471 static YYINT *yylexp = 0; 472 473 static YYINT *yylexemes = 0; 474 #endif /* YYBTYACC */ 475 #line 53 "expr.Y" 476 477 478 int yyparse(void); 479 480 int main() 481 {yyparse(); 482 } 483 484 485 486 #line 138 "expr.oxout.y" 487 long yyySSALspaceSize = 20000; 488 long yyyRSmaxSize = 1000; 489 long yyyTravStackMaxSize = 2000; 490 491 struct yyySolvedSAlistCell {yyyWAT attrbNum; 492 long next; 493 }; 494 495 #define yyyLambdaSSAL 0 496 long yyySSALCfreeList = yyyLambdaSSAL; 497 long yyyNewSSALC = 1; 498 499 struct yyySolvedSAlistCell *yyySSALspace; 500 501 long yyyNbytesStackStg; 502 503 504 505 yyyFT yyyRCIL[1]; 506 507 short yyyIIIEL[] = {0, 508 0,2,6,10,14,18,22,24, 509 }; 510 511 long yyyIIEL[] = { 512 0,0,0,0,0,0,0,0,0,0,0,0, 513 0,0,0,0,0,0,0,0,0,0,0,0, 514 1,1, 515 }; 516 517 long yyyIEL[] = { 518 0,0,0, 519 }; 520 521 yyyFT yyyEntL[1]; 522 523 void yyyfatal(char *msg) 524 {fputs(msg,stderr);exit(-1);} 525 526 527 528 #define yyySSALof 'S' 529 #define yyyRSof 'q' 530 #define yyyTSof 't' 531 532 533 534 void yyyHandleOverflow(char which) 535 {char *msg1,*msg2; 536 long oldSize,newSize; 537 switch(which) 538 { 539 case yyySSALof : 540 msg1 = "SSAL overflow: "; 541 oldSize = yyySSALspaceSize; 542 break; 543 case yyyRSof : 544 msg1 = "ready set overflow: "; 545 oldSize = yyyRSmaxSize; 546 break; 547 case yyyTSof : 548 msg1 = "traversal stack overflow: "; 549 oldSize = yyyTravStackMaxSize; 550 break; 551 default :; 552 } 553 newSize = (3*oldSize)/2; 554 if (newSize < 100) newSize = 100; 555 fputs(msg1,stderr); 556 fprintf(stderr,"size was %ld.\n",oldSize); 557 msg2 = " Have to modify evaluator: -Y%c%ld.\n"; 558 fprintf(stderr,msg2,which,newSize); 559 exit(-1); 560 } 561 562 563 564 void yyySignalEnts(yyyGNT *node,long startP,long stopP) 565 {yyyGNT *dumNode; 566 567 while (startP < stopP) 568 { 569 if (!yyyEntL[startP]) dumNode = node; 570 else dumNode = (node->cL)[yyyEntL[startP]-1]; 571 if (!(--((dumNode->refCountList)[yyyEntL[startP+1]] 572 ) 573 ) 574 ) 575 { 576 if (++yyyRSTop == yyyAfterRS) 577 {yyyHandleOverflow(yyyRSof); 578 break; 579 } 580 yyyRSTop->node = dumNode; 581 yyyRSTop->whichSym = yyyEntL[startP]; 582 yyyRSTop->wa = yyyEntL[startP+1]; 583 } 584 startP += 2; 585 } 586 } 587 588 589 590 591 592 593 void yyySolveAndSignal() { 594 long yyyiDum,*yyypL; 595 int yyyws,yyywa; 596 yyyGNT *yyyRSTopN,*yyyRefN; 597 yyyParent yyyRSTopNp; 598 599 600 yyyRSTopNp = (yyyRSTopN = yyyRSTop->node)->parent; 601 yyyRefN= (yyyws = (yyyRSTop->whichSym))?yyyRSTopNp.noderef:yyyRSTopN; 602 yyywa = yyyRSTop->wa; 603 yyyRSTop--; 604 switch(yyyRefN->prodNum) { 605 case 1: /***yacc rule 1***/ 606 switch (yyyws) { 607 } 608 break; 609 case 2: /***yacc rule 2***/ 610 switch (yyyws) { 611 } 612 break; 613 case 3: /***yacc rule 3***/ 614 switch (yyyws) { 615 } 616 break; 617 case 4: /***yacc rule 4***/ 618 switch (yyyws) { 619 } 620 break; 621 case 5: /***yacc rule 5***/ 622 switch (yyyws) { 623 } 624 break; 625 case 6: /***yacc rule 6***/ 626 switch (yyyws) { 627 } 628 break; 629 case 7: /***yacc rule 7***/ 630 switch (yyyws) { 631 case 1: /**/ 632 switch (yyywa) { 633 } 634 break; 635 } 636 break; 637 case 8: /***yacc rule 8***/ 638 switch (yyyws) { 639 case 1: /**/ 640 switch (yyywa) { 641 } 642 break; 643 } 644 break; 645 } /* switch */ 646 647 if (yyyws) /* the just-solved instance was inherited. */ 648 {if (yyyRSTopN->prodNum) 649 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopN->prodNum]] + yyywa; 650 yyySignalEnts(yyyRSTopN,yyyIEL[yyyiDum], 651 yyyIEL[yyyiDum+1] 652 ); 653 } 654 } 655 else /* the just-solved instance was synthesized. */ 656 {if (!(yyyRSTopN->parentIsStack)) /* node has a parent. */ 657 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopNp.noderef->prodNum] + 658 yyyRSTopN->whichSym 659 ] + 660 yyywa; 661 yyySignalEnts(yyyRSTopNp.noderef, 662 yyyIEL[yyyiDum], 663 yyyIEL[yyyiDum+1] 664 ); 665 } 666 else /* node is still on the stack--it has no parent yet. */ 667 {yyypL = &(yyyRSTopNp.stackref->solvedSAlist); 668 if (yyySSALCfreeList == yyyLambdaSSAL) 669 {yyySSALspace[yyyNewSSALC].next = *yyypL; 670 if ((*yyypL = yyyNewSSALC++) == yyySSALspaceSize) 671 yyyHandleOverflow(yyySSALof); 672 } 673 else 674 {yyyiDum = yyySSALCfreeList; 675 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next; 676 yyySSALspace[yyyiDum].next = *yyypL; 677 *yyypL = yyyiDum; 678 } 679 yyySSALspace[*yyypL].attrbNum = yyywa; 680 } 681 } 682 683 } /* yyySolveAndSignal */ 684 685 686 687 688 689 690 #define condStg unsigned int conds; 691 #define yyyClearConds {yyyTST->conds = 0;} 692 #define yyySetCond(n) {yyyTST->conds += (1<<(n));} 693 #define yyyCond(n) ((yyyTST->conds & (1<<(n)))?1:0) 694 695 696 697 struct yyyTravStackItem {yyyGNT *node; 698 char isReady; 699 condStg 700 }; 701 702 703 704 void yyyDoTraversals(yyyGNT *rootNode) 705 {struct yyyTravStackItem *yyyTravStack,*yyyTST,*yyyAfterTravStack; 706 yyyGNT *yyyTSTn,**yyyCLptr2; 707 int yyyi,yyyRL,yyyPass; 708 int i; 709 710 if (!yyyYok) return; 711 if ((yyyTravStack = 712 ((struct yyyTravStackItem *) 713 calloc((size_t)yyyTravStackMaxSize, 714 (size_t)sizeof(struct yyyTravStackItem) 715 ) 716 ) 717 ) 718 == 719 (struct yyyTravStackItem *)NULL 720 ) 721 {fputs("malloc error in traversal stack allocation\n",stderr); 722 exit(-1); 723 } 724 725 yyyAfterTravStack = yyyTravStack + yyyTravStackMaxSize; 726 yyyTravStack++; 727 728 729 for (yyyi=0; yyyi<2; yyyi++) { 730 yyyTST = yyyTravStack; 731 yyyTST->node = rootNode; 732 yyyTST->isReady = 0; 733 yyyClearConds 734 735 while(yyyTST >= yyyTravStack) 736 {yyyTSTn = yyyTST->node; 737 if (yyyTST->isReady) 738 {yyyPass = 1; 739 goto yyyTravSwitch; 740 yyyTpop: 741 yyyTST--; 742 } 743 else 744 {yyyPass = 0; 745 goto yyyTravSwitch; 746 yyyTpush: 747 yyyTST->isReady = 1; 748 if (yyyTSTn->prodNum) 749 {if (yyyRL) 750 {yyyCLptr2 = yyyTSTn->cL; 751 i = yyyTSTn->cLlen; 752 while (i--) 753 {if (++yyyTST == yyyAfterTravStack) 754 yyyHandleOverflow(yyyTSof); 755 else 756 {yyyTST->node = *yyyCLptr2; 757 yyyTST->isReady = 0; 758 yyyClearConds 759 } 760 yyyCLptr2++; 761 } 762 } /* right to left */ 763 else /* left to right */ 764 {i = yyyTSTn->cLlen; 765 yyyCLptr2 = yyyTSTn->cL + i; 766 while (i--) 767 {yyyCLptr2--; 768 if (++yyyTST == yyyAfterTravStack) 769 yyyHandleOverflow(yyyTSof); 770 else 771 {yyyTST->node = *yyyCLptr2; 772 yyyTST->isReady = 0; 773 yyyClearConds 774 } 775 } 776 } /* left to right */ 777 } 778 } /* else */ 779 continue; 780 yyyTravSwitch: 781 switch(yyyTSTn->prodNum) { 782 case 1: 783 switch(yyyi) { 784 case 0: 785 switch(yyyPass) { 786 case 0: 787 yyyRL = 0;yyySetCond(0) 788 789 if (! 790 #line 24 "expr.Y" 791 (1) 792 #line 444 "expr.oxout.y" 793 ) yyySetCond(1) 794 yyySetCond(2) 795 796 case 1: 797 798 if (yyyCond(0) != yyyPass) { 799 #line 24 "expr.Y" 800 801 #line 453 "expr.oxout.y" 802 } 803 if (yyyCond(1) != yyyPass) { 804 #line 24 "expr.Y" 805 printf("\n"); 806 807 #line 459 "expr.oxout.y" 808 } 809 if (yyyCond(2) != yyyPass) { 810 #line 25 "expr.Y" 811 printf("prefix: "); 812 813 #line 465 "expr.oxout.y" 814 } 815 break; 816 } 817 break; 818 case 1: 819 switch(yyyPass) { 820 case 0: 821 yyyRL = 0; 822 if ( 823 #line 23 "expr.Y" 824 (1) 825 #line 477 "expr.oxout.y" 826 ) yyySetCond(2) 827 828 case 1: 829 830 if (yyyCond(0) != yyyPass) { 831 #line 22 "expr.Y" 832 printf("\n"); 833 834 #line 486 "expr.oxout.y" 835 } 836 if (yyyCond(1) != yyyPass) { 837 #line 23 "expr.Y" 838 839 #line 491 "expr.oxout.y" 840 } 841 if (yyyCond(2) != yyyPass) { 842 #line 23 "expr.Y" 843 printf("postfix: ")/* missing ; */ 844 845 #line 497 "expr.oxout.y" 846 } 847 break; 848 } 849 break; 850 } 851 852 break; 853 case 2: 854 switch(yyyi) { 855 case 0: 856 switch(yyyPass) { 857 case 0: 858 yyyRL = 0;yyySetCond(0) 859 860 case 1: 861 862 if (yyyCond(0) != yyyPass) { 863 #line 29 "expr.Y" 864 printf(" * "); 865 866 #line 518 "expr.oxout.y" 867 } 868 break; 869 } 870 break; 871 case 1: 872 switch(yyyPass) { 873 case 0: 874 yyyRL = 0; 875 case 1: 876 877 if (yyyCond(0) != yyyPass) { 878 #line 28 "expr.Y" 879 printf(" * "); 880 881 #line 533 "expr.oxout.y" 882 } 883 break; 884 } 885 break; 886 } 887 888 break; 889 case 3: 890 switch(yyyi) { 891 case 0: 892 switch(yyyPass) { 893 case 0: 894 yyyRL = 0;yyySetCond(0) 895 896 case 1: 897 898 if (yyyCond(0) != yyyPass) { 899 #line 32 "expr.Y" 900 printf(" + "); 901 902 #line 554 "expr.oxout.y" 903 } 904 break; 905 } 906 break; 907 case 1: 908 switch(yyyPass) { 909 case 0: 910 yyyRL = 0; 911 case 1: 912 913 if (yyyCond(0) != yyyPass) { 914 #line 33 "expr.Y" 915 printf(" + "); 916 917 #line 569 "expr.oxout.y" 918 } 919 break; 920 } 921 break; 922 } 923 924 break; 925 case 4: 926 switch(yyyi) { 927 case 0: 928 switch(yyyPass) { 929 case 0: 930 yyyRL = 0;yyySetCond(0) 931 932 case 1: 933 934 if (yyyCond(0) != yyyPass) { 935 #line 37 "expr.Y" 936 printf(" / "); 937 938 #line 590 "expr.oxout.y" 939 } 940 break; 941 } 942 break; 943 case 1: 944 switch(yyyPass) { 945 case 0: 946 yyyRL = 0; 947 case 1: 948 949 if (yyyCond(0) != yyyPass) { 950 #line 36 "expr.Y" 951 printf(" / "); 952 953 #line 605 "expr.oxout.y" 954 } 955 break; 956 } 957 break; 958 } 959 960 break; 961 case 5: 962 switch(yyyi) { 963 case 0: 964 switch(yyyPass) { 965 case 0: 966 yyyRL = 0;yyySetCond(0) 967 968 case 1: 969 970 if (yyyCond(0) != yyyPass) { 971 #line 41 "expr.Y" 972 printf(" - "); 973 974 #line 626 "expr.oxout.y" 975 } 976 break; 977 } 978 break; 979 case 1: 980 switch(yyyPass) { 981 case 0: 982 yyyRL = 0; 983 case 1: 984 985 if (yyyCond(0) != yyyPass) { 986 #line 40 "expr.Y" 987 printf(" - "); 988 989 #line 641 "expr.oxout.y" 990 } 991 break; 992 } 993 break; 994 } 995 996 break; 997 case 6: 998 switch(yyyi) { 999 case 0: 1000 switch(yyyPass) { 1001 case 0: 1002 yyyRL = 0; 1003 case 1: 1004 1005 break; 1006 } 1007 break; 1008 case 1: 1009 switch(yyyPass) { 1010 case 0: 1011 yyyRL = 0; 1012 case 1: 1013 1014 break; 1015 } 1016 break; 1017 } 1018 1019 break; 1020 case 7: 1021 switch(yyyi) { 1022 case 0: 1023 switch(yyyPass) { 1024 case 0: 1025 yyyRL = 0;yyySetCond(0) 1026 1027 case 1: 1028 1029 if (yyyCond(0) != yyyPass) { 1030 #line 46 "expr.Y" 1031 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme); 1032 1033 #line 685 "expr.oxout.y" 1034 } 1035 break; 1036 } 1037 break; 1038 case 1: 1039 switch(yyyPass) { 1040 case 0: 1041 yyyRL = 0; 1042 case 1: 1043 1044 if (yyyCond(0) != yyyPass) { 1045 #line 45 "expr.Y" 1046 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme); 1047 1048 #line 700 "expr.oxout.y" 1049 } 1050 break; 1051 } 1052 break; 1053 } 1054 1055 break; 1056 case 8: 1057 switch(yyyi) { 1058 case 0: 1059 switch(yyyPass) { 1060 case 0: 1061 yyyRL = 0;yyySetCond(0) 1062 1063 case 1: 1064 1065 if (yyyCond(0) != yyyPass) { 1066 #line 50 "expr.Y" 1067 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme); 1068 1069 #line 721 "expr.oxout.y" 1070 } 1071 break; 1072 } 1073 break; 1074 case 1: 1075 switch(yyyPass) { 1076 case 0: 1077 yyyRL = 0; 1078 case 1: 1079 1080 if (yyyCond(0) != yyyPass) { 1081 #line 49 "expr.Y" 1082 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme); 1083 1084 #line 736 "expr.oxout.y" 1085 } 1086 break; 1087 } 1088 break; 1089 } 1090 1091 break; 1092 } /* switch */ 1093 if (yyyPass) goto yyyTpop; else goto yyyTpush; 1094 } /* while */ 1095 } /* for */ 1096 } /* yyyDoTraversals */ 1097 1098 void yyyExecuteRRsection(yyyGNT *rootNode) { 1099 int yyyi; 1100 long cycleSum = 0; 1101 long nNZrc = 0; 1102 1103 if (!yyyYok) return; 1104 yyyCheckUnsolvedInstTrav(rootNode,&nNZrc,&cycleSum); 1105 if (nNZrc) 1106 { 1107 fputs("\n\n\n**********\n",stderr); 1108 fputs("cycle detected in completed parse tree",stderr); 1109 fputs(" after decoration.\n",stderr); 1110 #if CYCLE_VERBOSE 1111 fprintf(stderr, 1112 "number of unsolved attribute instances == %ld.\n", 1113 nNZrc 1114 ); 1115 fprintf(stderr, 1116 "total number of remaining dependencies == %ld.\n", 1117 cycleSum 1118 ); 1119 fputs("average number of remaining dependencies\n",stderr); 1120 fprintf(stderr," per unsolved instance == %f.\n", 1121 ((float)(cycleSum)/(float)(nNZrc)) 1122 ); 1123 #endif 1124 fprintf(stderr, 1125 "searching parse tree for %ld unsolved instances:\n", 1126 nNZrc 1127 ); 1128 yyyUnsolvedInstSearchTravAux(rootNode); 1129 } 1130 yyyDoTraversals(rootNode); 1131 } /* yyyExecuteRRsection */ 1132 1133 1134 1135 yyyWAT yyyLRCIL[2] = {0,0, 1136 }; 1137 1138 1139 1140 void yyyYoxInit(void) 1141 { 1142 static int yyyInitDone = 0; 1143 if (yyyInitDone) return; 1144 1145 if ((yyyRS = (struct yyyRSitem *) 1146 calloc((size_t)(yyyRSmaxSize+1), (size_t)sizeof(struct yyyRSitem)) 1147 ) 1148 == 1149 ((struct yyyRSitem *) NULL) 1150 ) 1151 yyyfatal("malloc error in ox ready set space allocation\n"); 1152 yyyRS++; 1153 yyyAfterRS = yyyRS + yyyRSmaxSize; 1154 1155 1156 if ((yyySSALspace = (struct yyySolvedSAlistCell *) 1157 calloc((size_t)(yyySSALspaceSize+1), (size_t)sizeof(struct yyySolvedSAlistCell)) 1158 ) 1159 == 1160 ((struct yyySolvedSAlistCell *) NULL) 1161 ) 1162 yyyfatal("malloc error in stack solved list space allocation\n"); 1163 yyyInitDone = 1; 1164 1165 yyyRSTop = yyyRS - 1; 1166 } /* yyyYoxInit */ 1167 1168 1169 1170 void yyyDecorate(void) 1171 { 1172 while (yyyRSTop >= yyyRS) 1173 yyySolveAndSignal(); 1174 } 1175 1176 1177 1178 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...) 1179 {yyyWST i; 1180 yyySIT **yyyOxStackItem = &yyval_OxAttrbs->yyyOxStackItem; 1181 yyyGNT *gnpDum; 1182 va_list ap; 1183 1184 *yyyOxStackItem = (yyySIT *) malloc((size_t)sizeof(yyySIT)); 1185 if (*yyyOxStackItem == (yyySIT *) NULL) 1186 yyyfatal("malloc error in ox yacc semantic stack space allocation\n"); 1187 (*yyyOxStackItem)->node = 1188 (yyyGNT *) malloc((size_t)sizeof(yyyGNT)); 1189 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL) 1190 yyyfatal("malloc error in ox node space allocation\n"); 1191 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL; 1192 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem; 1193 (*yyyOxStackItem)->node->parentIsStack = 1; 1194 (*yyyOxStackItem)->node->cLlen = yyyRHSlength; 1195 (*yyyOxStackItem)->node->cL = 1196 (yyyGNT **) calloc((size_t)yyyRHSlength, (size_t)sizeof(yyyGNT *)); 1197 if ((*yyyOxStackItem)->node->cL == (yyyGNT **) NULL) 1198 yyyfatal("malloc error in ox child list space allocation\n"); 1199 (*yyyOxStackItem)->node->refCountListLen = yyyNattrbs; 1200 (*yyyOxStackItem)->node->refCountList = 1201 (yyyRCT *) calloc((size_t)yyyNattrbs, (size_t)sizeof(yyyRCT)); 1202 if ((*yyyOxStackItem)->node->refCountList == (yyyRCT *) NULL) 1203 yyyfatal("malloc error in ox reference count list space allocation\n"); 1204 (*yyyOxStackItem)->node->prodNum = yyyProdNum; 1205 va_start(ap, yyval_OxAttrbs); 1206 for (i=1;i<=yyyRHSlength;i++) 1207 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem; 1208 gnpDum = (*yyyOxStackItem)->node->cL[i-1] = yaccStDum->node; 1209 gnpDum->whichSym = i; 1210 gnpDum->parent.noderef = (*yyyOxStackItem)->node; 1211 gnpDum->parentIsStack = 0; 1212 } 1213 va_end(ap); 1214 } 1215 1216 1217 1218 #define yyyDECORfREQ 50 1219 1220 1221 1222 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...) 1223 {yyyWST i; 1224 yyySIT *yyyOxStackItem = yyval_OxAttrbs->yyyOxStackItem; 1225 long SSALptr,SSALptrHead,*cPtrPtr; 1226 long *pL; 1227 yyyGNT *gnpDum; 1228 long iTemp; 1229 long nextP; 1230 static unsigned short intNodeCount = yyyDECORfREQ; 1231 va_list ap; 1232 1233 nextP = startP; 1234 while (nextP < stopP) 1235 {if (yyyRCIL[nextP] == yyyR) 1236 {(yyyOxStackItem->node->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2]; 1237 } 1238 else 1239 {(((yyyOxStackItem->node->cL)[yyyRCIL[nextP]])->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2]; 1240 } 1241 nextP += 3; 1242 } 1243 pL = yyyIIEL + yyyIIIEL[yyyProdNum]; 1244 va_start(ap, yyval_OxAttrbs); 1245 for (i=1;i<=yyyRHSlength;i++) 1246 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem; 1247 pL++; 1248 SSALptrHead = SSALptr = *(cPtrPtr = &(yaccStDum->solvedSAlist)); 1249 if (SSALptr != yyyLambdaSSAL) 1250 {*cPtrPtr = yyyLambdaSSAL; 1251 do 1252 { 1253 iTemp = (*pL+yyySSALspace[SSALptr].attrbNum); 1254 yyySignalEnts(yyyOxStackItem->node, 1255 yyyIEL[iTemp], 1256 yyyIEL[iTemp+1] 1257 ); 1258 SSALptr = *(cPtrPtr = &(yyySSALspace[SSALptr].next)); 1259 } 1260 while (SSALptr != yyyLambdaSSAL); 1261 *cPtrPtr = yyySSALCfreeList; 1262 yyySSALCfreeList = SSALptrHead; 1263 } 1264 } 1265 va_end(ap); 1266 nextP = startP + 2; 1267 while (nextP < stopP) 1268 {if (!yyyRCIL[nextP]) 1269 {if (yyyRCIL[nextP-2] == yyyR) 1270 {pL = &(yyyOxStackItem->solvedSAlist); 1271 if (yyySSALCfreeList == yyyLambdaSSAL) 1272 {yyySSALspace[yyyNewSSALC].next = *pL; 1273 if ((*pL = yyyNewSSALC++) == yyySSALspaceSize) 1274 yyyHandleOverflow(yyySSALof); 1275 } 1276 else 1277 {iTemp = yyySSALCfreeList; 1278 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next; 1279 yyySSALspace[iTemp].next = *pL; 1280 *pL = iTemp; 1281 } 1282 yyySSALspace[*pL].attrbNum = yyyRCIL[nextP-1]; 1283 } 1284 else 1285 {if ((gnpDum = (yyyOxStackItem->node->cL)[yyyRCIL[nextP-2]])->prodNum != 0) 1286 { 1287 iTemp = yyyIIEL[yyyIIIEL[gnpDum->prodNum]] + yyyRCIL[nextP-1]; 1288 yyySignalEnts(gnpDum, 1289 yyyIEL[iTemp], 1290 yyyIEL[iTemp+1] 1291 ); 1292 } 1293 } 1294 } 1295 nextP += 3; 1296 } 1297 if (!--intNodeCount) 1298 {intNodeCount = yyyDECORfREQ; 1299 yyyDecorate(); 1300 } 1301 } 1302 1303 1304 1305 void yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE *yylval) 1306 {yyyRCT *rcPdum; 1307 yyySIT **yyyOxStackItem = &yylval->yyyOxAttrbs.yyyOxStackItem; 1308 (*yyyOxStackItem) = (yyySIT *) malloc((size_t)sizeof(yyySIT)); 1309 if ((*yyyOxStackItem) == (yyySIT *) NULL) 1310 yyyfatal("malloc error in ox yacc semantic stack space allocation\n"); 1311 (*yyyOxStackItem)->node = 1312 (yyyGNT *) malloc((size_t)sizeof(yyyGNT)) 1313 ; 1314 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL) 1315 yyyfatal("malloc error in ox node space allocation\n"); 1316 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL; 1317 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem; 1318 (*yyyOxStackItem)->node->parentIsStack = 1; 1319 (*yyyOxStackItem)->node->cLlen = 0; 1320 (*yyyOxStackItem)->node->cL = (yyyGNT **)NULL; 1321 (*yyyOxStackItem)->node->refCountListLen = nAttrbs; 1322 rcPdum = (*yyyOxStackItem)->node->refCountList = 1323 (yyyRCT *) calloc((size_t)nAttrbs, (size_t)sizeof(yyyRCT)); 1324 if (rcPdum == (yyyRCT *) NULL) 1325 yyyfatal("malloc error in ox reference count list space allocation\n"); 1326 while (startP < stopP) rcPdum[yyyLRCIL[startP++]] = 0; 1327 (*yyyOxStackItem)->node->prodNum = 0; 1328 (*yyyOxStackItem)->node->whichSym = 0; 1329 } 1330 1331 1332 1333 void yyyabort(void) 1334 {yyyYok = 0; 1335 } 1336 1337 1338 1339 1340 1341 #define yyyLastProdNum 8 1342 1343 1344 #define yyyNsorts 1 1345 1346 1347 int yyyProdsInd[] = { 1348 0, 1349 0, 2, 6, 10, 14, 18, 22, 24, 1350 26, 1351 }; 1352 1353 1354 int yyyProds[][2] = { 1355 { 116, 0},{ 462, 0},{ 462, 0},{ 462, 0},{ 412, 0}, 1356 { 462, 0},{ 462, 0},{ 462, 0},{ 420, 0},{ 462, 0}, 1357 { 462, 0},{ 462, 0},{ 452, 0},{ 462, 0},{ 462, 0}, 1358 { 462, 0},{ 436, 0},{ 462, 0},{ 462, 0},{ 396, 0}, 1359 { 462, 0},{ 404, 0},{ 462, 0},{ 619, 1},{ 462, 0}, 1360 { 567, 1}, 1361 }; 1362 1363 1364 int yyySortsInd[] = { 1365 0, 1366 0, 1367 1, 1368 }; 1369 1370 1371 int yyySorts[] = { 1372 413, 1373 }; 1374 1375 1376 1377 char *yyyStringTab[] = { 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,"s",0,0,0, 1402 0,0,"y",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,"LRpre",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, 1458 0,0,0,0,"')'", 1459 0,0,0,0,0, 1460 0,0,"'*'","lexeme",0, 1461 0,0,0,0,0, 1462 "'+'",0,0,0,0, 1463 0,0,0,0,0, 1464 0,0,0,0,0, 1465 0,"'-'",0,0,0, 1466 0,0,0,0,0, 1467 0,0,0,0,0, 1468 0,0,"'/'",0,0, 1469 0,0,0,0,0, 1470 0,0,"expr",0,0, 1471 0,0,0,0,0, 1472 0,0,0,0,0, 1473 0,"printf",0,0,0, 1474 0,0,0,0,0, 1475 0,0,0,0,0, 1476 0,0,0,0,0, 1477 0,0,0,0,0, 1478 0,0,0,0,0, 1479 0,0,0,0,0, 1480 0,0,0,0,0, 1481 0,0,0,0,0, 1482 0,0,0,0,0, 1483 0,0,0,0,0, 1484 0,0,0,0,0, 1485 0,0,0,0,0, 1486 0,0,0,0,0, 1487 0,0,0,0,0, 1488 0,0,0,0,0, 1489 0,0,0,0,0, 1490 0,0,0,0,0, 1491 0,0,"CONST","LRpost",0, 1492 0,0,0,0,0, 1493 0,0,0,0,0, 1494 0,0,0,0,0, 1495 0,0,0,0,0, 1496 0,0,0,0,0, 1497 0,0,0,0,0, 1498 0,0,0,0,0, 1499 0,0,0,0,0, 1500 0,0,0,0,0, 1501 0,0,0,0,"ID", 1502 0,0,0,0,0, 1503 0,0,0,0,0, 1504 0,0,0,0,0, 1505 0,0,0,0,0, 1506 0,0,0,0,0, 1507 0,0,0,0,0, 1508 0,0,0,0,0, 1509 0,0,0,0,0, 1510 0,0,0,0,0, 1511 0,0,0,0,0, 1512 0,0,0,0,0, 1513 0,0,0,0,0, 1514 0,0,0,0,0, 1515 0,0,0,0,0, 1516 0,0,0,0,0, 1517 0,0,0,0,0, 1518 0,0,0,0,0, 1519 0,0,0,0,0, 1520 0,0,0,0,0, 1521 0,0,0,0,0, 1522 0,0,0,0,0, 1523 0,0,0,0,0, 1524 0,0,0,0,0, 1525 0,0,0,0,0, 1526 0,0,0,0,0, 1527 0,0,0,0,0, 1528 0,0,0,0,0, 1529 0,0,0,0,0, 1530 0,0,0,0,0, 1531 0,0,0,0,0, 1532 0,0,0,0,0, 1533 0,0,0,0,0, 1534 0,0,0,0,0, 1535 0,0,0,0,0, 1536 0,0,0,0,0, 1537 0,0,0,0,0, 1538 0,0,0,0,0, 1539 0,0,0,0,0, 1540 0,0,0,0,0, 1541 0,0,0,0,0, 1542 0,0,0,0,0, 1543 0,0,0,0,0, 1544 0,0,0,0,0, 1545 0,0,0,0,0, 1546 0,0,0,0,0, 1547 0,0,0,0,0, 1548 0,0,0,0,0, 1549 0,0,0,0,0, 1550 0,0,0,0,0, 1551 0,0,0,0,0, 1552 0,0,0,0,0, 1553 0,0,0,0,0, 1554 0,0,0,0,0, 1555 0,0,0,0,0, 1556 0,0,0,0,0, 1557 0,0,0,0,0, 1558 0,0,0,0,0, 1559 0,0,0,0,0, 1560 0,0,0,0,0, 1561 0,0,0,0,0, 1562 0,0,0,0,0, 1563 0,0,0,0,0, 1564 0,0,0,0,0, 1565 0,0,0,0,0, 1566 0,0,0,0,0, 1567 0,0,0,0,0, 1568 0,0,0,0,0, 1569 0,0,0,0,0, 1570 0,0,0,0,0, 1571 0,0,0,0,0, 1572 0,0,0,0,0, 1573 0,0,0,0,0, 1574 0,0,0,0,0, 1575 0,0,0,0,0, 1576 0,0,0,0,0, 1577 0,0,0,0,0, 1578 0,0,0,0,0, 1579 0,0,0,0,0, 1580 0,0,0,0,0, 1581 0,0,0,0,0, 1582 0,0,0,0,0, 1583 0,0,0,0,0, 1584 0,0,0,0,0, 1585 0,0,0,0,0, 1586 0,0,0,0,0, 1587 0,0,0,0,0, 1588 0,0,0,0,0, 1589 0,0,0,0,0, 1590 0,0,0,0,0, 1591 0,0,0,0,0, 1592 0,0,0,0,0, 1593 0,0,0,0,0, 1594 0,0,0,0,0, 1595 0,0,0,0,0, 1596 0,0,0,0,0, 1597 0,0,0,0,0, 1598 0,0,0,0,0, 1599 0,0,0,0,0, 1600 0,0,0,0,0, 1601 0,0,0,0,0, 1602 0,0,0,0,0, 1603 0,0,0,0,0, 1604 0,0,0,0,0, 1605 0,0,0,0,0, 1606 0,0,0,0,0, 1607 0,0,0,0,0, 1608 0,0,0,0,0, 1609 0,0,0,0,0, 1610 0,0,0,0,0, 1611 0,0,0,0,0, 1612 0,0,0,0,0, 1613 0,0,0,0,0, 1614 0,0,0,0,0, 1615 0,0,0,0,0, 1616 0,0,0,0,0, 1617 0,0,0,0,0, 1618 0,0,0,0,0, 1619 0,0,0,0,0, 1620 0,0,0,0,0, 1621 0,0,0,0,0, 1622 0,0,0,0,0, 1623 0,0,0,0,0, 1624 0, 1625 }; 1626 1627 1628 1629 #define yyySizeofProd(num) (yyyProdsInd[(num)+1] - yyyProdsInd[(num)]) 1630 1631 #define yyyGSoccurStr(prodNum,symPos) \ 1632 (yyyStringTab[yyyProds[yyyProdsInd[(prodNum)] + (symPos)][0]]) 1633 1634 #define yyySizeofSort(num) (yyySortsInd[(num)+1] - yyySortsInd[(num)]) 1635 1636 #define yyySortOf(prodNum,symPos) \ 1637 (yyyProds[yyyProdsInd[(prodNum)] + (symPos)][1]) 1638 1639 #define yyyAttrbStr(prodNum,symPos,attrbNum) \ 1640 (yyyStringTab[yyySorts[yyySortsInd[yyySortOf(prodNum,symPos)] + \ 1641 (attrbNum) \ 1642 ] \ 1643 ] \ 1644 ) 1645 1646 1647 1648 void yyyShowProd(int i) 1649 {int j,nSyms; 1650 1651 nSyms = yyySizeofProd(i); 1652 for (j=0; j<nSyms; j++) 1653 { 1654 fprintf(stderr,"%s",yyyGSoccurStr(i,j)); 1655 if (j == 0) fputs(" : ",stderr); else putc(' ',stderr); 1656 } 1657 fputs(";\n",stderr); 1658 } 1659 1660 1661 1662 void yyyShowProds() 1663 {int i; for (i=1; i<=yyyLastProdNum; i++) yyyShowProd(i);} 1664 1665 1666 1667 void yyyShowSymsAndSorts() 1668 {int i; 1669 1670 for (i=1; i<=yyyLastProdNum; i++) 1671 {int j, nSyms; 1672 1673 fprintf(stderr, 1674 "\n\n\n---------------------------------- %3.1d\n",i); 1675 /* yyyShowProd(i); */ 1676 nSyms = yyySizeofProd(i); 1677 for (j=0; j<nSyms; j++) 1678 {int k, sortSize; 1679 1680 fprintf(stderr,"%s\n",yyyGSoccurStr(i,j)); 1681 sortSize = yyySizeofSort(yyySortOf(i,j)); 1682 for (k=0; k<sortSize; k++) 1683 fprintf(stderr," %s\n",yyyAttrbStr(i,j,k)); 1684 if (j == 0) fputs("->\n",stderr); 1685 else 1686 putc('\n',stderr); 1687 } 1688 } 1689 } 1690 1691 1692 1693 void yyyCheckNodeInstancesSolved(yyyGNT *np) 1694 {int mysort,sortSize,i,prodNum,symPos,inTerminalNode; 1695 int nUnsolvedInsts = 0; 1696 1697 if (np->prodNum != 0) 1698 {inTerminalNode = 0; 1699 prodNum = np->prodNum; 1700 symPos = 0; 1701 } 1702 else 1703 {inTerminalNode = 1; 1704 prodNum = np->parent.noderef->prodNum; 1705 symPos = np->whichSym; 1706 } 1707 mysort = yyySortOf(prodNum,symPos); 1708 sortSize = yyySizeofSort(mysort); 1709 for (i=0; i<sortSize; i++) 1710 if ((np->refCountList)[i] != 0) nUnsolvedInsts += 1; 1711 if (nUnsolvedInsts) 1712 {fprintf(stderr, 1713 "\nFound node that has %d unsolved attribute instance(s).\n", 1714 nUnsolvedInsts 1715 ); 1716 fprintf(stderr,"Node is labeled \"%s\".\n", 1717 yyyGSoccurStr(prodNum,symPos)); 1718 if (inTerminalNode) 1719 {fputs("Node is terminal. Its parent production is:\n ",stderr); 1720 yyyShowProd(prodNum); 1721 } 1722 else 1723 {fputs("Node is nonterminal. ",stderr); 1724 if (!(np->parentIsStack)) 1725 {fprintf(stderr, 1726 "Node is %dth child in its parent production:\n ", 1727 np->whichSym 1728 ); 1729 yyyShowProd(np->parent.noderef->prodNum); 1730 } 1731 fputs("Node is on left hand side of this production:\n ",stderr); 1732 yyyShowProd(np->prodNum); 1733 } 1734 fputs("The following instances are unsolved:\n",stderr); 1735 for (i=0; i<sortSize; i++) 1736 if ((np->refCountList)[i] != 0) 1737 fprintf(stderr," %-16s still has %1d dependencies.\n", 1738 yyyAttrbStr(prodNum,symPos,i),(np->refCountList)[i]); 1739 } 1740 } 1741 1742 1743 1744 void yyyCheckUnsolvedInstTrav(yyyGNT *pNode,long *nNZrc,long *cycleSum) 1745 {yyyGNT **yyyCLpdum; 1746 yyyRCT *rcp; 1747 int i; 1748 1749 /* visit the refCountList of each node in the tree, and sum the non-zero refCounts */ 1750 rcp = pNode->refCountList; 1751 i = pNode->refCountListLen; 1752 while (i--) 1753 if (*rcp++) {*cycleSum += *(rcp - 1); (*nNZrc)++;} 1754 yyyCLpdum = pNode->cL; 1755 i = pNode->cLlen; 1756 while (i--) 1757 { 1758 yyyCheckUnsolvedInstTrav(*yyyCLpdum,nNZrc,cycleSum); 1759 yyyCLpdum++; 1760 } 1761 } 1762 1763 1764 1765 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode) 1766 {yyyGNT **yyyCLpdum; 1767 int i; 1768 1769 yyyCheckNodeInstancesSolved(pNode); 1770 yyyCLpdum = pNode->cL; 1771 i = pNode->cLlen; 1772 while (i--) 1773 { 1774 yyyUnsolvedInstSearchTravAux(*yyyCLpdum); 1775 yyyCLpdum++; 1776 } 1777 } 1778 1779 1780 1781 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode) 1782 {yyyGNT **yyyCLpdum; 1783 int i; 1784 1785 yyyCLpdum = pNode->cL; 1786 i = pNode->cLlen; 1787 while (i--) 1788 { 1789 yyyUnsolvedInstSearchTravAux(*yyyCLpdum); 1790 yyyCLpdum++; 1791 } 1792 } 1793 1794 1795 1796 #line 1797 "expr.oxout.tab.c" 1797 1798 /* For use in generated program */ 1799 #define yydepth (int)(yystack.s_mark - yystack.s_base) 1800 #if YYBTYACC 1801 #define yytrial (yyps->save) 1802 #endif /* YYBTYACC */ 1803 1804 #if YYDEBUG 1805 #include <stdio.h> /* needed for printf */ 1806 #endif 1807 1808 #include <stdlib.h> /* needed for malloc, etc */ 1809 #include <string.h> /* needed for memset */ 1810 1811 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 1812 static int yygrowstack(YYSTACKDATA *data) 1813 { 1814 int i; 1815 unsigned newsize; 1816 YYINT *newss; 1817 YYSTYPE *newvs; 1818 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1819 YYLTYPE *newps; 1820 #endif 1821 1822 if ((newsize = data->stacksize) == 0) 1823 newsize = YYINITSTACKSIZE; 1824 else if (newsize >= YYMAXDEPTH) 1825 return YYENOMEM; 1826 else if ((newsize *= 2) > YYMAXDEPTH) 1827 newsize = YYMAXDEPTH; 1828 1829 i = (int) (data->s_mark - data->s_base); 1830 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 1831 if (newss == NULL) 1832 return YYENOMEM; 1833 1834 data->s_base = newss; 1835 data->s_mark = newss + i; 1836 1837 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 1838 if (newvs == NULL) 1839 return YYENOMEM; 1840 1841 data->l_base = newvs; 1842 data->l_mark = newvs + i; 1843 1844 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1845 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 1846 if (newps == NULL) 1847 return YYENOMEM; 1848 1849 data->p_base = newps; 1850 data->p_mark = newps + i; 1851 #endif 1852 1853 data->stacksize = newsize; 1854 data->s_last = data->s_base + newsize - 1; 1855 1856 #if YYDEBUG 1857 if (yydebug) 1858 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 1859 #endif 1860 return 0; 1861 } 1862 1863 #if YYPURE || defined(YY_NO_LEAKS) 1864 static void yyfreestack(YYSTACKDATA *data) 1865 { 1866 free(data->s_base); 1867 free(data->l_base); 1868 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1869 free(data->p_base); 1870 #endif 1871 memset(data, 0, sizeof(*data)); 1872 } 1873 #else 1874 #define yyfreestack(data) /* nothing */ 1875 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 1876 #if YYBTYACC 1877 1878 static YYParseState * 1879 yyNewState(unsigned size) 1880 { 1881 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 1882 if (p == NULL) return NULL; 1883 1884 p->yystack.stacksize = size; 1885 if (size == 0) 1886 { 1887 p->yystack.s_base = NULL; 1888 p->yystack.l_base = NULL; 1889 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1890 p->yystack.p_base = NULL; 1891 #endif 1892 return p; 1893 } 1894 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 1895 if (p->yystack.s_base == NULL) return NULL; 1896 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 1897 if (p->yystack.l_base == NULL) return NULL; 1898 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 1899 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1900 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 1901 if (p->yystack.p_base == NULL) return NULL; 1902 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 1903 #endif 1904 1905 return p; 1906 } 1907 1908 static void 1909 yyFreeState(YYParseState *p) 1910 { 1911 yyfreestack(&p->yystack); 1912 free(p); 1913 } 1914 #endif /* YYBTYACC */ 1915 1916 #define YYABORT goto yyabort 1917 #define YYREJECT goto yyabort 1918 #define YYACCEPT goto yyaccept 1919 #define YYERROR goto yyerrlab 1920 #if YYBTYACC 1921 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 1922 #define YYVALID_NESTED do { if (yyps->save && \ 1923 yyps->save->save == 0) goto yyvalid; } while(0) 1924 #endif /* YYBTYACC */ 1925 1926 int 1927 YYPARSE_DECL() 1928 { 1929 int yym, yyn, yystate, yyresult; 1930 #if YYBTYACC 1931 int yynewerrflag; 1932 YYParseState *yyerrctx = NULL; 1933 #endif /* YYBTYACC */ 1934 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1935 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */ 1936 #endif 1937 #if YYDEBUG 1938 const char *yys; 1939 1940 if ((yys = getenv("YYDEBUG")) != NULL) 1941 { 1942 yyn = *yys; 1943 if (yyn >= '0' && yyn <= '9') 1944 yydebug = yyn - '0'; 1945 } 1946 if (yydebug) 1947 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 1948 #endif 1949 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1950 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 1951 #endif 1952 1953 #if YYBTYACC 1954 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 1955 yyps->save = 0; 1956 #endif /* YYBTYACC */ 1957 yym = 0; 1958 yyn = 0; 1959 yynerrs = 0; 1960 yyerrflag = 0; 1961 yychar = YYEMPTY; 1962 yystate = 0; 1963 1964 #if YYPURE 1965 memset(&yystack, 0, sizeof(yystack)); 1966 #endif 1967 1968 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1969 yystack.s_mark = yystack.s_base; 1970 yystack.l_mark = yystack.l_base; 1971 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1972 yystack.p_mark = yystack.p_base; 1973 #endif 1974 yystate = 0; 1975 *yystack.s_mark = 0; 1976 1977 yyloop: 1978 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 1979 if (yychar < 0) 1980 { 1981 #if YYBTYACC 1982 do { 1983 if (yylvp < yylve) 1984 { 1985 /* we're currently re-reading tokens */ 1986 yylval = *yylvp++; 1987 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1988 yylloc = *yylpp++; 1989 #endif 1990 yychar = *yylexp++; 1991 break; 1992 } 1993 if (yyps->save) 1994 { 1995 /* in trial mode; save scanner results for future parse attempts */ 1996 if (yylvp == yylvlim) 1997 { /* Enlarge lexical value queue */ 1998 size_t p = (size_t) (yylvp - yylvals); 1999 size_t s = (size_t) (yylvlim - yylvals); 2000 2001 s += YYLVQUEUEGROWTH; 2002 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 2003 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 2004 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2005 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 2006 #endif 2007 yylvp = yylve = yylvals + p; 2008 yylvlim = yylvals + s; 2009 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2010 yylpp = yylpe = yylpsns + p; 2011 yylplim = yylpsns + s; 2012 #endif 2013 yylexp = yylexemes + p; 2014 } 2015 *yylexp = (YYINT) YYLEX; 2016 *yylvp++ = yylval; 2017 yylve++; 2018 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2019 *yylpp++ = yylloc; 2020 yylpe++; 2021 #endif 2022 yychar = *yylexp++; 2023 break; 2024 } 2025 /* normal operation, no conflict encountered */ 2026 #endif /* YYBTYACC */ 2027 yychar = YYLEX; 2028 #if YYBTYACC 2029 } while (0); 2030 #endif /* YYBTYACC */ 2031 if (yychar < 0) yychar = YYEOF; 2032 #if YYDEBUG 2033 if (yydebug) 2034 { 2035 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 2036 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 2037 YYDEBUGSTR, yydepth, yystate, yychar, yys); 2038 #ifdef YYSTYPE_TOSTRING 2039 #if YYBTYACC 2040 if (!yytrial) 2041 #endif /* YYBTYACC */ 2042 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 2043 #endif 2044 fputc('\n', stderr); 2045 } 2046 #endif 2047 } 2048 #if YYBTYACC 2049 2050 /* Do we have a conflict? */ 2051 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 2052 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 2053 { 2054 YYINT ctry; 2055 2056 if (yypath) 2057 { 2058 YYParseState *save; 2059 #if YYDEBUG 2060 if (yydebug) 2061 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 2062 YYDEBUGSTR, yydepth, yystate); 2063 #endif 2064 /* Switch to the next conflict context */ 2065 save = yypath; 2066 yypath = save->save; 2067 save->save = NULL; 2068 ctry = save->ctry; 2069 if (save->state != yystate) YYABORT; 2070 yyFreeState(save); 2071 2072 } 2073 else 2074 { 2075 2076 /* Unresolved conflict - start/continue trial parse */ 2077 YYParseState *save; 2078 #if YYDEBUG 2079 if (yydebug) 2080 { 2081 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 2082 if (yyps->save) 2083 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 2084 else 2085 fputs("Starting trial parse.\n", stderr); 2086 } 2087 #endif 2088 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 2089 if (save == NULL) goto yyenomem; 2090 save->save = yyps->save; 2091 save->state = yystate; 2092 save->errflag = yyerrflag; 2093 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 2094 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 2095 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 2096 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 2097 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2098 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 2099 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 2100 #endif 2101 ctry = yytable[yyn]; 2102 if (yyctable[ctry] == -1) 2103 { 2104 #if YYDEBUG 2105 if (yydebug && yychar >= YYEOF) 2106 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 2107 #endif 2108 ctry++; 2109 } 2110 save->ctry = ctry; 2111 if (yyps->save == NULL) 2112 { 2113 /* If this is a first conflict in the stack, start saving lexemes */ 2114 if (!yylexemes) 2115 { 2116 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 2117 if (yylexemes == NULL) goto yyenomem; 2118 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 2119 if (yylvals == NULL) goto yyenomem; 2120 yylvlim = yylvals + YYLVQUEUEGROWTH; 2121 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2122 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 2123 if (yylpsns == NULL) goto yyenomem; 2124 yylplim = yylpsns + YYLVQUEUEGROWTH; 2125 #endif 2126 } 2127 if (yylvp == yylve) 2128 { 2129 yylvp = yylve = yylvals; 2130 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2131 yylpp = yylpe = yylpsns; 2132 #endif 2133 yylexp = yylexemes; 2134 if (yychar >= YYEOF) 2135 { 2136 *yylve++ = yylval; 2137 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2138 *yylpe++ = yylloc; 2139 #endif 2140 *yylexp = (YYINT) yychar; 2141 yychar = YYEMPTY; 2142 } 2143 } 2144 } 2145 if (yychar >= YYEOF) 2146 { 2147 yylvp--; 2148 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2149 yylpp--; 2150 #endif 2151 yylexp--; 2152 yychar = YYEMPTY; 2153 } 2154 save->lexeme = (int) (yylvp - yylvals); 2155 yyps->save = save; 2156 } 2157 if (yytable[yyn] == ctry) 2158 { 2159 #if YYDEBUG 2160 if (yydebug) 2161 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 2162 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 2163 #endif 2164 if (yychar < 0) 2165 { 2166 yylvp++; 2167 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2168 yylpp++; 2169 #endif 2170 yylexp++; 2171 } 2172 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 2173 goto yyoverflow; 2174 yystate = yyctable[ctry]; 2175 *++yystack.s_mark = (YYINT) yystate; 2176 *++yystack.l_mark = yylval; 2177 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2178 *++yystack.p_mark = yylloc; 2179 #endif 2180 yychar = YYEMPTY; 2181 if (yyerrflag > 0) --yyerrflag; 2182 goto yyloop; 2183 } 2184 else 2185 { 2186 yyn = yyctable[ctry]; 2187 goto yyreduce; 2188 } 2189 } /* End of code dealing with conflicts */ 2190 #endif /* YYBTYACC */ 2191 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 2192 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 2193 { 2194 #if YYDEBUG 2195 if (yydebug) 2196 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 2197 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 2198 #endif 2199 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 2200 yystate = yytable[yyn]; 2201 *++yystack.s_mark = yytable[yyn]; 2202 *++yystack.l_mark = yylval; 2203 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2204 *++yystack.p_mark = yylloc; 2205 #endif 2206 yychar = YYEMPTY; 2207 if (yyerrflag > 0) --yyerrflag; 2208 goto yyloop; 2209 } 2210 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 2211 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 2212 { 2213 yyn = yytable[yyn]; 2214 goto yyreduce; 2215 } 2216 if (yyerrflag != 0) goto yyinrecovery; 2217 #if YYBTYACC 2218 2219 yynewerrflag = 1; 2220 goto yyerrhandler; 2221 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 2222 2223 yyerrlab: 2224 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 2225 * before looking for error recovery */ 2226 yystack.s_mark -= yym; 2227 yystate = *yystack.s_mark; 2228 yystack.l_mark -= yym; 2229 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2230 yystack.p_mark -= yym; 2231 #endif 2232 2233 yynewerrflag = 0; 2234 yyerrhandler: 2235 while (yyps->save) 2236 { 2237 int ctry; 2238 YYParseState *save = yyps->save; 2239 #if YYDEBUG 2240 if (yydebug) 2241 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 2242 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 2243 (int)(yylvp - yylvals - yyps->save->lexeme)); 2244 #endif 2245 /* Memorize most forward-looking error state in case it's really an error. */ 2246 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 2247 { 2248 /* Free old saved error context state */ 2249 if (yyerrctx) yyFreeState(yyerrctx); 2250 /* Create and fill out new saved error context state */ 2251 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 2252 if (yyerrctx == NULL) goto yyenomem; 2253 yyerrctx->save = yyps->save; 2254 yyerrctx->state = yystate; 2255 yyerrctx->errflag = yyerrflag; 2256 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 2257 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 2258 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 2259 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 2260 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2261 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 2262 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 2263 #endif 2264 yyerrctx->lexeme = (int) (yylvp - yylvals); 2265 } 2266 yylvp = yylvals + save->lexeme; 2267 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2268 yylpp = yylpsns + save->lexeme; 2269 #endif 2270 yylexp = yylexemes + save->lexeme; 2271 yychar = YYEMPTY; 2272 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 2273 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 2274 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 2275 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 2276 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2277 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 2278 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 2279 #endif 2280 ctry = ++save->ctry; 2281 yystate = save->state; 2282 /* We tried shift, try reduce now */ 2283 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 2284 yyps->save = save->save; 2285 save->save = NULL; 2286 yyFreeState(save); 2287 2288 /* Nothing left on the stack -- error */ 2289 if (!yyps->save) 2290 { 2291 #if YYDEBUG 2292 if (yydebug) 2293 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 2294 YYPREFIX, yydepth); 2295 #endif 2296 /* Restore state as it was in the most forward-advanced error */ 2297 yylvp = yylvals + yyerrctx->lexeme; 2298 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2299 yylpp = yylpsns + yyerrctx->lexeme; 2300 #endif 2301 yylexp = yylexemes + yyerrctx->lexeme; 2302 yychar = yylexp[-1]; 2303 yylval = yylvp[-1]; 2304 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2305 yylloc = yylpp[-1]; 2306 #endif 2307 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 2308 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 2309 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 2310 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 2311 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2312 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 2313 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 2314 #endif 2315 yystate = yyerrctx->state; 2316 yyFreeState(yyerrctx); 2317 yyerrctx = NULL; 2318 } 2319 yynewerrflag = 1; 2320 } 2321 if (yynewerrflag == 0) goto yyinrecovery; 2322 #endif /* YYBTYACC */ 2323 2324 YYERROR_CALL("syntax error"); 2325 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2326 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */ 2327 #endif 2328 2329 #if !YYBTYACC 2330 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 2331 yyerrlab: 2332 #endif 2333 ++yynerrs; 2334 2335 yyinrecovery: 2336 if (yyerrflag < 3) 2337 { 2338 yyerrflag = 3; 2339 for (;;) 2340 { 2341 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 2342 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 2343 { 2344 #if YYDEBUG 2345 if (yydebug) 2346 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 2347 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 2348 #endif 2349 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 2350 yystate = yytable[yyn]; 2351 *++yystack.s_mark = yytable[yyn]; 2352 *++yystack.l_mark = yylval; 2353 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2354 /* lookahead position is error end position */ 2355 yyerror_loc_range[2] = yylloc; 2356 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 2357 *++yystack.p_mark = yyloc; 2358 #endif 2359 goto yyloop; 2360 } 2361 else 2362 { 2363 #if YYDEBUG 2364 if (yydebug) 2365 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 2366 YYDEBUGSTR, yydepth, *yystack.s_mark); 2367 #endif 2368 if (yystack.s_mark <= yystack.s_base) goto yyabort; 2369 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2370 /* the current TOS position is the error start position */ 2371 yyerror_loc_range[1] = *yystack.p_mark; 2372 #endif 2373 #if defined(YYDESTRUCT_CALL) 2374 #if YYBTYACC 2375 if (!yytrial) 2376 #endif /* YYBTYACC */ 2377 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2378 YYDESTRUCT_CALL("error: discarding state", 2379 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 2380 #else 2381 YYDESTRUCT_CALL("error: discarding state", 2382 yystos[*yystack.s_mark], yystack.l_mark); 2383 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 2384 #endif /* defined(YYDESTRUCT_CALL) */ 2385 --yystack.s_mark; 2386 --yystack.l_mark; 2387 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2388 --yystack.p_mark; 2389 #endif 2390 } 2391 } 2392 } 2393 else 2394 { 2395 if (yychar == YYEOF) goto yyabort; 2396 #if YYDEBUG 2397 if (yydebug) 2398 { 2399 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 2400 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 2401 YYDEBUGSTR, yydepth, yystate, yychar, yys); 2402 } 2403 #endif 2404 #if defined(YYDESTRUCT_CALL) 2405 #if YYBTYACC 2406 if (!yytrial) 2407 #endif /* YYBTYACC */ 2408 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2409 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 2410 #else 2411 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 2412 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 2413 #endif /* defined(YYDESTRUCT_CALL) */ 2414 yychar = YYEMPTY; 2415 goto yyloop; 2416 } 2417 2418 yyreduce: 2419 yym = yylen[yyn]; 2420 #if YYDEBUG 2421 if (yydebug) 2422 { 2423 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 2424 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 2425 #ifdef YYSTYPE_TOSTRING 2426 #if YYBTYACC 2427 if (!yytrial) 2428 #endif /* YYBTYACC */ 2429 if (yym > 0) 2430 { 2431 int i; 2432 fputc('<', stderr); 2433 for (i = yym; i > 0; i--) 2434 { 2435 if (i != yym) fputs(", ", stderr); 2436 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 2437 yystack.l_mark[1-i]), stderr); 2438 } 2439 fputc('>', stderr); 2440 } 2441 #endif 2442 fputc('\n', stderr); 2443 } 2444 #endif 2445 if (yym > 0) 2446 yyval = yystack.l_mark[1-yym]; 2447 else 2448 memset(&yyval, 0, sizeof yyval); 2449 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2450 2451 /* Perform position reduction */ 2452 memset(&yyloc, 0, sizeof(yyloc)); 2453 #if YYBTYACC 2454 if (!yytrial) 2455 #endif /* YYBTYACC */ 2456 { 2457 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym); 2458 /* just in case YYERROR is invoked within the action, save 2459 the start of the rhs as the error start position */ 2460 yyerror_loc_range[1] = yystack.p_mark[1-yym]; 2461 } 2462 #endif 2463 2464 switch (yyn) 2465 { 2466 case 1: 2467 #line 64 "expr.oxout.y" 2468 {yyyYoxInit();} 2469 break; 2470 case 2: 2471 #line 66 "expr.oxout.y" 2472 { 2473 yyyDecorate(); yyyExecuteRRsection(yystack.l_mark[0].yyyOxAttrbs.yyyOxStackItem->node); 2474 } 2475 break; 2476 case 3: 2477 #line 73 "expr.oxout.y" 2478 {if(yyyYok){ 2479 yyyGenIntNode(1,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 2480 yyyAdjustINRC(1,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 2481 break; 2482 case 4: 2483 #line 80 "expr.oxout.y" 2484 {if(yyyYok){ 2485 yyyGenIntNode(2,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 2486 yyyAdjustINRC(2,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 2487 break; 2488 case 5: 2489 #line 87 "expr.oxout.y" 2490 {if(yyyYok){ 2491 yyyGenIntNode(3,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 2492 yyyAdjustINRC(3,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 2493 break; 2494 case 6: 2495 #line 94 "expr.oxout.y" 2496 {if(yyyYok){ 2497 yyyGenIntNode(4,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 2498 yyyAdjustINRC(4,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 2499 break; 2500 case 7: 2501 #line 101 "expr.oxout.y" 2502 {if(yyyYok){ 2503 yyyGenIntNode(5,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 2504 yyyAdjustINRC(5,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 2505 break; 2506 case 8: 2507 #line 108 "expr.oxout.y" 2508 {if(yyyYok){ 2509 yyyGenIntNode(6,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 2510 yyyAdjustINRC(6,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 2511 break; 2512 case 9: 2513 #line 114 "expr.oxout.y" 2514 {if(yyyYok){ 2515 yyyGenIntNode(7,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 2516 yyyAdjustINRC(7,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 2517 break; 2518 case 10: 2519 #line 121 "expr.oxout.y" 2520 {if(yyyYok){ 2521 yyyGenIntNode(8,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs); 2522 yyyAdjustINRC(8,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}} 2523 break; 2524 #line 2525 "expr.oxout.tab.c" 2525 default: 2526 break; 2527 } 2528 yystack.s_mark -= yym; 2529 yystate = *yystack.s_mark; 2530 yystack.l_mark -= yym; 2531 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2532 yystack.p_mark -= yym; 2533 #endif 2534 yym = yylhs[yyn]; 2535 if (yystate == 0 && yym == 0) 2536 { 2537 #if YYDEBUG 2538 if (yydebug) 2539 { 2540 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 2541 #ifdef YYSTYPE_TOSTRING 2542 #if YYBTYACC 2543 if (!yytrial) 2544 #endif /* YYBTYACC */ 2545 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 2546 #endif 2547 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 2548 } 2549 #endif 2550 yystate = YYFINAL; 2551 *++yystack.s_mark = YYFINAL; 2552 *++yystack.l_mark = yyval; 2553 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2554 *++yystack.p_mark = yyloc; 2555 #endif 2556 if (yychar < 0) 2557 { 2558 #if YYBTYACC 2559 do { 2560 if (yylvp < yylve) 2561 { 2562 /* we're currently re-reading tokens */ 2563 yylval = *yylvp++; 2564 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2565 yylloc = *yylpp++; 2566 #endif 2567 yychar = *yylexp++; 2568 break; 2569 } 2570 if (yyps->save) 2571 { 2572 /* in trial mode; save scanner results for future parse attempts */ 2573 if (yylvp == yylvlim) 2574 { /* Enlarge lexical value queue */ 2575 size_t p = (size_t) (yylvp - yylvals); 2576 size_t s = (size_t) (yylvlim - yylvals); 2577 2578 s += YYLVQUEUEGROWTH; 2579 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 2580 goto yyenomem; 2581 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 2582 goto yyenomem; 2583 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2584 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 2585 goto yyenomem; 2586 #endif 2587 yylvp = yylve = yylvals + p; 2588 yylvlim = yylvals + s; 2589 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2590 yylpp = yylpe = yylpsns + p; 2591 yylplim = yylpsns + s; 2592 #endif 2593 yylexp = yylexemes + p; 2594 } 2595 *yylexp = (YYINT) YYLEX; 2596 *yylvp++ = yylval; 2597 yylve++; 2598 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2599 *yylpp++ = yylloc; 2600 yylpe++; 2601 #endif 2602 yychar = *yylexp++; 2603 break; 2604 } 2605 /* normal operation, no conflict encountered */ 2606 #endif /* YYBTYACC */ 2607 yychar = YYLEX; 2608 #if YYBTYACC 2609 } while (0); 2610 #endif /* YYBTYACC */ 2611 if (yychar < 0) yychar = YYEOF; 2612 #if YYDEBUG 2613 if (yydebug) 2614 { 2615 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 2616 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 2617 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 2618 } 2619 #endif 2620 } 2621 if (yychar == YYEOF) goto yyaccept; 2622 goto yyloop; 2623 } 2624 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 2625 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 2626 yystate = yytable[yyn]; 2627 else 2628 yystate = yydgoto[yym]; 2629 #if YYDEBUG 2630 if (yydebug) 2631 { 2632 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 2633 #ifdef YYSTYPE_TOSTRING 2634 #if YYBTYACC 2635 if (!yytrial) 2636 #endif /* YYBTYACC */ 2637 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 2638 #endif 2639 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 2640 } 2641 #endif 2642 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 2643 *++yystack.s_mark = (YYINT) yystate; 2644 *++yystack.l_mark = yyval; 2645 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2646 *++yystack.p_mark = yyloc; 2647 #endif 2648 goto yyloop; 2649 #if YYBTYACC 2650 2651 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 2652 yyvalid: 2653 if (yypath) YYABORT; 2654 while (yyps->save) 2655 { 2656 YYParseState *save = yyps->save; 2657 yyps->save = save->save; 2658 save->save = yypath; 2659 yypath = save; 2660 } 2661 #if YYDEBUG 2662 if (yydebug) 2663 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 2664 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 2665 #endif 2666 if (yyerrctx) 2667 { 2668 yyFreeState(yyerrctx); 2669 yyerrctx = NULL; 2670 } 2671 yylvp = yylvals + yypath->lexeme; 2672 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2673 yylpp = yylpsns + yypath->lexeme; 2674 #endif 2675 yylexp = yylexemes + yypath->lexeme; 2676 yychar = YYEMPTY; 2677 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 2678 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 2679 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 2680 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 2681 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2682 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 2683 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 2684 #endif 2685 yystate = yypath->state; 2686 goto yyloop; 2687 #endif /* YYBTYACC */ 2688 2689 yyoverflow: 2690 YYERROR_CALL("yacc stack overflow"); 2691 #if YYBTYACC 2692 goto yyabort_nomem; 2693 yyenomem: 2694 YYERROR_CALL("memory exhausted"); 2695 yyabort_nomem: 2696 #endif /* YYBTYACC */ 2697 yyresult = 2; 2698 goto yyreturn; 2699 2700 yyabort: 2701 yyresult = 1; 2702 goto yyreturn; 2703 2704 yyaccept: 2705 #if YYBTYACC 2706 if (yyps->save) goto yyvalid; 2707 #endif /* YYBTYACC */ 2708 yyresult = 0; 2709 2710 yyreturn: 2711 #if defined(YYDESTRUCT_CALL) 2712 if (yychar != YYEOF && yychar != YYEMPTY) 2713 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2714 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 2715 #else 2716 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 2717 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 2718 2719 { 2720 YYSTYPE *pv; 2721 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 2722 YYLTYPE *pp; 2723 2724 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 2725 YYDESTRUCT_CALL("cleanup: discarding state", 2726 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 2727 #else 2728 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 2729 YYDESTRUCT_CALL("cleanup: discarding state", 2730 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 2731 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 2732 } 2733 #endif /* defined(YYDESTRUCT_CALL) */ 2734 2735 #if YYBTYACC 2736 if (yyerrctx) 2737 { 2738 yyFreeState(yyerrctx); 2739 yyerrctx = NULL; 2740 } 2741 while (yyps) 2742 { 2743 YYParseState *save = yyps; 2744 yyps = save->save; 2745 save->save = NULL; 2746 yyFreeState(save); 2747 } 2748 while (yypath) 2749 { 2750 YYParseState *save = yypath; 2751 yypath = save->save; 2752 save->save = NULL; 2753 yyFreeState(save); 2754 } 2755 #endif /* YYBTYACC */ 2756 yyfreestack(&yystack); 2757 return (yyresult); 2758 } 2759