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