calc3.tab.c revision 1.1.1.6
1 /* $NetBSD: calc3.tab.c,v 1.1.1.6 2018/12/23 15:26:13 christos Exp $ */ 2 3 /* original parser id follows */ 4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 5 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 6 7 #define YYBYACC 1 8 #define YYMAJOR 1 9 #define YYMINOR 9 10 #define YYCHECK "yyyymmdd" 11 12 #define YYEMPTY (-1) 13 #define yyclearin (yychar = YYEMPTY) 14 #define yyerrok (yyerrflag = 0) 15 #define YYRECOVERING() (yyerrflag != 0) 16 #define YYENOMEM (-2) 17 #define YYEOF 0 18 #undef YYBTYACC 19 #define YYBTYACC 0 20 #define YYDEBUGSTR YYPREFIX "debug" 21 22 #ifndef yyparse 23 #define yyparse 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 short 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 = 0; 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 break; 1213 case 4: 1214 #line 42 "calc3.y" 1215 { printf("%d\n",yystack.l_mark[0]);} 1216 break; 1217 case 5: 1218 #line 44 "calc3.y" 1219 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1220 break; 1221 case 6: 1222 #line 48 "calc3.y" 1223 { yyval = yystack.l_mark[-1]; } 1224 break; 1225 case 7: 1226 #line 50 "calc3.y" 1227 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1228 break; 1229 case 8: 1230 #line 52 "calc3.y" 1231 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1232 break; 1233 case 9: 1234 #line 54 "calc3.y" 1235 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1236 break; 1237 case 10: 1238 #line 56 "calc3.y" 1239 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1240 break; 1241 case 11: 1242 #line 58 "calc3.y" 1243 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1244 break; 1245 case 12: 1246 #line 60 "calc3.y" 1247 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1248 break; 1249 case 13: 1250 #line 62 "calc3.y" 1251 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1252 break; 1253 case 14: 1254 #line 64 "calc3.y" 1255 { yyval = - yystack.l_mark[0]; } 1256 break; 1257 case 15: 1258 #line 66 "calc3.y" 1259 { yyval = regs[yystack.l_mark[0]]; } 1260 break; 1261 case 17: 1262 #line 71 "calc3.y" 1263 { yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; } 1264 break; 1265 case 18: 1266 #line 73 "calc3.y" 1267 { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; } 1268 break; 1269 #line 1268 "calc3.tab.c" 1270 default: 1271 break; 1272 } 1273 yystack.s_mark -= yym; 1274 yystate = *yystack.s_mark; 1275 yystack.l_mark -= yym; 1276 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1277 yystack.p_mark -= yym; 1278 #endif 1279 yym = yylhs[yyn]; 1280 if (yystate == 0 && yym == 0) 1281 { 1282 #if YYDEBUG 1283 if (yydebug) 1284 { 1285 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1286 #ifdef YYSTYPE_TOSTRING 1287 #if YYBTYACC 1288 if (!yytrial) 1289 #endif /* YYBTYACC */ 1290 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1291 #endif 1292 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1293 } 1294 #endif 1295 yystate = YYFINAL; 1296 *++yystack.s_mark = YYFINAL; 1297 *++yystack.l_mark = yyval; 1298 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1299 *++yystack.p_mark = yyloc; 1300 #endif 1301 if (yychar < 0) 1302 { 1303 #if YYBTYACC 1304 do { 1305 if (yylvp < yylve) 1306 { 1307 /* we're currently re-reading tokens */ 1308 yylval = *yylvp++; 1309 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1310 yylloc = *yylpp++; 1311 #endif 1312 yychar = *yylexp++; 1313 break; 1314 } 1315 if (yyps->save) 1316 { 1317 /* in trial mode; save scanner results for future parse attempts */ 1318 if (yylvp == yylvlim) 1319 { /* Enlarge lexical value queue */ 1320 size_t p = (size_t) (yylvp - yylvals); 1321 size_t s = (size_t) (yylvlim - yylvals); 1322 1323 s += YYLVQUEUEGROWTH; 1324 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1325 goto yyenomem; 1326 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1327 goto yyenomem; 1328 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1329 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1330 goto yyenomem; 1331 #endif 1332 yylvp = yylve = yylvals + p; 1333 yylvlim = yylvals + s; 1334 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1335 yylpp = yylpe = yylpsns + p; 1336 yylplim = yylpsns + s; 1337 #endif 1338 yylexp = yylexemes + p; 1339 } 1340 *yylexp = (YYINT) YYLEX; 1341 *yylvp++ = yylval; 1342 yylve++; 1343 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1344 *yylpp++ = yylloc; 1345 yylpe++; 1346 #endif 1347 yychar = *yylexp++; 1348 break; 1349 } 1350 /* normal operation, no conflict encountered */ 1351 #endif /* YYBTYACC */ 1352 yychar = YYLEX; 1353 #if YYBTYACC 1354 } while (0); 1355 #endif /* YYBTYACC */ 1356 if (yychar < 0) yychar = YYEOF; 1357 #if YYDEBUG 1358 if (yydebug) 1359 { 1360 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1361 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1362 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1363 } 1364 #endif 1365 } 1366 if (yychar == YYEOF) goto yyaccept; 1367 goto yyloop; 1368 } 1369 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1370 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1371 yystate = yytable[yyn]; 1372 else 1373 yystate = yydgoto[yym]; 1374 #if YYDEBUG 1375 if (yydebug) 1376 { 1377 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1378 #ifdef YYSTYPE_TOSTRING 1379 #if YYBTYACC 1380 if (!yytrial) 1381 #endif /* YYBTYACC */ 1382 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1383 #endif 1384 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1385 } 1386 #endif 1387 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1388 *++yystack.s_mark = (YYINT) yystate; 1389 *++yystack.l_mark = yyval; 1390 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1391 *++yystack.p_mark = yyloc; 1392 #endif 1393 goto yyloop; 1394 #if YYBTYACC 1395 1396 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1397 yyvalid: 1398 if (yypath) YYABORT; 1399 while (yyps->save) 1400 { 1401 YYParseState *save = yyps->save; 1402 yyps->save = save->save; 1403 save->save = yypath; 1404 yypath = save; 1405 } 1406 #if YYDEBUG 1407 if (yydebug) 1408 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1409 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1410 #endif 1411 if (yyerrctx) 1412 { 1413 yyFreeState(yyerrctx); 1414 yyerrctx = NULL; 1415 } 1416 yylvp = yylvals + yypath->lexeme; 1417 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1418 yylpp = yylpsns + yypath->lexeme; 1419 #endif 1420 yylexp = yylexemes + yypath->lexeme; 1421 yychar = YYEMPTY; 1422 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1423 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1424 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1425 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1426 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1427 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1428 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1429 #endif 1430 yystate = yypath->state; 1431 goto yyloop; 1432 #endif /* YYBTYACC */ 1433 1434 yyoverflow: 1435 YYERROR_CALL("yacc stack overflow"); 1436 #if YYBTYACC 1437 goto yyabort_nomem; 1438 yyenomem: 1439 YYERROR_CALL("memory exhausted"); 1440 yyabort_nomem: 1441 #endif /* YYBTYACC */ 1442 yyresult = 2; 1443 goto yyreturn; 1444 1445 yyabort: 1446 yyresult = 1; 1447 goto yyreturn; 1448 1449 yyaccept: 1450 #if YYBTYACC 1451 if (yyps->save) goto yyvalid; 1452 #endif /* YYBTYACC */ 1453 yyresult = 0; 1454 1455 yyreturn: 1456 #if defined(YYDESTRUCT_CALL) 1457 if (yychar != YYEOF && yychar != YYEMPTY) 1458 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1459 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1460 #else 1461 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1462 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1463 1464 { 1465 YYSTYPE *pv; 1466 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1467 YYLTYPE *pp; 1468 1469 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1470 YYDESTRUCT_CALL("cleanup: discarding state", 1471 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1472 #else 1473 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1474 YYDESTRUCT_CALL("cleanup: discarding state", 1475 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1476 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1477 } 1478 #endif /* defined(YYDESTRUCT_CALL) */ 1479 1480 #if YYBTYACC 1481 if (yyerrctx) 1482 { 1483 yyFreeState(yyerrctx); 1484 yyerrctx = NULL; 1485 } 1486 while (yyps) 1487 { 1488 YYParseState *save = yyps; 1489 yyps = save->save; 1490 save->save = NULL; 1491 yyFreeState(save); 1492 } 1493 while (yypath) 1494 { 1495 YYParseState *save = yypath; 1496 yypath = save->save; 1497 save->save = NULL; 1498 yyFreeState(save); 1499 } 1500 #endif /* YYBTYACC */ 1501 yyfreestack(&yystack); 1502 return (yyresult); 1503 } 1504
Indexes created Fri Mar 27 00:22:57 UTC 2026