ok_syntax1.tab.c revision 1.2.4.1
1 /* $NetBSD: ok_syntax1.tab.c,v 1.2.4.1 2017/07/18 18:09:43 snj 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 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 704 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 705 #endif 706 707 yyerrflag = 0; 708 yychar = 0; 709 memset(&yyval, 0, sizeof(yyval)); 710 memset(&yylval, 0, sizeof(yylval)); 711 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 712 memset(&yyloc, 0, sizeof(yyloc)); 713 memset(&yylloc, 0, sizeof(yylloc)); 714 #endif 715 716 #if YYBTYACC 717 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 718 yyps->save = 0; 719 #endif /* YYBTYACC */ 720 yym = 0; 721 yyn = 0; 722 yynerrs = 0; 723 yyerrflag = 0; 724 yychar = YYEMPTY; 725 yystate = 0; 726 727 #if YYPURE 728 memset(&yystack, 0, sizeof(yystack)); 729 #endif 730 731 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 732 yystack.s_mark = yystack.s_base; 733 yystack.l_mark = yystack.l_base; 734 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 735 yystack.p_mark = yystack.p_base; 736 #endif 737 yystate = 0; 738 *yystack.s_mark = 0; 739 740 yyloop: 741 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 742 if (yychar < 0) 743 { 744 #if YYBTYACC 745 do { 746 if (yylvp < yylve) 747 { 748 /* we're currently re-reading tokens */ 749 yylval = *yylvp++; 750 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 751 yylloc = *yylpp++; 752 #endif 753 yychar = *yylexp++; 754 break; 755 } 756 if (yyps->save) 757 { 758 /* in trial mode; save scanner results for future parse attempts */ 759 if (yylvp == yylvlim) 760 { /* Enlarge lexical value queue */ 761 size_t p = (size_t) (yylvp - yylvals); 762 size_t s = (size_t) (yylvlim - yylvals); 763 764 s += YYLVQUEUEGROWTH; 765 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 766 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 767 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 768 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 769 #endif 770 yylvp = yylve = yylvals + p; 771 yylvlim = yylvals + s; 772 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 773 yylpp = yylpe = yylpsns + p; 774 yylplim = yylpsns + s; 775 #endif 776 yylexp = yylexemes + p; 777 } 778 *yylexp = (YYINT) YYLEX; 779 *yylvp++ = yylval; 780 yylve++; 781 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 782 *yylpp++ = yylloc; 783 yylpe++; 784 #endif 785 yychar = *yylexp++; 786 break; 787 } 788 /* normal operation, no conflict encountered */ 789 #endif /* YYBTYACC */ 790 yychar = YYLEX; 791 #if YYBTYACC 792 } while (0); 793 #endif /* YYBTYACC */ 794 if (yychar < 0) yychar = YYEOF; 795 #if YYDEBUG 796 if (yydebug) 797 { 798 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 799 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 800 YYDEBUGSTR, yydepth, yystate, yychar, yys); 801 #ifdef YYSTYPE_TOSTRING 802 #if YYBTYACC 803 if (!yytrial) 804 #endif /* YYBTYACC */ 805 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 806 #endif 807 fputc('\n', stderr); 808 } 809 #endif 810 } 811 #if YYBTYACC 812 813 /* Do we have a conflict? */ 814 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 815 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 816 { 817 YYINT ctry; 818 819 if (yypath) 820 { 821 YYParseState *save; 822 #if YYDEBUG 823 if (yydebug) 824 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 825 YYDEBUGSTR, yydepth, yystate); 826 #endif 827 /* Switch to the next conflict context */ 828 save = yypath; 829 yypath = save->save; 830 save->save = NULL; 831 ctry = save->ctry; 832 if (save->state != yystate) YYABORT; 833 yyFreeState(save); 834 835 } 836 else 837 { 838 839 /* Unresolved conflict - start/continue trial parse */ 840 YYParseState *save; 841 #if YYDEBUG 842 if (yydebug) 843 { 844 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 845 if (yyps->save) 846 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 847 else 848 fputs("Starting trial parse.\n", stderr); 849 } 850 #endif 851 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 852 if (save == NULL) goto yyenomem; 853 save->save = yyps->save; 854 save->state = yystate; 855 save->errflag = yyerrflag; 856 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 857 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 858 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 859 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 860 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 861 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 862 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 863 #endif 864 ctry = yytable[yyn]; 865 if (yyctable[ctry] == -1) 866 { 867 #if YYDEBUG 868 if (yydebug && yychar >= YYEOF) 869 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 870 #endif 871 ctry++; 872 } 873 save->ctry = ctry; 874 if (yyps->save == NULL) 875 { 876 /* If this is a first conflict in the stack, start saving lexemes */ 877 if (!yylexemes) 878 { 879 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 880 if (yylexemes == NULL) goto yyenomem; 881 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 882 if (yylvals == NULL) goto yyenomem; 883 yylvlim = yylvals + YYLVQUEUEGROWTH; 884 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 885 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 886 if (yylpsns == NULL) goto yyenomem; 887 yylplim = yylpsns + YYLVQUEUEGROWTH; 888 #endif 889 } 890 if (yylvp == yylve) 891 { 892 yylvp = yylve = yylvals; 893 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 894 yylpp = yylpe = yylpsns; 895 #endif 896 yylexp = yylexemes; 897 if (yychar >= YYEOF) 898 { 899 *yylve++ = yylval; 900 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 901 *yylpe++ = yylloc; 902 #endif 903 *yylexp = (YYINT) yychar; 904 yychar = YYEMPTY; 905 } 906 } 907 } 908 if (yychar >= YYEOF) 909 { 910 yylvp--; 911 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 912 yylpp--; 913 #endif 914 yylexp--; 915 yychar = YYEMPTY; 916 } 917 save->lexeme = (int) (yylvp - yylvals); 918 yyps->save = save; 919 } 920 if (yytable[yyn] == ctry) 921 { 922 #if YYDEBUG 923 if (yydebug) 924 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 925 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 926 #endif 927 if (yychar < 0) 928 { 929 yylvp++; 930 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 931 yylpp++; 932 #endif 933 yylexp++; 934 } 935 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 936 goto yyoverflow; 937 yystate = yyctable[ctry]; 938 *++yystack.s_mark = (YYINT) yystate; 939 *++yystack.l_mark = yylval; 940 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 941 *++yystack.p_mark = yylloc; 942 #endif 943 yychar = YYEMPTY; 944 if (yyerrflag > 0) --yyerrflag; 945 goto yyloop; 946 } 947 else 948 { 949 yyn = yyctable[ctry]; 950 goto yyreduce; 951 } 952 } /* End of code dealing with conflicts */ 953 #endif /* YYBTYACC */ 954 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 955 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 956 { 957 #if YYDEBUG 958 if (yydebug) 959 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 960 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 961 #endif 962 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 963 yystate = yytable[yyn]; 964 *++yystack.s_mark = yytable[yyn]; 965 *++yystack.l_mark = yylval; 966 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 967 *++yystack.p_mark = yylloc; 968 #endif 969 yychar = YYEMPTY; 970 if (yyerrflag > 0) --yyerrflag; 971 goto yyloop; 972 } 973 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 974 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 975 { 976 yyn = yytable[yyn]; 977 goto yyreduce; 978 } 979 if (yyerrflag != 0) goto yyinrecovery; 980 #if YYBTYACC 981 982 yynewerrflag = 1; 983 goto yyerrhandler; 984 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 985 986 yyerrlab: 987 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 988 * before looking for error recovery */ 989 yystack.s_mark -= yym; 990 yystate = *yystack.s_mark; 991 yystack.l_mark -= yym; 992 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 993 yystack.p_mark -= yym; 994 #endif 995 996 yynewerrflag = 0; 997 yyerrhandler: 998 while (yyps->save) 999 { 1000 int ctry; 1001 YYParseState *save = yyps->save; 1002 #if YYDEBUG 1003 if (yydebug) 1004 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 1005 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 1006 (int)(yylvp - yylvals - yyps->save->lexeme)); 1007 #endif 1008 /* Memorize most forward-looking error state in case it's really an error. */ 1009 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 1010 { 1011 /* Free old saved error context state */ 1012 if (yyerrctx) yyFreeState(yyerrctx); 1013 /* Create and fill out new saved error context state */ 1014 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 1015 if (yyerrctx == NULL) goto yyenomem; 1016 yyerrctx->save = yyps->save; 1017 yyerrctx->state = yystate; 1018 yyerrctx->errflag = yyerrflag; 1019 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 1020 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1021 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 1022 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1023 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1024 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 1025 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1026 #endif 1027 yyerrctx->lexeme = (int) (yylvp - yylvals); 1028 } 1029 yylvp = yylvals + save->lexeme; 1030 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1031 yylpp = yylpsns + save->lexeme; 1032 #endif 1033 yylexp = yylexemes + save->lexeme; 1034 yychar = YYEMPTY; 1035 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1036 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1037 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1038 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1039 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1040 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1041 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1042 #endif 1043 ctry = ++save->ctry; 1044 yystate = save->state; 1045 /* We tried shift, try reduce now */ 1046 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1047 yyps->save = save->save; 1048 save->save = NULL; 1049 yyFreeState(save); 1050 1051 /* Nothing left on the stack -- error */ 1052 if (!yyps->save) 1053 { 1054 #if YYDEBUG 1055 if (yydebug) 1056 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1057 YYPREFIX, yydepth); 1058 #endif 1059 /* Restore state as it was in the most forward-advanced error */ 1060 yylvp = yylvals + yyerrctx->lexeme; 1061 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1062 yylpp = yylpsns + yyerrctx->lexeme; 1063 #endif 1064 yylexp = yylexemes + yyerrctx->lexeme; 1065 yychar = yylexp[-1]; 1066 yylval = yylvp[-1]; 1067 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1068 yylloc = yylpp[-1]; 1069 #endif 1070 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1071 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1072 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1073 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1074 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1075 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1076 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1077 #endif 1078 yystate = yyerrctx->state; 1079 yyFreeState(yyerrctx); 1080 yyerrctx = NULL; 1081 } 1082 yynewerrflag = 1; 1083 } 1084 if (yynewerrflag == 0) goto yyinrecovery; 1085 #endif /* YYBTYACC */ 1086 1087 YYERROR_CALL("syntax error"); 1088 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1089 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1090 #endif 1091 1092 #if !YYBTYACC 1093 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1094 yyerrlab: 1095 #endif 1096 ++yynerrs; 1097 1098 yyinrecovery: 1099 if (yyerrflag < 3) 1100 { 1101 yyerrflag = 3; 1102 for (;;) 1103 { 1104 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1105 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1106 { 1107 #if YYDEBUG 1108 if (yydebug) 1109 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1110 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1111 #endif 1112 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1113 yystate = yytable[yyn]; 1114 *++yystack.s_mark = yytable[yyn]; 1115 *++yystack.l_mark = yylval; 1116 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1117 /* lookahead position is error end position */ 1118 yyerror_loc_range[1] = yylloc; 1119 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1120 *++yystack.p_mark = yyloc; 1121 #endif 1122 goto yyloop; 1123 } 1124 else 1125 { 1126 #if YYDEBUG 1127 if (yydebug) 1128 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1129 YYDEBUGSTR, yydepth, *yystack.s_mark); 1130 #endif 1131 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1132 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1133 /* the current TOS position is the error start position */ 1134 yyerror_loc_range[0] = *yystack.p_mark; 1135 #endif 1136 #if defined(YYDESTRUCT_CALL) 1137 #if YYBTYACC 1138 if (!yytrial) 1139 #endif /* YYBTYACC */ 1140 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1141 YYDESTRUCT_CALL("error: discarding state", 1142 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1143 #else 1144 YYDESTRUCT_CALL("error: discarding state", 1145 yystos[*yystack.s_mark], yystack.l_mark); 1146 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1147 #endif /* defined(YYDESTRUCT_CALL) */ 1148 --yystack.s_mark; 1149 --yystack.l_mark; 1150 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1151 --yystack.p_mark; 1152 #endif 1153 } 1154 } 1155 } 1156 else 1157 { 1158 if (yychar == YYEOF) goto yyabort; 1159 #if YYDEBUG 1160 if (yydebug) 1161 { 1162 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1163 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1164 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1165 } 1166 #endif 1167 #if defined(YYDESTRUCT_CALL) 1168 #if YYBTYACC 1169 if (!yytrial) 1170 #endif /* YYBTYACC */ 1171 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1172 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1173 #else 1174 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1175 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1176 #endif /* defined(YYDESTRUCT_CALL) */ 1177 yychar = YYEMPTY; 1178 goto yyloop; 1179 } 1180 1181 yyreduce: 1182 yym = yylen[yyn]; 1183 #if YYDEBUG 1184 if (yydebug) 1185 { 1186 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1187 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1188 #ifdef YYSTYPE_TOSTRING 1189 #if YYBTYACC 1190 if (!yytrial) 1191 #endif /* YYBTYACC */ 1192 if (yym > 0) 1193 { 1194 int i; 1195 fputc('<', stderr); 1196 for (i = yym; i > 0; i--) 1197 { 1198 if (i != yym) fputs(", ", stderr); 1199 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1200 yystack.l_mark[1-i]), stderr); 1201 } 1202 fputc('>', stderr); 1203 } 1204 #endif 1205 fputc('\n', stderr); 1206 } 1207 #endif 1208 if (yym > 0) 1209 yyval = yystack.l_mark[1-yym]; 1210 else 1211 memset(&yyval, 0, sizeof yyval); 1212 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1213 1214 /* Perform position reduction */ 1215 memset(&yyloc, 0, sizeof(yyloc)); 1216 #if YYBTYACC 1217 if (!yytrial) 1218 #endif /* YYBTYACC */ 1219 { 1220 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1221 /* just in case YYERROR is invoked within the action, save 1222 the start of the rhs as the error start position */ 1223 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1224 } 1225 #endif 1226 1227 switch (yyn) 1228 { 1229 case 3: 1230 #line 66 "ok_syntax1.y" 1231 { yyerrok ; } 1232 break; 1233 case 4: 1234 #line 70 "ok_syntax1.y" 1235 { printf("%d\n",yystack.l_mark[0].ival);} 1236 break; 1237 case 5: 1238 #line 72 "ok_syntax1.y" 1239 { regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; } 1240 break; 1241 case 6: 1242 #line 76 "ok_syntax1.y" 1243 { yyval.ival = yystack.l_mark[-1].ival; } 1244 break; 1245 case 7: 1246 #line 78 "ok_syntax1.y" 1247 { yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; } 1248 break; 1249 case 8: 1250 #line 80 "ok_syntax1.y" 1251 { yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; } 1252 break; 1253 case 9: 1254 #line 82 "ok_syntax1.y" 1255 { yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; } 1256 break; 1257 case 10: 1258 #line 84 "ok_syntax1.y" 1259 { yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; } 1260 break; 1261 case 11: 1262 #line 86 "ok_syntax1.y" 1263 { yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; } 1264 break; 1265 case 12: 1266 #line 88 "ok_syntax1.y" 1267 { yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; } 1268 break; 1269 case 13: 1270 #line 90 "ok_syntax1.y" 1271 { yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; } 1272 break; 1273 case 14: 1274 #line 92 "ok_syntax1.y" 1275 { yyval.ival = - yystack.l_mark[0].ival; } 1276 break; 1277 case 15: 1278 #line 94 "ok_syntax1.y" 1279 { yyval.ival = regs[yystack.l_mark[0].ival]; } 1280 break; 1281 case 17: 1282 #line 99 "ok_syntax1.y" 1283 { yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; } 1284 break; 1285 case 18: 1286 #line 101 "ok_syntax1.y" 1287 { yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; } 1288 break; 1289 #line 1288 "ok_syntax1.tab.c" 1290 default: 1291 break; 1292 } 1293 yystack.s_mark -= yym; 1294 yystate = *yystack.s_mark; 1295 yystack.l_mark -= yym; 1296 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1297 yystack.p_mark -= yym; 1298 #endif 1299 yym = yylhs[yyn]; 1300 if (yystate == 0 && yym == 0) 1301 { 1302 #if YYDEBUG 1303 if (yydebug) 1304 { 1305 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1306 #ifdef YYSTYPE_TOSTRING 1307 #if YYBTYACC 1308 if (!yytrial) 1309 #endif /* YYBTYACC */ 1310 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1311 #endif 1312 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1313 } 1314 #endif 1315 yystate = YYFINAL; 1316 *++yystack.s_mark = YYFINAL; 1317 *++yystack.l_mark = yyval; 1318 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1319 *++yystack.p_mark = yyloc; 1320 #endif 1321 if (yychar < 0) 1322 { 1323 #if YYBTYACC 1324 do { 1325 if (yylvp < yylve) 1326 { 1327 /* we're currently re-reading tokens */ 1328 yylval = *yylvp++; 1329 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1330 yylloc = *yylpp++; 1331 #endif 1332 yychar = *yylexp++; 1333 break; 1334 } 1335 if (yyps->save) 1336 { 1337 /* in trial mode; save scanner results for future parse attempts */ 1338 if (yylvp == yylvlim) 1339 { /* Enlarge lexical value queue */ 1340 size_t p = (size_t) (yylvp - yylvals); 1341 size_t s = (size_t) (yylvlim - yylvals); 1342 1343 s += YYLVQUEUEGROWTH; 1344 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1345 goto yyenomem; 1346 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1347 goto yyenomem; 1348 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1349 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1350 goto yyenomem; 1351 #endif 1352 yylvp = yylve = yylvals + p; 1353 yylvlim = yylvals + s; 1354 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1355 yylpp = yylpe = yylpsns + p; 1356 yylplim = yylpsns + s; 1357 #endif 1358 yylexp = yylexemes + p; 1359 } 1360 *yylexp = (YYINT) YYLEX; 1361 *yylvp++ = yylval; 1362 yylve++; 1363 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1364 *yylpp++ = yylloc; 1365 yylpe++; 1366 #endif 1367 yychar = *yylexp++; 1368 break; 1369 } 1370 /* normal operation, no conflict encountered */ 1371 #endif /* YYBTYACC */ 1372 yychar = YYLEX; 1373 #if YYBTYACC 1374 } while (0); 1375 #endif /* YYBTYACC */ 1376 if (yychar < 0) yychar = YYEOF; 1377 #if YYDEBUG 1378 if (yydebug) 1379 { 1380 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1381 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1382 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1383 } 1384 #endif 1385 } 1386 if (yychar == YYEOF) goto yyaccept; 1387 goto yyloop; 1388 } 1389 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1390 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1391 yystate = yytable[yyn]; 1392 else 1393 yystate = yydgoto[yym]; 1394 #if YYDEBUG 1395 if (yydebug) 1396 { 1397 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1398 #ifdef YYSTYPE_TOSTRING 1399 #if YYBTYACC 1400 if (!yytrial) 1401 #endif /* YYBTYACC */ 1402 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1403 #endif 1404 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1405 } 1406 #endif 1407 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1408 *++yystack.s_mark = (YYINT) yystate; 1409 *++yystack.l_mark = yyval; 1410 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1411 *++yystack.p_mark = yyloc; 1412 #endif 1413 goto yyloop; 1414 #if YYBTYACC 1415 1416 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1417 yyvalid: 1418 if (yypath) YYABORT; 1419 while (yyps->save) 1420 { 1421 YYParseState *save = yyps->save; 1422 yyps->save = save->save; 1423 save->save = yypath; 1424 yypath = save; 1425 } 1426 #if YYDEBUG 1427 if (yydebug) 1428 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1429 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1430 #endif 1431 if (yyerrctx) 1432 { 1433 yyFreeState(yyerrctx); 1434 yyerrctx = NULL; 1435 } 1436 yylvp = yylvals + yypath->lexeme; 1437 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1438 yylpp = yylpsns + yypath->lexeme; 1439 #endif 1440 yylexp = yylexemes + yypath->lexeme; 1441 yychar = YYEMPTY; 1442 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1443 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1444 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1445 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1446 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1447 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1448 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1449 #endif 1450 yystate = yypath->state; 1451 goto yyloop; 1452 #endif /* YYBTYACC */ 1453 1454 yyoverflow: 1455 YYERROR_CALL("yacc stack overflow"); 1456 #if YYBTYACC 1457 goto yyabort_nomem; 1458 yyenomem: 1459 YYERROR_CALL("memory exhausted"); 1460 yyabort_nomem: 1461 #endif /* YYBTYACC */ 1462 yyresult = 2; 1463 goto yyreturn; 1464 1465 yyabort: 1466 yyresult = 1; 1467 goto yyreturn; 1468 1469 yyaccept: 1470 #if YYBTYACC 1471 if (yyps->save) goto yyvalid; 1472 #endif /* YYBTYACC */ 1473 yyresult = 0; 1474 1475 yyreturn: 1476 #if defined(YYDESTRUCT_CALL) 1477 if (yychar != YYEOF && yychar != YYEMPTY) 1478 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1479 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1480 #else 1481 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1482 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1483 1484 { 1485 YYSTYPE *pv; 1486 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1487 YYLTYPE *pp; 1488 1489 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1490 YYDESTRUCT_CALL("cleanup: discarding state", 1491 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1492 #else 1493 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1494 YYDESTRUCT_CALL("cleanup: discarding state", 1495 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1496 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1497 } 1498 #endif /* defined(YYDESTRUCT_CALL) */ 1499 1500 #if YYBTYACC 1501 if (yyerrctx) 1502 { 1503 yyFreeState(yyerrctx); 1504 yyerrctx = NULL; 1505 } 1506 while (yyps) 1507 { 1508 YYParseState *save = yyps; 1509 yyps = save->save; 1510 save->save = NULL; 1511 yyFreeState(save); 1512 } 1513 while (yypath) 1514 { 1515 YYParseState *save = yypath; 1516 yypath = save->save; 1517 save->save = NULL; 1518 yyFreeState(save); 1519 } 1520 #endif /* YYBTYACC */ 1521 yyfreestack(&yystack); 1522 return (yyresult); 1523 } 1524
Indexes created Wed Mar 25 00:23:37 UTC 2026