defines2.calc.c revision 1.1.1.1
1 /* $NetBSD: defines2.calc.c,v 1.1.1.1 2019/10/06 23:19:27 christos Exp $ */ 2 3 /* original parser id follows */ 4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 5 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 6 7 #define YYBYACC 1 8 #define YYMAJOR 1 9 #define YYMINOR 9 10 #define YYCHECK "yyyymmdd" 11 12 #define YYEMPTY (-1) 13 #define yyclearin (yychar = YYEMPTY) 14 #define yyerrok (yyerrflag = 0) 15 #define YYRECOVERING() (yyerrflag != 0) 16 #define YYENOMEM (-2) 17 #define YYEOF 0 18 #undef YYBTYACC 19 #define YYBTYACC 0 20 #define YYDEBUGSTR YYPREFIX "debug" 21 #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 short 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 = 0; 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 break; 1093 case 4: 1094 #line 32 "calc.y" 1095 { printf("%d\n",yystack.l_mark[0]);} 1096 break; 1097 case 5: 1098 #line 34 "calc.y" 1099 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1100 break; 1101 case 6: 1102 #line 38 "calc.y" 1103 { yyval = yystack.l_mark[-1]; } 1104 break; 1105 case 7: 1106 #line 40 "calc.y" 1107 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1108 break; 1109 case 8: 1110 #line 42 "calc.y" 1111 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1112 break; 1113 case 9: 1114 #line 44 "calc.y" 1115 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1116 break; 1117 case 10: 1118 #line 46 "calc.y" 1119 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1120 break; 1121 case 11: 1122 #line 48 "calc.y" 1123 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1124 break; 1125 case 12: 1126 #line 50 "calc.y" 1127 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1128 break; 1129 case 13: 1130 #line 52 "calc.y" 1131 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1132 break; 1133 case 14: 1134 #line 54 "calc.y" 1135 { yyval = - yystack.l_mark[0]; } 1136 break; 1137 case 15: 1138 #line 56 "calc.y" 1139 { yyval = regs[yystack.l_mark[0]]; } 1140 break; 1141 case 17: 1142 #line 61 "calc.y" 1143 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1144 break; 1145 case 18: 1146 #line 63 "calc.y" 1147 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1148 break; 1149 #line 1148 "y.tab.c" 1150 default: 1151 break; 1152 } 1153 yystack.s_mark -= yym; 1154 yystate = *yystack.s_mark; 1155 yystack.l_mark -= yym; 1156 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1157 yystack.p_mark -= yym; 1158 #endif 1159 yym = yylhs[yyn]; 1160 if (yystate == 0 && yym == 0) 1161 { 1162 #if YYDEBUG 1163 if (yydebug) 1164 { 1165 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1166 #ifdef YYSTYPE_TOSTRING 1167 #if YYBTYACC 1168 if (!yytrial) 1169 #endif /* YYBTYACC */ 1170 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1171 #endif 1172 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1173 } 1174 #endif 1175 yystate = YYFINAL; 1176 *++yystack.s_mark = YYFINAL; 1177 *++yystack.l_mark = yyval; 1178 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1179 *++yystack.p_mark = yyloc; 1180 #endif 1181 if (yychar < 0) 1182 { 1183 #if YYBTYACC 1184 do { 1185 if (yylvp < yylve) 1186 { 1187 /* we're currently re-reading tokens */ 1188 yylval = *yylvp++; 1189 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1190 yylloc = *yylpp++; 1191 #endif 1192 yychar = *yylexp++; 1193 break; 1194 } 1195 if (yyps->save) 1196 { 1197 /* in trial mode; save scanner results for future parse attempts */ 1198 if (yylvp == yylvlim) 1199 { /* Enlarge lexical value queue */ 1200 size_t p = (size_t) (yylvp - yylvals); 1201 size_t s = (size_t) (yylvlim - yylvals); 1202 1203 s += YYLVQUEUEGROWTH; 1204 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1205 goto yyenomem; 1206 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1207 goto yyenomem; 1208 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1209 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1210 goto yyenomem; 1211 #endif 1212 yylvp = yylve = yylvals + p; 1213 yylvlim = yylvals + s; 1214 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1215 yylpp = yylpe = yylpsns + p; 1216 yylplim = yylpsns + s; 1217 #endif 1218 yylexp = yylexemes + p; 1219 } 1220 *yylexp = (YYINT) YYLEX; 1221 *yylvp++ = yylval; 1222 yylve++; 1223 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1224 *yylpp++ = yylloc; 1225 yylpe++; 1226 #endif 1227 yychar = *yylexp++; 1228 break; 1229 } 1230 /* normal operation, no conflict encountered */ 1231 #endif /* YYBTYACC */ 1232 yychar = YYLEX; 1233 #if YYBTYACC 1234 } while (0); 1235 #endif /* YYBTYACC */ 1236 if (yychar < 0) yychar = YYEOF; 1237 #if YYDEBUG 1238 if (yydebug) 1239 { 1240 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1241 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1242 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1243 } 1244 #endif 1245 } 1246 if (yychar == YYEOF) goto yyaccept; 1247 goto yyloop; 1248 } 1249 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1250 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1251 yystate = yytable[yyn]; 1252 else 1253 yystate = yydgoto[yym]; 1254 #if YYDEBUG 1255 if (yydebug) 1256 { 1257 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1258 #ifdef YYSTYPE_TOSTRING 1259 #if YYBTYACC 1260 if (!yytrial) 1261 #endif /* YYBTYACC */ 1262 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1263 #endif 1264 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1265 } 1266 #endif 1267 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1268 *++yystack.s_mark = (YYINT) yystate; 1269 *++yystack.l_mark = yyval; 1270 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1271 *++yystack.p_mark = yyloc; 1272 #endif 1273 goto yyloop; 1274 #if YYBTYACC 1275 1276 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1277 yyvalid: 1278 if (yypath) YYABORT; 1279 while (yyps->save) 1280 { 1281 YYParseState *save = yyps->save; 1282 yyps->save = save->save; 1283 save->save = yypath; 1284 yypath = save; 1285 } 1286 #if YYDEBUG 1287 if (yydebug) 1288 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1289 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1290 #endif 1291 if (yyerrctx) 1292 { 1293 yyFreeState(yyerrctx); 1294 yyerrctx = NULL; 1295 } 1296 yylvp = yylvals + yypath->lexeme; 1297 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1298 yylpp = yylpsns + yypath->lexeme; 1299 #endif 1300 yylexp = yylexemes + yypath->lexeme; 1301 yychar = YYEMPTY; 1302 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1303 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1304 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1305 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1306 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1307 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1308 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1309 #endif 1310 yystate = yypath->state; 1311 goto yyloop; 1312 #endif /* YYBTYACC */ 1313 1314 yyoverflow: 1315 YYERROR_CALL("yacc stack overflow"); 1316 #if YYBTYACC 1317 goto yyabort_nomem; 1318 yyenomem: 1319 YYERROR_CALL("memory exhausted"); 1320 yyabort_nomem: 1321 #endif /* YYBTYACC */ 1322 yyresult = 2; 1323 goto yyreturn; 1324 1325 yyabort: 1326 yyresult = 1; 1327 goto yyreturn; 1328 1329 yyaccept: 1330 #if YYBTYACC 1331 if (yyps->save) goto yyvalid; 1332 #endif /* YYBTYACC */ 1333 yyresult = 0; 1334 1335 yyreturn: 1336 #if defined(YYDESTRUCT_CALL) 1337 if (yychar != YYEOF && yychar != YYEMPTY) 1338 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1339 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1340 #else 1341 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1342 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1343 1344 { 1345 YYSTYPE *pv; 1346 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1347 YYLTYPE *pp; 1348 1349 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1350 YYDESTRUCT_CALL("cleanup: discarding state", 1351 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1352 #else 1353 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1354 YYDESTRUCT_CALL("cleanup: discarding state", 1355 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1356 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1357 } 1358 #endif /* defined(YYDESTRUCT_CALL) */ 1359 1360 #if YYBTYACC 1361 if (yyerrctx) 1362 { 1363 yyFreeState(yyerrctx); 1364 yyerrctx = NULL; 1365 } 1366 while (yyps) 1367 { 1368 YYParseState *save = yyps; 1369 yyps = save->save; 1370 save->save = NULL; 1371 yyFreeState(save); 1372 } 1373 while (yypath) 1374 { 1375 YYParseState *save = yypath; 1376 yypath = save->save; 1377 save->save = NULL; 1378 yyFreeState(save); 1379 } 1380 #endif /* YYBTYACC */ 1381 yyfreestack(&yystack); 1382 return (yyresult); 1383 } 1384
Indexes created Fri Mar 20 00:23:26 UTC 2026