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