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