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