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