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