calc2.tab.c revision 1.7
1 /* $NetBSD: calc2.tab.c,v 1.7 2026/01/18 16:41:29 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 2 9 #define YYMINOR 0 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 calc2_parse 24 #endif /* yyparse */ 25 26 #ifndef yylex 27 #define yylex calc2_lex 28 #endif /* yylex */ 29 30 #ifndef yyerror 31 #define yyerror calc2_error 32 #endif /* yyerror */ 33 34 #ifndef yychar 35 #define yychar calc2_char 36 #endif /* yychar */ 37 38 #ifndef yyval 39 #define yyval calc2_val 40 #endif /* yyval */ 41 42 #ifndef yylval 43 #define yylval calc2_lval 44 #endif /* yylval */ 45 46 #ifndef yydebug 47 #define yydebug calc2_debug 48 #endif /* yydebug */ 49 50 #ifndef yynerrs 51 #define yynerrs calc2_nerrs 52 #endif /* yynerrs */ 53 54 #ifndef yyerrflag 55 #define yyerrflag calc2_errflag 56 #endif /* yyerrflag */ 57 58 #ifndef yylhs 59 #define yylhs calc2_lhs 60 #endif /* yylhs */ 61 62 #ifndef yylen 63 #define yylen calc2_len 64 #endif /* yylen */ 65 66 #ifndef yydefred 67 #define yydefred calc2_defred 68 #endif /* yydefred */ 69 70 #ifndef yystos 71 #define yystos calc2_stos 72 #endif /* yystos */ 73 74 #ifndef yydgoto 75 #define yydgoto calc2_dgoto 76 #endif /* yydgoto */ 77 78 #ifndef yysindex 79 #define yysindex calc2_sindex 80 #endif /* yysindex */ 81 82 #ifndef yyrindex 83 #define yyrindex calc2_rindex 84 #endif /* yyrindex */ 85 86 #ifndef yygindex 87 #define yygindex calc2_gindex 88 #endif /* yygindex */ 89 90 #ifndef yytable 91 #define yytable calc2_table 92 #endif /* yytable */ 93 94 #ifndef yycheck 95 #define yycheck calc2_check 96 #endif /* yycheck */ 97 98 #ifndef yyname 99 #define yyname calc2_name 100 #endif /* yyname */ 101 102 #ifndef yyrule 103 #define yyrule calc2_rule 104 #endif /* yyrule */ 105 106 #if YYBTYACC 107 108 #ifndef yycindex 109 #define yycindex calc2_cindex 110 #endif /* yycindex */ 111 112 #ifndef yyctable 113 #define yyctable calc2_ctable 114 #endif /* yyctable */ 115 116 #endif /* YYBTYACC */ 117 118 #define YYPREFIX "calc2_" 119 120 #define YYPURE 0 121 122 #line 7 "calc2.y" 123 # include <stdio.h> 124 # include <ctype.h> 125 126 #ifdef YYBISON 127 #define YYLEX_PARAM base 128 #define YYLEX_DECL() yylex(int *YYLEX_PARAM) 129 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s) 130 int YYLEX_DECL(); 131 static void YYERROR_DECL(); 132 #endif 133 134 #line 133 "calc2.tab.c" 135 136 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED) 137 /* Default: YYSTYPE is the semantic value type. */ 138 typedef int YYSTYPE; 139 # define YYSTYPE_IS_DECLARED 1 140 #endif 141 142 /* compatibility with bison */ 143 #ifdef YYPARSE_PARAM 144 /* compatibility with FreeBSD */ 145 # ifdef YYPARSE_PARAM_TYPE 146 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 147 # else 148 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 149 # endif 150 #else 151 # define YYPARSE_DECL() yyparse(int regs[26], int *base) 152 #endif 153 154 /* Parameters sent to lex. */ 155 #ifdef YYLEX_PARAM 156 # define YYLEX_DECL() yylex(void *YYLEX_PARAM) 157 # define YYLEX yylex(YYLEX_PARAM) 158 #else 159 # define YYLEX_DECL() yylex(int *base) 160 # define YYLEX yylex(base) 161 #endif 162 163 /* Parameters sent to yyerror. */ 164 #ifndef YYERROR_DECL 165 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s) 166 #endif 167 #ifndef YYERROR_CALL 168 #define YYERROR_CALL(msg) yyerror(regs, base, msg) 169 #endif 170 171 extern int YYPARSE_DECL(); 172 173 #define DIGIT 257 174 #define LETTER 258 175 #define UMINUS 259 176 #define YYERRCODE 256 177 typedef int YYINT; 178 static const YYINT calc2_lhs[] = { -1, 179 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 180 2, 2, 2, 2, 2, 2, 3, 3, 181 }; 182 static const YYINT calc2_len[] = { 2, 183 0, 3, 3, 1, 3, 3, 3, 3, 3, 3, 184 3, 3, 3, 2, 1, 1, 1, 2, 185 }; 186 static const YYINT calc2_defred[] = { 1, 187 0, 0, 17, 0, 0, 0, 0, 0, 0, 3, 188 0, 15, 14, 0, 2, 0, 0, 0, 0, 0, 189 0, 0, 18, 0, 6, 0, 0, 0, 0, 9, 190 10, 11, 191 }; 192 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) 193 static const YYINT calc2_stos[] = { 0, 194 261, 256, 257, 258, 45, 40, 262, 263, 264, 10, 195 61, 258, 263, 263, 10, 124, 38, 43, 45, 42, 196 47, 37, 257, 263, 41, 263, 263, 263, 263, 263, 197 263, 263, 198 }; 199 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ 200 static const YYINT calc2_dgoto[] = { 1, 201 7, 8, 9, 202 }; 203 static const YYINT calc2_sindex[] = { 0, 204 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0, 205 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38, 206 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0, 207 0, 0, 208 }; 209 static const YYINT calc2_rindex[] = { 0, 210 0, 0, 0, 2, 0, 0, 0, 9, -9, 0, 211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 212 0, 0, 0, 10, 0, -6, 14, 5, 13, 0, 213 0, 0, 214 }; 215 #if YYBTYACC 216 static const YYINT calc2_cindex[] = { 0, 217 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 218 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 220 0, 0, 221 }; 222 #endif 223 static const YYINT calc2_gindex[] = { 0, 224 0, 65, 0, 225 }; 226 #define YYTABLESIZE 220 227 static const YYINT calc2_table[] = { 6, 228 16, 6, 10, 13, 5, 11, 5, 22, 17, 23, 229 15, 15, 20, 18, 7, 19, 22, 21, 4, 5, 230 0, 20, 8, 12, 0, 0, 21, 16, 16, 0, 231 0, 16, 16, 16, 13, 16, 0, 16, 15, 15, 232 0, 0, 7, 15, 15, 7, 15, 7, 15, 7, 233 8, 12, 0, 8, 12, 8, 0, 8, 22, 17, 234 0, 0, 25, 20, 18, 0, 19, 0, 21, 13, 235 14, 0, 0, 0, 0, 24, 0, 0, 0, 0, 236 26, 27, 28, 29, 30, 31, 32, 22, 17, 0, 237 0, 0, 20, 18, 16, 19, 22, 21, 0, 0, 238 0, 20, 18, 0, 19, 0, 21, 0, 0, 0, 239 0, 0, 0, 0, 16, 0, 0, 13, 0, 0, 240 0, 0, 0, 0, 0, 15, 0, 0, 7, 0, 241 0, 0, 0, 0, 0, 0, 8, 12, 0, 0, 242 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 245 0, 0, 0, 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, 2, 3, 4, 3, 12, 250 }; 251 static const YYINT calc2_check[] = { 40, 252 10, 40, 10, 10, 45, 61, 45, 37, 38, 257, 253 10, 10, 42, 43, 10, 45, 37, 47, 10, 10, 254 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1, 255 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38, 256 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45, 257 38, 38, -1, 41, 41, 43, -1, 45, 37, 38, 258 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5, 259 6, -1, -1, -1, -1, 11, -1, -1, -1, -1, 260 16, 17, 18, 19, 20, 21, 22, 37, 38, -1, 261 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1, 262 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1, 263 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1, 264 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1, 265 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1, 266 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1, 267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 268 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 269 -1, -1, -1, -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, 256, 257, 258, 257, 258, 274 }; 275 #if YYBTYACC 276 static const YYINT calc2_ctable[] = { -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, -1, -1, -1, -1, 288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -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, 299 }; 300 #endif 301 #define YYFINAL 1 302 #ifndef YYDEBUG 303 #define YYDEBUG 0 304 #endif 305 #define YYMAXTOKEN 259 306 #define YYUNDFTOKEN 265 307 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 308 #if YYDEBUG 309 #ifndef NULL 310 #define NULL (void*)0 311 #endif 312 static const char *const calc2_name[] = { 313 314 "$end",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,"'\\n'",NULL,NULL,NULL,NULL, 315 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 316 NULL,NULL,NULL,NULL,NULL,NULL,"'%'","'&'",NULL,"'('","')'","'*'","'+'",NULL, 317 "'-'",NULL,"'/'",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 318 NULL,"'='",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 319 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 320 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 321 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 322 NULL,"'|'",NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 323 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 324 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 325 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 326 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 327 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 328 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 329 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, 330 NULL,NULL,NULL,NULL,NULL,NULL,"error","DIGIT","LETTER","UMINUS","$accept", 331 "list","stat","expr","number","illegal-symbol", 332 }; 333 static const char *const calc2_rule[] = { 334 "$accept : list", 335 "list :", 336 "list : list stat '\\n'", 337 "list : list error '\\n'", 338 "stat : expr", 339 "stat : LETTER '=' expr", 340 "expr : '(' expr ')'", 341 "expr : expr '+' expr", 342 "expr : expr '-' expr", 343 "expr : expr '*' expr", 344 "expr : expr '/' expr", 345 "expr : expr '%' expr", 346 "expr : expr '&' expr", 347 "expr : expr '|' expr", 348 "expr : '-' expr", 349 "expr : LETTER", 350 "expr : number", 351 "number : DIGIT", 352 "number : number DIGIT", 353 354 }; 355 #endif 356 357 #if YYDEBUG 358 int yydebug; 359 #endif 360 361 int yyerrflag; 362 int yychar; 363 YYSTYPE yyval; 364 YYSTYPE yylval; 365 int yynerrs; 366 367 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 368 YYLTYPE yyloc; /* position returned by actions */ 369 YYLTYPE yylloc; /* position from the lexer */ 370 #endif 371 372 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 373 #ifndef YYLLOC_DEFAULT 374 #define YYLLOC_DEFAULT(loc, rhs, n) \ 375 do \ 376 { \ 377 if (n == 0) \ 378 { \ 379 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \ 380 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \ 381 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \ 382 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \ 383 } \ 384 else \ 385 { \ 386 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \ 387 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \ 388 (loc).last_line = YYRHSLOC(rhs, n).last_line; \ 389 (loc).last_column = YYRHSLOC(rhs, n).last_column; \ 390 } \ 391 } while (0) 392 #endif /* YYLLOC_DEFAULT */ 393 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 394 #if YYBTYACC 395 396 #ifndef YYLVQUEUEGROWTH 397 #define YYLVQUEUEGROWTH 32 398 #endif 399 #endif /* YYBTYACC */ 400 401 /* define the initial stack-sizes */ 402 #ifdef YYSTACKSIZE 403 #undef YYMAXDEPTH 404 #define YYMAXDEPTH YYSTACKSIZE 405 #else 406 #ifdef YYMAXDEPTH 407 #define YYSTACKSIZE YYMAXDEPTH 408 #else 409 #define YYSTACKSIZE 10000 410 #define YYMAXDEPTH 10000 411 #endif 412 #endif 413 414 #ifndef YYINITSTACKSIZE 415 #define YYINITSTACKSIZE 200 416 #endif 417 418 typedef struct { 419 unsigned stacksize; 420 YYINT *s_base; 421 YYINT *s_mark; 422 YYINT *s_last; 423 YYSTYPE *l_base; 424 YYSTYPE *l_mark; 425 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 426 YYLTYPE *p_base; 427 YYLTYPE *p_mark; 428 #endif 429 } YYSTACKDATA; 430 #if YYBTYACC 431 432 struct YYParseState_s 433 { 434 struct YYParseState_s *save; /* Previously saved parser state */ 435 YYSTACKDATA yystack; /* saved parser stack */ 436 int state; /* saved parser state */ 437 int errflag; /* saved error recovery status */ 438 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 439 YYINT ctry; /* saved index in yyctable[] for this conflict */ 440 }; 441 typedef struct YYParseState_s YYParseState; 442 #endif /* YYBTYACC */ 443 /* variables for the parser stack */ 444 static YYSTACKDATA yystack; 445 #if YYBTYACC 446 447 /* Current parser state */ 448 static YYParseState *yyps = NULL; 449 450 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 451 static YYParseState *yypath = NULL; 452 453 /* Base of the lexical value queue */ 454 static YYSTYPE *yylvals = NULL; 455 456 /* Current position at lexical value queue */ 457 static YYSTYPE *yylvp = NULL; 458 459 /* End position of lexical value queue */ 460 static YYSTYPE *yylve = NULL; 461 462 /* The last allocated position at the lexical value queue */ 463 static YYSTYPE *yylvlim = NULL; 464 465 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 466 /* Base of the lexical position queue */ 467 static YYLTYPE *yylpsns = NULL; 468 469 /* Current position at lexical position queue */ 470 static YYLTYPE *yylpp = NULL; 471 472 /* End position of lexical position queue */ 473 static YYLTYPE *yylpe = NULL; 474 475 /* The last allocated position at the lexical position queue */ 476 static YYLTYPE *yylplim = NULL; 477 #endif 478 479 /* Current position at lexical token queue */ 480 static YYINT *yylexp = NULL; 481 482 static YYINT *yylexemes = NULL; 483 #endif /* YYBTYACC */ 484 #line 73 "calc2.y" 485 /* start of programs */ 486 487 #ifdef YYBYACC 488 extern int YYLEX_DECL(); 489 #endif 490 491 int 492 main (void) 493 { 494 int regs[26]; 495 int base = 10; 496 497 while(!feof(stdin)) { 498 yyparse(regs, &base); 499 } 500 return 0; 501 } 502 503 #define UNUSED(x) ((void)(x)) 504 505 static void 506 YYERROR_DECL() 507 { 508 UNUSED(regs); /* %parse-param regs is not actually used here */ 509 UNUSED(base); /* %parse-param base is not actually used here */ 510 fprintf(stderr, "%s\n", s); 511 } 512 513 int 514 YYLEX_DECL() 515 { 516 /* lexical analysis routine */ 517 /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 518 /* return DIGIT for a digit, yylval = 0 through 9 */ 519 /* all other characters are returned immediately */ 520 521 int c; 522 523 while( (c=getchar()) == ' ' ) { /* skip blanks */ } 524 525 /* c is now nonblank */ 526 527 if( islower( c )) { 528 yylval = c - 'a'; 529 return ( LETTER ); 530 } 531 if( isdigit( c )) { 532 yylval = (c - '0') % (*base); 533 return ( DIGIT ); 534 } 535 return( c ); 536 } 537 #line 536 "calc2.tab.c" 538 539 /* For use in generated program */ 540 #define yydepth (int)(yystack.s_mark - yystack.s_base) 541 #if YYBTYACC 542 #define yytrial (yyps->save) 543 #endif /* YYBTYACC */ 544 545 #if YYDEBUG 546 #include <stdio.h> /* needed for printf */ 547 #endif 548 549 #include <stdlib.h> /* needed for malloc, etc */ 550 #include <string.h> /* needed for memset */ 551 552 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 553 static int yygrowstack(YYSTACKDATA *data) 554 { 555 int i; 556 unsigned newsize; 557 YYINT *newss; 558 YYSTYPE *newvs; 559 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 560 YYLTYPE *newps; 561 #endif 562 563 if ((newsize = data->stacksize) == 0) 564 newsize = YYINITSTACKSIZE; 565 else if (newsize >= YYMAXDEPTH) 566 return YYENOMEM; 567 else if ((newsize *= 2) > YYMAXDEPTH) 568 newsize = YYMAXDEPTH; 569 570 i = (int) (data->s_mark - data->s_base); 571 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 572 if (newss == NULL) 573 return YYENOMEM; 574 575 data->s_base = newss; 576 data->s_mark = newss + i; 577 578 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 579 if (newvs == NULL) 580 return YYENOMEM; 581 582 data->l_base = newvs; 583 data->l_mark = newvs + i; 584 585 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 586 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 587 if (newps == NULL) 588 return YYENOMEM; 589 590 data->p_base = newps; 591 data->p_mark = newps + i; 592 #endif 593 594 data->stacksize = newsize; 595 data->s_last = data->s_base + newsize - 1; 596 597 #if YYDEBUG 598 if (yydebug) 599 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 600 #endif 601 return 0; 602 } 603 604 #if YYPURE || defined(YY_NO_LEAKS) 605 static void yyfreestack(YYSTACKDATA *data) 606 { 607 free(data->s_base); 608 free(data->l_base); 609 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 610 free(data->p_base); 611 #endif 612 memset(data, 0, sizeof(*data)); 613 } 614 #else 615 #define yyfreestack(data) /* nothing */ 616 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 617 #if YYBTYACC 618 619 static YYParseState * 620 yyNewState(unsigned size) 621 { 622 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 623 if (p == NULL) return NULL; 624 625 p->yystack.stacksize = size; 626 if (size == 0) 627 { 628 p->yystack.s_base = NULL; 629 p->yystack.l_base = NULL; 630 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 631 p->yystack.p_base = NULL; 632 #endif 633 return p; 634 } 635 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 636 if (p->yystack.s_base == NULL) return NULL; 637 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 638 if (p->yystack.l_base == NULL) return NULL; 639 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 640 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 641 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 642 if (p->yystack.p_base == NULL) return NULL; 643 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 644 #endif 645 646 return p; 647 } 648 649 static void 650 yyFreeState(YYParseState *p) 651 { 652 yyfreestack(&p->yystack); 653 free(p); 654 } 655 #endif /* YYBTYACC */ 656 657 #define YYABORT goto yyabort 658 #define YYREJECT goto yyabort 659 #define YYACCEPT goto yyaccept 660 #define YYERROR goto yyerrlab 661 #if YYBTYACC 662 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 663 #define YYVALID_NESTED do { if (yyps->save && \ 664 yyps->save->save == 0) goto yyvalid; } while(0) 665 #endif /* YYBTYACC */ 666 667 int 668 YYPARSE_DECL() 669 { 670 int yym, yyn, yystate, yyresult; 671 #if YYBTYACC 672 int yynewerrflag; 673 YYParseState *yyerrctx = NULL; 674 #endif /* YYBTYACC */ 675 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 676 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */ 677 #endif 678 #if YYDEBUG 679 const char *yys; 680 681 if ((yys = getenv("YYDEBUG")) != NULL) 682 { 683 yyn = *yys; 684 if (yyn >= '0' && yyn <= '9') 685 yydebug = yyn - '0'; 686 } 687 if (yydebug) 688 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 689 #endif 690 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 691 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 692 #endif 693 694 #if YYBTYACC 695 yyps = yyNewState(0); if (yyps == NULL) goto yyenomem; 696 yyps->save = NULL; 697 #endif /* YYBTYACC */ 698 yym = 0; 699 /* yyn is set below */ 700 yynerrs = 0; 701 yyerrflag = 0; 702 yychar = YYEMPTY; 703 yystate = 0; 704 705 #if YYPURE 706 memset(&yystack, 0, sizeof(yystack)); 707 #endif 708 709 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 710 yystack.s_mark = yystack.s_base; 711 yystack.l_mark = yystack.l_base; 712 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 713 yystack.p_mark = yystack.p_base; 714 #endif 715 yystate = 0; 716 *yystack.s_mark = 0; 717 718 yyloop: 719 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 720 if (yychar < 0) 721 { 722 #if YYBTYACC 723 do { 724 if (yylvp < yylve) 725 { 726 /* we're currently re-reading tokens */ 727 yylval = *yylvp++; 728 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 729 yylloc = *yylpp++; 730 #endif 731 yychar = *yylexp++; 732 break; 733 } 734 if (yyps->save) 735 { 736 /* in trial mode; save scanner results for future parse attempts */ 737 if (yylvp == yylvlim) 738 { /* Enlarge lexical value queue */ 739 size_t p = (size_t) (yylvp - yylvals); 740 size_t s = (size_t) (yylvlim - yylvals); 741 742 s += YYLVQUEUEGROWTH; 743 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 744 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 745 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 746 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 747 #endif 748 yylvp = yylve = yylvals + p; 749 yylvlim = yylvals + s; 750 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 751 yylpp = yylpe = yylpsns + p; 752 yylplim = yylpsns + s; 753 #endif 754 yylexp = yylexemes + p; 755 } 756 *yylexp = (YYINT) YYLEX; 757 *yylvp++ = yylval; 758 yylve++; 759 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 760 *yylpp++ = yylloc; 761 yylpe++; 762 #endif 763 yychar = *yylexp++; 764 break; 765 } 766 /* normal operation, no conflict encountered */ 767 #endif /* YYBTYACC */ 768 yychar = YYLEX; 769 #if YYBTYACC 770 } while (0); 771 #endif /* YYBTYACC */ 772 if (yychar < 0) yychar = YYEOF; 773 #if YYDEBUG 774 if (yydebug) 775 { 776 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 777 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 778 YYDEBUGSTR, yydepth, yystate, yychar, yys); 779 #ifdef YYSTYPE_TOSTRING 780 #if YYBTYACC 781 if (!yytrial) 782 #endif /* YYBTYACC */ 783 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 784 #endif 785 fputc('\n', stderr); 786 } 787 #endif 788 } 789 #if YYBTYACC 790 791 /* Do we have a conflict? */ 792 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 793 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 794 { 795 YYINT ctry; 796 797 if (yypath) 798 { 799 YYParseState *save; 800 #if YYDEBUG 801 if (yydebug) 802 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 803 YYDEBUGSTR, yydepth, yystate); 804 #endif 805 /* Switch to the next conflict context */ 806 save = yypath; 807 yypath = save->save; 808 save->save = NULL; 809 ctry = save->ctry; 810 if (save->state != yystate) YYABORT; 811 yyFreeState(save); 812 813 } 814 else 815 { 816 817 /* Unresolved conflict - start/continue trial parse */ 818 YYParseState *save; 819 #if YYDEBUG 820 if (yydebug) 821 { 822 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 823 if (yyps->save) 824 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 825 else 826 fputs("Starting trial parse.\n", stderr); 827 } 828 #endif 829 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 830 if (save == NULL) goto yyenomem; 831 save->save = yyps->save; 832 save->state = yystate; 833 save->errflag = yyerrflag; 834 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 835 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 836 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 837 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 838 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 839 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 840 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 841 #endif 842 ctry = yytable[yyn]; 843 if (yyctable[ctry] == -1) 844 { 845 #if YYDEBUG 846 if (yydebug && yychar >= YYEOF) 847 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 848 #endif 849 ctry++; 850 } 851 save->ctry = ctry; 852 if (yyps->save == NULL) 853 { 854 /* If this is a first conflict in the stack, start saving lexemes */ 855 if (!yylexemes) 856 { 857 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 858 if (yylexemes == NULL) goto yyenomem; 859 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 860 if (yylvals == NULL) goto yyenomem; 861 yylvlim = yylvals + YYLVQUEUEGROWTH; 862 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 863 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 864 if (yylpsns == NULL) goto yyenomem; 865 yylplim = yylpsns + YYLVQUEUEGROWTH; 866 #endif 867 } 868 if (yylvp == yylve) 869 { 870 yylvp = yylve = yylvals; 871 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 872 yylpp = yylpe = yylpsns; 873 #endif 874 yylexp = yylexemes; 875 if (yychar >= YYEOF) 876 { 877 *yylve++ = yylval; 878 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 879 *yylpe++ = yylloc; 880 #endif 881 *yylexp = (YYINT) yychar; 882 yychar = YYEMPTY; 883 } 884 } 885 } 886 if (yychar >= YYEOF) 887 { 888 yylvp--; 889 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 890 yylpp--; 891 #endif 892 yylexp--; 893 yychar = YYEMPTY; 894 } 895 save->lexeme = (int) (yylvp - yylvals); 896 yyps->save = save; 897 } 898 if (yytable[yyn] == ctry) 899 { 900 #if YYDEBUG 901 if (yydebug) 902 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 903 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 904 #endif 905 if (yychar < 0) 906 { 907 yylvp++; 908 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 909 yylpp++; 910 #endif 911 yylexp++; 912 } 913 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 914 goto yyoverflow; 915 yystate = yyctable[ctry]; 916 *++yystack.s_mark = (YYINT) yystate; 917 *++yystack.l_mark = yylval; 918 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 919 *++yystack.p_mark = yylloc; 920 #endif 921 yychar = YYEMPTY; 922 if (yyerrflag > 0) --yyerrflag; 923 goto yyloop; 924 } 925 else 926 { 927 yyn = yyctable[ctry]; 928 goto yyreduce; 929 } 930 } /* End of code dealing with conflicts */ 931 #endif /* YYBTYACC */ 932 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 933 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 934 { 935 #if YYDEBUG 936 if (yydebug) 937 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 938 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 939 #endif 940 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 941 yystate = yytable[yyn]; 942 *++yystack.s_mark = yytable[yyn]; 943 *++yystack.l_mark = yylval; 944 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 945 *++yystack.p_mark = yylloc; 946 #endif 947 yychar = YYEMPTY; 948 if (yyerrflag > 0) --yyerrflag; 949 goto yyloop; 950 } 951 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 952 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 953 { 954 yyn = yytable[yyn]; 955 goto yyreduce; 956 } 957 if (yyerrflag != 0) goto yyinrecovery; 958 #if YYBTYACC 959 960 yynewerrflag = 1; 961 goto yyerrhandler; 962 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 963 964 yyerrlab: 965 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 966 * before looking for error recovery */ 967 yystack.s_mark -= yym; 968 yystate = *yystack.s_mark; 969 yystack.l_mark -= yym; 970 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 971 yystack.p_mark -= yym; 972 #endif 973 974 yynewerrflag = 0; 975 yyerrhandler: 976 while (yyps->save) 977 { 978 int ctry; 979 YYParseState *save = yyps->save; 980 #if YYDEBUG 981 if (yydebug) 982 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 983 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 984 (int)(yylvp - yylvals - yyps->save->lexeme)); 985 #endif 986 /* Memorize most forward-looking error state in case it's really an error. */ 987 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 988 { 989 /* Free old saved error context state */ 990 if (yyerrctx) yyFreeState(yyerrctx); 991 /* Create and fill out new saved error context state */ 992 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 993 if (yyerrctx == NULL) goto yyenomem; 994 yyerrctx->save = yyps->save; 995 yyerrctx->state = yystate; 996 yyerrctx->errflag = yyerrflag; 997 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 998 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 999 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 1000 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1001 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1002 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 1003 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1004 #endif 1005 yyerrctx->lexeme = (int) (yylvp - yylvals); 1006 } 1007 yylvp = yylvals + save->lexeme; 1008 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1009 yylpp = yylpsns + save->lexeme; 1010 #endif 1011 yylexp = yylexemes + save->lexeme; 1012 yychar = YYEMPTY; 1013 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1014 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1015 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1016 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1017 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1018 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1019 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1020 #endif 1021 ctry = ++save->ctry; 1022 yystate = save->state; 1023 /* We tried shift, try reduce now */ 1024 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1025 yyps->save = save->save; 1026 save->save = NULL; 1027 yyFreeState(save); 1028 1029 /* Nothing left on the stack -- error */ 1030 if (!yyps->save) 1031 { 1032 #if YYDEBUG 1033 if (yydebug) 1034 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1035 YYPREFIX, yydepth); 1036 #endif 1037 /* Restore state as it was in the most forward-advanced error */ 1038 yylvp = yylvals + yyerrctx->lexeme; 1039 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1040 yylpp = yylpsns + yyerrctx->lexeme; 1041 #endif 1042 yylexp = yylexemes + yyerrctx->lexeme; 1043 yychar = yylexp[-1]; 1044 yylval = yylvp[-1]; 1045 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1046 yylloc = yylpp[-1]; 1047 #endif 1048 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1049 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1050 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1051 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1052 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1053 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1054 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1055 #endif 1056 yystate = yyerrctx->state; 1057 yyFreeState(yyerrctx); 1058 yyerrctx = NULL; 1059 } 1060 yynewerrflag = 1; 1061 } 1062 if (yynewerrflag == 0) goto yyinrecovery; 1063 #endif /* YYBTYACC */ 1064 1065 YYERROR_CALL("syntax error"); 1066 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1067 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */ 1068 #endif 1069 1070 #if !YYBTYACC 1071 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1072 yyerrlab: 1073 #endif 1074 ++yynerrs; 1075 1076 yyinrecovery: 1077 if (yyerrflag < 3) 1078 { 1079 yyerrflag = 3; 1080 for (;;) 1081 { 1082 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1083 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1084 { 1085 #if YYDEBUG 1086 if (yydebug) 1087 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1088 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1089 #endif 1090 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1091 yystate = yytable[yyn]; 1092 *++yystack.s_mark = yytable[yyn]; 1093 *++yystack.l_mark = yylval; 1094 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1095 /* lookahead position is error end position */ 1096 yyerror_loc_range[2] = yylloc; 1097 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1098 *++yystack.p_mark = yyloc; 1099 #endif 1100 goto yyloop; 1101 } 1102 else 1103 { 1104 #if YYDEBUG 1105 if (yydebug) 1106 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1107 YYDEBUGSTR, yydepth, *yystack.s_mark); 1108 #endif 1109 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1110 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1111 /* the current TOS position is the error start position */ 1112 yyerror_loc_range[1] = *yystack.p_mark; 1113 #endif 1114 #if defined(YYDESTRUCT_CALL) 1115 #if YYBTYACC 1116 if (!yytrial) 1117 #endif /* YYBTYACC */ 1118 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1119 YYDESTRUCT_CALL("error: discarding state", 1120 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1121 #else 1122 YYDESTRUCT_CALL("error: discarding state", 1123 yystos[*yystack.s_mark], yystack.l_mark); 1124 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1125 #endif /* defined(YYDESTRUCT_CALL) */ 1126 --yystack.s_mark; 1127 --yystack.l_mark; 1128 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1129 --yystack.p_mark; 1130 #endif 1131 } 1132 } 1133 } 1134 else 1135 { 1136 if (yychar == YYEOF) goto yyabort; 1137 #if YYDEBUG 1138 if (yydebug) 1139 { 1140 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1141 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1142 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1143 } 1144 #endif 1145 #if defined(YYDESTRUCT_CALL) 1146 #if YYBTYACC 1147 if (!yytrial) 1148 #endif /* YYBTYACC */ 1149 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1150 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1151 #else 1152 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1153 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1154 #endif /* defined(YYDESTRUCT_CALL) */ 1155 yychar = YYEMPTY; 1156 goto yyloop; 1157 } 1158 1159 yyreduce: 1160 yym = yylen[yyn]; 1161 #if YYDEBUG 1162 if (yydebug) 1163 { 1164 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1165 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1166 #ifdef YYSTYPE_TOSTRING 1167 #if YYBTYACC 1168 if (!yytrial) 1169 #endif /* YYBTYACC */ 1170 if (yym > 0) 1171 { 1172 int i; 1173 fputc('<', stderr); 1174 for (i = yym; i > 0; i--) 1175 { 1176 if (i != yym) fputs(", ", stderr); 1177 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1178 yystack.l_mark[1-i]), stderr); 1179 } 1180 fputc('>', stderr); 1181 } 1182 #endif 1183 fputc('\n', stderr); 1184 } 1185 #endif 1186 if (yym > 0) 1187 yyval = yystack.l_mark[1-yym]; 1188 else 1189 memset(&yyval, 0, sizeof yyval); 1190 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1191 1192 /* Perform position reduction */ 1193 memset(&yyloc, 0, sizeof(yyloc)); 1194 #if YYBTYACC 1195 if (!yytrial) 1196 #endif /* YYBTYACC */ 1197 { 1198 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym); 1199 /* just in case YYERROR is invoked within the action, save 1200 the start of the rhs as the error start position */ 1201 yyerror_loc_range[1] = yystack.p_mark[1-yym]; 1202 } 1203 #endif 1204 1205 switch (yyn) 1206 { 1207 case 3: 1208 #line 35 "calc2.y" 1209 { yyerrok ; } 1210 #line 1209 "calc2.tab.c" 1211 break; 1212 case 4: 1213 #line 39 "calc2.y" 1214 { printf("%d\n",yystack.l_mark[0]);} 1215 #line 1214 "calc2.tab.c" 1216 break; 1217 case 5: 1218 #line 41 "calc2.y" 1219 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1220 #line 1219 "calc2.tab.c" 1221 break; 1222 case 6: 1223 #line 45 "calc2.y" 1224 { yyval = yystack.l_mark[-1]; } 1225 #line 1224 "calc2.tab.c" 1226 break; 1227 case 7: 1228 #line 47 "calc2.y" 1229 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1230 #line 1229 "calc2.tab.c" 1231 break; 1232 case 8: 1233 #line 49 "calc2.y" 1234 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1235 #line 1234 "calc2.tab.c" 1236 break; 1237 case 9: 1238 #line 51 "calc2.y" 1239 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1240 #line 1239 "calc2.tab.c" 1241 break; 1242 case 10: 1243 #line 53 "calc2.y" 1244 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1245 #line 1244 "calc2.tab.c" 1246 break; 1247 case 11: 1248 #line 55 "calc2.y" 1249 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1250 #line 1249 "calc2.tab.c" 1251 break; 1252 case 12: 1253 #line 57 "calc2.y" 1254 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1255 #line 1254 "calc2.tab.c" 1256 break; 1257 case 13: 1258 #line 59 "calc2.y" 1259 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1260 #line 1259 "calc2.tab.c" 1261 break; 1262 case 14: 1263 #line 61 "calc2.y" 1264 { yyval = - yystack.l_mark[0]; } 1265 #line 1264 "calc2.tab.c" 1266 break; 1267 case 15: 1268 #line 63 "calc2.y" 1269 { yyval = regs[yystack.l_mark[0]]; } 1270 #line 1269 "calc2.tab.c" 1271 break; 1272 case 17: 1273 #line 68 "calc2.y" 1274 { yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; } 1275 #line 1274 "calc2.tab.c" 1276 break; 1277 case 18: 1278 #line 70 "calc2.y" 1279 { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; } 1280 #line 1279 "calc2.tab.c" 1281 break; 1282 #line 1281 "calc2.tab.c" 1283 default: 1284 break; 1285 } 1286 yystack.s_mark -= yym; 1287 yystate = *yystack.s_mark; 1288 yystack.l_mark -= yym; 1289 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1290 yystack.p_mark -= yym; 1291 #endif 1292 yym = yylhs[yyn]; 1293 if (yystate == 0 && yym == 0) 1294 { 1295 #if YYDEBUG 1296 if (yydebug) 1297 { 1298 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1299 #ifdef YYSTYPE_TOSTRING 1300 #if YYBTYACC 1301 if (!yytrial) 1302 #endif /* YYBTYACC */ 1303 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1304 #endif 1305 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1306 } 1307 #endif 1308 yystate = YYFINAL; 1309 *++yystack.s_mark = YYFINAL; 1310 *++yystack.l_mark = yyval; 1311 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1312 *++yystack.p_mark = yyloc; 1313 #endif 1314 if (yychar < 0) 1315 { 1316 #if YYBTYACC 1317 do { 1318 if (yylvp < yylve) 1319 { 1320 /* we're currently re-reading tokens */ 1321 yylval = *yylvp++; 1322 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1323 yylloc = *yylpp++; 1324 #endif 1325 yychar = *yylexp++; 1326 break; 1327 } 1328 if (yyps->save) 1329 { 1330 /* in trial mode; save scanner results for future parse attempts */ 1331 if (yylvp == yylvlim) 1332 { /* Enlarge lexical value queue */ 1333 size_t p = (size_t) (yylvp - yylvals); 1334 size_t s = (size_t) (yylvlim - yylvals); 1335 1336 s += YYLVQUEUEGROWTH; 1337 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1338 goto yyenomem; 1339 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1340 goto yyenomem; 1341 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1342 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1343 goto yyenomem; 1344 #endif 1345 yylvp = yylve = yylvals + p; 1346 yylvlim = yylvals + s; 1347 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1348 yylpp = yylpe = yylpsns + p; 1349 yylplim = yylpsns + s; 1350 #endif 1351 yylexp = yylexemes + p; 1352 } 1353 *yylexp = (YYINT) YYLEX; 1354 *yylvp++ = yylval; 1355 yylve++; 1356 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1357 *yylpp++ = yylloc; 1358 yylpe++; 1359 #endif 1360 yychar = *yylexp++; 1361 break; 1362 } 1363 /* normal operation, no conflict encountered */ 1364 #endif /* YYBTYACC */ 1365 yychar = YYLEX; 1366 #if YYBTYACC 1367 } while (0); 1368 #endif /* YYBTYACC */ 1369 if (yychar < 0) yychar = YYEOF; 1370 #if YYDEBUG 1371 if (yydebug) 1372 { 1373 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1374 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1375 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1376 } 1377 #endif 1378 } 1379 if (yychar == YYEOF) goto yyaccept; 1380 goto yyloop; 1381 } 1382 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1383 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1384 yystate = yytable[yyn]; 1385 else 1386 yystate = yydgoto[yym]; 1387 #if YYDEBUG 1388 if (yydebug) 1389 { 1390 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1391 #ifdef YYSTYPE_TOSTRING 1392 #if YYBTYACC 1393 if (!yytrial) 1394 #endif /* YYBTYACC */ 1395 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1396 #endif 1397 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1398 } 1399 #endif 1400 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1401 *++yystack.s_mark = (YYINT) yystate; 1402 *++yystack.l_mark = yyval; 1403 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1404 *++yystack.p_mark = yyloc; 1405 #endif 1406 goto yyloop; 1407 #if YYBTYACC 1408 1409 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1410 yyvalid: 1411 if (yypath) YYABORT; 1412 while (yyps->save) 1413 { 1414 YYParseState *save = yyps->save; 1415 yyps->save = save->save; 1416 save->save = yypath; 1417 yypath = save; 1418 } 1419 #if YYDEBUG 1420 if (yydebug) 1421 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1422 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1423 #endif 1424 if (yyerrctx) 1425 { 1426 yyFreeState(yyerrctx); 1427 yyerrctx = NULL; 1428 } 1429 yylvp = yylvals + yypath->lexeme; 1430 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1431 yylpp = yylpsns + yypath->lexeme; 1432 #endif 1433 yylexp = yylexemes + yypath->lexeme; 1434 yychar = YYEMPTY; 1435 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1436 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1437 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1438 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1439 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1440 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1441 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1442 #endif 1443 yystate = yypath->state; 1444 goto yyloop; 1445 #endif /* YYBTYACC */ 1446 1447 yyoverflow: 1448 YYERROR_CALL("yacc stack overflow"); 1449 #if YYBTYACC 1450 goto yyabort_nomem; 1451 yyenomem: 1452 YYERROR_CALL("memory exhausted"); 1453 yyabort_nomem: 1454 #endif /* YYBTYACC */ 1455 yyresult = 2; 1456 goto yyreturn; 1457 1458 yyabort: 1459 yyresult = 1; 1460 goto yyreturn; 1461 1462 yyaccept: 1463 #if YYBTYACC 1464 if (yyps->save) goto yyvalid; 1465 #endif /* YYBTYACC */ 1466 yyresult = 0; 1467 1468 yyreturn: 1469 #if defined(YYDESTRUCT_CALL) 1470 if (yychar != YYEOF && yychar != YYEMPTY) 1471 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1472 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1473 #else 1474 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1475 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1476 1477 { 1478 YYSTYPE *pv; 1479 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1480 YYLTYPE *pp; 1481 1482 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1483 YYDESTRUCT_CALL("cleanup: discarding state", 1484 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1485 #else 1486 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1487 YYDESTRUCT_CALL("cleanup: discarding state", 1488 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1489 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1490 } 1491 #endif /* defined(YYDESTRUCT_CALL) */ 1492 1493 #if YYBTYACC 1494 if (yyerrctx) 1495 { 1496 yyFreeState(yyerrctx); 1497 yyerrctx = NULL; 1498 } 1499 while (yyps) 1500 { 1501 YYParseState *save = yyps; 1502 yyps = save->save; 1503 save->save = NULL; 1504 yyFreeState(save); 1505 } 1506 while (yypath) 1507 { 1508 YYParseState *save = yypath; 1509 yypath = save->save; 1510 save->save = NULL; 1511 yyFreeState(save); 1512 } 1513 #endif /* YYBTYACC */ 1514 yyfreestack(&yystack); 1515 return (yyresult); 1516 } 1517
Indexes created Wed Mar 25 00:23:37 UTC 2026