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