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