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