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