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