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