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