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