pure_calc.tab.c revision 264790
1264790Sbapt/* original parser id follows */ 2264790Sbapt/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3264790Sbapt/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 4264790Sbapt 5264790Sbapt#define YYBYACC 1 6264790Sbapt#define YYMAJOR 1 7264790Sbapt#define YYMINOR 9 8264790Sbapt#define YYCHECK "yyyymmdd" 9264790Sbapt 10264790Sbapt#define YYEMPTY (-1) 11264790Sbapt#define yyclearin (yychar = YYEMPTY) 12264790Sbapt#define yyerrok (yyerrflag = 0) 13264790Sbapt#define YYRECOVERING() (yyerrflag != 0) 14264790Sbapt#define YYENOMEM (-2) 15264790Sbapt#define YYEOF 0 16264790Sbapt#undef YYBTYACC 17264790Sbapt#define YYBTYACC 0 18264790Sbapt#define YYDEBUGSTR YYPREFIX "debug" 19264790Sbapt 20264790Sbapt#ifndef yyparse 21264790Sbapt#define yyparse calc_parse 22264790Sbapt#endif /* yyparse */ 23264790Sbapt 24264790Sbapt#ifndef yylex 25264790Sbapt#define yylex calc_lex 26264790Sbapt#endif /* yylex */ 27264790Sbapt 28264790Sbapt#ifndef yyerror 29264790Sbapt#define yyerror calc_error 30264790Sbapt#endif /* yyerror */ 31264790Sbapt 32264790Sbapt#ifndef yychar 33264790Sbapt#define yychar calc_char 34264790Sbapt#endif /* yychar */ 35264790Sbapt 36264790Sbapt#ifndef yyval 37264790Sbapt#define yyval calc_val 38264790Sbapt#endif /* yyval */ 39264790Sbapt 40264790Sbapt#ifndef yylval 41264790Sbapt#define yylval calc_lval 42264790Sbapt#endif /* yylval */ 43264790Sbapt 44264790Sbapt#ifndef yydebug 45264790Sbapt#define yydebug calc_debug 46264790Sbapt#endif /* yydebug */ 47264790Sbapt 48264790Sbapt#ifndef yynerrs 49264790Sbapt#define yynerrs calc_nerrs 50264790Sbapt#endif /* yynerrs */ 51264790Sbapt 52264790Sbapt#ifndef yyerrflag 53264790Sbapt#define yyerrflag calc_errflag 54264790Sbapt#endif /* yyerrflag */ 55264790Sbapt 56264790Sbapt#ifndef yylhs 57264790Sbapt#define yylhs calc_lhs 58264790Sbapt#endif /* yylhs */ 59264790Sbapt 60264790Sbapt#ifndef yylen 61264790Sbapt#define yylen calc_len 62264790Sbapt#endif /* yylen */ 63264790Sbapt 64264790Sbapt#ifndef yydefred 65264790Sbapt#define yydefred calc_defred 66264790Sbapt#endif /* yydefred */ 67264790Sbapt 68264790Sbapt#ifndef yystos 69264790Sbapt#define yystos calc_stos 70264790Sbapt#endif /* yystos */ 71264790Sbapt 72264790Sbapt#ifndef yydgoto 73264790Sbapt#define yydgoto calc_dgoto 74264790Sbapt#endif /* yydgoto */ 75264790Sbapt 76264790Sbapt#ifndef yysindex 77264790Sbapt#define yysindex calc_sindex 78264790Sbapt#endif /* yysindex */ 79264790Sbapt 80264790Sbapt#ifndef yyrindex 81264790Sbapt#define yyrindex calc_rindex 82264790Sbapt#endif /* yyrindex */ 83264790Sbapt 84264790Sbapt#ifndef yygindex 85264790Sbapt#define yygindex calc_gindex 86264790Sbapt#endif /* yygindex */ 87264790Sbapt 88264790Sbapt#ifndef yytable 89264790Sbapt#define yytable calc_table 90264790Sbapt#endif /* yytable */ 91264790Sbapt 92264790Sbapt#ifndef yycheck 93264790Sbapt#define yycheck calc_check 94264790Sbapt#endif /* yycheck */ 95264790Sbapt 96264790Sbapt#ifndef yyname 97264790Sbapt#define yyname calc_name 98264790Sbapt#endif /* yyname */ 99264790Sbapt 100264790Sbapt#ifndef yyrule 101264790Sbapt#define yyrule calc_rule 102264790Sbapt#endif /* yyrule */ 103264790Sbapt 104264790Sbapt#if YYBTYACC 105264790Sbapt 106264790Sbapt#ifndef yycindex 107264790Sbapt#define yycindex calc_cindex 108264790Sbapt#endif /* yycindex */ 109264790Sbapt 110264790Sbapt#ifndef yyctable 111264790Sbapt#define yyctable calc_ctable 112264790Sbapt#endif /* yyctable */ 113264790Sbapt 114264790Sbapt#endif /* YYBTYACC */ 115264790Sbapt 116264790Sbapt#define YYPREFIX "calc_" 117264790Sbapt 118264790Sbapt#define YYPURE 1 119264790Sbapt 120264790Sbapt#line 2 "pure_calc.y" 121264790Sbapt# include <stdio.h> 122264790Sbapt# include <ctype.h> 123264790Sbapt 124264790Sbaptint regs[26]; 125264790Sbaptint base; 126264790Sbapt 127264790Sbapt#ifdef YYBISON 128264790Sbapt#define YYSTYPE int 129264790Sbapt#define YYLEX_PARAM &yylval 130264790Sbapt#define YYLEX_DECL() yylex(YYSTYPE *yylval) 131264790Sbapt#define YYERROR_DECL() yyerror(const char *s) 132264790Sbaptint YYLEX_DECL(); 133264790Sbaptstatic void YYERROR_DECL(); 134264790Sbapt#endif 135264790Sbapt 136264790Sbapt#line 137 "pure_calc.tab.c" 137264790Sbapt 138264790Sbapt#if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED) 139264790Sbapt/* Default: YYSTYPE is the semantic value type. */ 140264790Sbapttypedef int YYSTYPE; 141264790Sbapt# define YYSTYPE_IS_DECLARED 1 142264790Sbapt#endif 143264790Sbapt 144264790Sbapt/* compatibility with bison */ 145264790Sbapt#ifdef YYPARSE_PARAM 146264790Sbapt/* compatibility with FreeBSD */ 147264790Sbapt# ifdef YYPARSE_PARAM_TYPE 148264790Sbapt# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 149264790Sbapt# else 150264790Sbapt# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 151264790Sbapt# endif 152264790Sbapt#else 153264790Sbapt# define YYPARSE_DECL() yyparse(void) 154264790Sbapt#endif 155264790Sbapt 156264790Sbapt/* Parameters sent to lex. */ 157264790Sbapt#ifdef YYLEX_PARAM 158264790Sbapt# ifdef YYLEX_PARAM_TYPE 159264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM) 160264790Sbapt# else 161264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM) 162264790Sbapt# endif 163264790Sbapt# define YYLEX yylex(&yylval, YYLEX_PARAM) 164264790Sbapt#else 165264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval) 166264790Sbapt# define YYLEX yylex(&yylval) 167264790Sbapt#endif 168264790Sbapt 169264790Sbapt/* Parameters sent to yyerror. */ 170264790Sbapt#ifndef YYERROR_DECL 171264790Sbapt#define YYERROR_DECL() yyerror(const char *s) 172264790Sbapt#endif 173264790Sbapt#ifndef YYERROR_CALL 174264790Sbapt#define YYERROR_CALL(msg) yyerror(msg) 175264790Sbapt#endif 176264790Sbapt 177264790Sbaptextern int YYPARSE_DECL(); 178264790Sbapt 179264790Sbapt#define DIGIT 257 180264790Sbapt#define LETTER 258 181264790Sbapt#define UMINUS 259 182264790Sbapt#define YYERRCODE 256 183264790Sbapttypedef short YYINT; 184264790Sbaptstatic const YYINT calc_lhs[] = { -1, 185264790Sbapt 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 186264790Sbapt 2, 2, 2, 2, 2, 2, 3, 3, 187264790Sbapt}; 188264790Sbaptstatic const YYINT calc_len[] = { 2, 189264790Sbapt 0, 3, 3, 1, 3, 3, 3, 3, 3, 3, 190264790Sbapt 3, 3, 3, 2, 1, 1, 1, 2, 191264790Sbapt}; 192264790Sbaptstatic const YYINT calc_defred[] = { 1, 193264790Sbapt 0, 0, 17, 0, 0, 0, 0, 0, 0, 3, 194264790Sbapt 0, 15, 14, 0, 2, 0, 0, 0, 0, 0, 195264790Sbapt 0, 0, 18, 0, 6, 0, 0, 0, 0, 9, 196264790Sbapt 10, 11, 197264790Sbapt}; 198264790Sbaptstatic const YYINT calc_stos[] = { 0, 199264790Sbapt 261, 256, 257, 258, 45, 40, 262, 263, 264, 10, 200264790Sbapt 61, 258, 263, 263, 10, 124, 38, 43, 45, 42, 201264790Sbapt 47, 37, 257, 263, 41, 263, 263, 263, 263, 263, 202264790Sbapt 263, 263, 203264790Sbapt}; 204264790Sbaptstatic const YYINT calc_dgoto[] = { 1, 205264790Sbapt 7, 8, 9, 206264790Sbapt}; 207264790Sbaptstatic const YYINT calc_sindex[] = { 0, 208264790Sbapt -40, -7, 0, -55, -38, -38, 1, -29, -247, 0, 209264790Sbapt -38, 0, 0, 22, 0, -38, -38, -38, -38, -38, 210264790Sbapt -38, -38, 0, -29, 0, 51, 60, -20, -20, 0, 211264790Sbapt 0, 0, 212264790Sbapt}; 213264790Sbaptstatic const YYINT calc_rindex[] = { 0, 214264790Sbapt 0, 0, 0, 2, 0, 0, 0, 9, -9, 0, 215264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 216264790Sbapt 0, 0, 0, 10, 0, -6, 14, 5, 13, 0, 217264790Sbapt 0, 0, 218264790Sbapt}; 219264790Sbapt#if YYBTYACC 220264790Sbaptstatic const YYINT calc_cindex[] = { 0, 221264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 222264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 223264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224264790Sbapt 0, 0, 225264790Sbapt}; 226264790Sbapt#endif 227264790Sbaptstatic const YYINT calc_gindex[] = { 0, 228264790Sbapt 0, 65, 0, 229264790Sbapt}; 230264790Sbapt#define YYTABLESIZE 220 231264790Sbaptstatic const YYINT calc_table[] = { 6, 232264790Sbapt 16, 6, 10, 13, 5, 11, 5, 22, 17, 23, 233264790Sbapt 15, 15, 20, 18, 7, 19, 22, 21, 4, 5, 234264790Sbapt 0, 20, 8, 12, 0, 0, 21, 16, 16, 0, 235264790Sbapt 0, 16, 16, 16, 13, 16, 0, 16, 15, 15, 236264790Sbapt 0, 0, 7, 15, 15, 7, 15, 7, 15, 7, 237264790Sbapt 8, 12, 0, 8, 12, 8, 0, 8, 22, 17, 238264790Sbapt 0, 0, 25, 20, 18, 0, 19, 0, 21, 13, 239264790Sbapt 14, 0, 0, 0, 0, 24, 0, 0, 0, 0, 240264790Sbapt 26, 27, 28, 29, 30, 31, 32, 22, 17, 0, 241264790Sbapt 0, 0, 20, 18, 16, 19, 22, 21, 0, 0, 242264790Sbapt 0, 20, 18, 0, 19, 0, 21, 0, 0, 0, 243264790Sbapt 0, 0, 0, 0, 16, 0, 0, 13, 0, 0, 244264790Sbapt 0, 0, 0, 0, 0, 15, 0, 0, 7, 0, 245264790Sbapt 0, 0, 0, 0, 0, 0, 8, 12, 0, 0, 246264790Sbapt 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 247264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 249264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 250264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 251264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253264790Sbapt 0, 0, 0, 0, 0, 2, 3, 4, 3, 12, 254264790Sbapt}; 255264790Sbaptstatic const YYINT calc_check[] = { 40, 256264790Sbapt 10, 40, 10, 10, 45, 61, 45, 37, 38, 257, 257264790Sbapt 10, 10, 42, 43, 10, 45, 37, 47, 10, 10, 258264790Sbapt -1, 42, 10, 10, -1, -1, 47, 37, 38, -1, 259264790Sbapt -1, 41, 42, 43, 41, 45, -1, 47, 37, 38, 260264790Sbapt -1, -1, 38, 42, 43, 41, 45, 43, 47, 45, 261264790Sbapt 38, 38, -1, 41, 41, 43, -1, 45, 37, 38, 262264790Sbapt -1, -1, 41, 42, 43, -1, 45, -1, 47, 5, 263264790Sbapt 6, -1, -1, -1, -1, 11, -1, -1, -1, -1, 264264790Sbapt 16, 17, 18, 19, 20, 21, 22, 37, 38, -1, 265264790Sbapt -1, -1, 42, 43, 124, 45, 37, 47, -1, -1, 266264790Sbapt -1, 42, 43, -1, 45, -1, 47, -1, -1, -1, 267264790Sbapt -1, -1, -1, -1, 124, -1, -1, 124, -1, -1, 268264790Sbapt -1, -1, -1, -1, -1, 124, -1, -1, 124, -1, 269264790Sbapt -1, -1, -1, -1, -1, -1, 124, 124, -1, -1, 270264790Sbapt -1, -1, -1, -1, -1, 124, -1, -1, -1, -1, 271264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 272264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 273264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 274264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 275264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 276264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 277264790Sbapt -1, -1, -1, -1, -1, 256, 257, 258, 257, 258, 278264790Sbapt}; 279264790Sbapt#define YYFINAL 1 280264790Sbapt#ifndef YYDEBUG 281264790Sbapt#define YYDEBUG 0 282264790Sbapt#endif 283264790Sbapt#define YYMAXTOKEN 259 284264790Sbapt#define YYUNDFTOKEN 265 285264790Sbapt#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 286264790Sbapt#if YYDEBUG 287264790Sbaptstatic const char *const calc_name[] = { 288264790Sbapt 289264790Sbapt"$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, 290264790Sbapt0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0, 291264790Sbapt0,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, 292264790Sbapt0,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, 293264790Sbapt0,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, 294264790Sbapt0,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, 295264790Sbapt0,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, 296264790Sbapt0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number", 297264790Sbapt"illegal-symbol", 298264790Sbapt}; 299264790Sbaptstatic const char *const calc_rule[] = { 300264790Sbapt"$accept : list", 301264790Sbapt"list :", 302264790Sbapt"list : list stat '\\n'", 303264790Sbapt"list : list error '\\n'", 304264790Sbapt"stat : expr", 305264790Sbapt"stat : LETTER '=' expr", 306264790Sbapt"expr : '(' expr ')'", 307264790Sbapt"expr : expr '+' expr", 308264790Sbapt"expr : expr '-' expr", 309264790Sbapt"expr : expr '*' expr", 310264790Sbapt"expr : expr '/' expr", 311264790Sbapt"expr : expr '%' expr", 312264790Sbapt"expr : expr '&' expr", 313264790Sbapt"expr : expr '|' expr", 314264790Sbapt"expr : '-' expr", 315264790Sbapt"expr : LETTER", 316264790Sbapt"expr : number", 317264790Sbapt"number : DIGIT", 318264790Sbapt"number : number DIGIT", 319264790Sbapt 320264790Sbapt}; 321264790Sbapt#endif 322264790Sbapt 323264790Sbaptint yydebug; 324264790Sbaptint yynerrs; 325264790Sbapt 326264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 327264790Sbapt#ifndef YYLLOC_DEFAULT 328264790Sbapt#define YYLLOC_DEFAULT(loc, rhs, n) \ 329264790Sbaptdo \ 330264790Sbapt{ \ 331264790Sbapt if (n == 0) \ 332264790Sbapt { \ 333264790Sbapt (loc).first_line = ((rhs)[-1]).last_line; \ 334264790Sbapt (loc).first_column = ((rhs)[-1]).last_column; \ 335264790Sbapt (loc).last_line = ((rhs)[-1]).last_line; \ 336264790Sbapt (loc).last_column = ((rhs)[-1]).last_column; \ 337264790Sbapt } \ 338264790Sbapt else \ 339264790Sbapt { \ 340264790Sbapt (loc).first_line = ((rhs)[ 0 ]).first_line; \ 341264790Sbapt (loc).first_column = ((rhs)[ 0 ]).first_column; \ 342264790Sbapt (loc).last_line = ((rhs)[n-1]).last_line; \ 343264790Sbapt (loc).last_column = ((rhs)[n-1]).last_column; \ 344264790Sbapt } \ 345264790Sbapt} while (0) 346264790Sbapt#endif /* YYLLOC_DEFAULT */ 347264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 348264790Sbapt#if YYBTYACC 349264790Sbapt 350264790Sbapt#ifndef YYLVQUEUEGROWTH 351264790Sbapt#define YYLVQUEUEGROWTH 32 352264790Sbapt#endif 353264790Sbapt#endif /* YYBTYACC */ 354264790Sbapt 355264790Sbapt/* define the initial stack-sizes */ 356264790Sbapt#ifdef YYSTACKSIZE 357264790Sbapt#undef YYMAXDEPTH 358264790Sbapt#define YYMAXDEPTH YYSTACKSIZE 359264790Sbapt#else 360264790Sbapt#ifdef YYMAXDEPTH 361264790Sbapt#define YYSTACKSIZE YYMAXDEPTH 362264790Sbapt#else 363264790Sbapt#define YYSTACKSIZE 10000 364264790Sbapt#define YYMAXDEPTH 10000 365264790Sbapt#endif 366264790Sbapt#endif 367264790Sbapt 368264790Sbapt#ifndef YYINITSTACKSIZE 369264790Sbapt#define YYINITSTACKSIZE 200 370264790Sbapt#endif 371264790Sbapt 372264790Sbapttypedef struct { 373264790Sbapt unsigned stacksize; 374264790Sbapt short *s_base; 375264790Sbapt short *s_mark; 376264790Sbapt short *s_last; 377264790Sbapt YYSTYPE *l_base; 378264790Sbapt YYSTYPE *l_mark; 379264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 380264790Sbapt YYLTYPE *p_base; 381264790Sbapt YYLTYPE *p_mark; 382264790Sbapt#endif 383264790Sbapt} YYSTACKDATA; 384264790Sbapt#if YYBTYACC 385264790Sbapt 386264790Sbaptstruct YYParseState_s 387264790Sbapt{ 388264790Sbapt struct YYParseState_s *save; /* Previously saved parser state */ 389264790Sbapt YYSTACKDATA yystack; /* saved parser stack */ 390264790Sbapt int state; /* saved parser state */ 391264790Sbapt int errflag; /* saved error recovery status */ 392264790Sbapt int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 393264790Sbapt YYINT ctry; /* saved index in yyctable[] for this conflict */ 394264790Sbapt}; 395264790Sbapttypedef struct YYParseState_s YYParseState; 396264790Sbapt#endif /* YYBTYACC */ 397264790Sbapt#line 72 "pure_calc.y" 398264790Sbapt /* start of programs */ 399264790Sbapt 400264790Sbapt#ifdef YYBYACC 401264790Sbaptstatic int YYLEX_DECL(); 402264790Sbapt#endif 403264790Sbapt 404264790Sbaptint 405264790Sbaptmain (void) 406264790Sbapt{ 407264790Sbapt while(!feof(stdin)) { 408264790Sbapt yyparse(); 409264790Sbapt } 410264790Sbapt return 0; 411264790Sbapt} 412264790Sbapt 413264790Sbaptstatic void 414264790SbaptYYERROR_DECL() 415264790Sbapt{ 416264790Sbapt fprintf(stderr, "%s\n", s); 417264790Sbapt} 418264790Sbapt 419264790Sbaptint 420264790SbaptYYLEX_DECL() 421264790Sbapt{ 422264790Sbapt /* lexical analysis routine */ 423264790Sbapt /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 424264790Sbapt /* return DIGIT for a digit, yylval = 0 through 9 */ 425264790Sbapt /* all other characters are returned immediately */ 426264790Sbapt 427264790Sbapt int c; 428264790Sbapt 429264790Sbapt while( (c=getchar()) == ' ' ) { /* skip blanks */ } 430264790Sbapt 431264790Sbapt /* c is now nonblank */ 432264790Sbapt 433264790Sbapt if( islower( c )) { 434264790Sbapt *yylval = c - 'a'; 435264790Sbapt return ( LETTER ); 436264790Sbapt } 437264790Sbapt if( isdigit( c )) { 438264790Sbapt *yylval = c - '0'; 439264790Sbapt return ( DIGIT ); 440264790Sbapt } 441264790Sbapt return( c ); 442264790Sbapt} 443264790Sbapt#line 444 "pure_calc.tab.c" 444264790Sbapt 445264790Sbapt/* For use in generated program */ 446264790Sbapt#define yydepth (int)(yystack.s_mark - yystack.s_base) 447264790Sbapt#if YYBTYACC 448264790Sbapt#define yytrial (yyps->save) 449264790Sbapt#endif /* YYBTYACC */ 450264790Sbapt 451264790Sbapt#if YYDEBUG 452264790Sbapt#include <stdio.h> /* needed for printf */ 453264790Sbapt#endif 454264790Sbapt 455264790Sbapt#include <stdlib.h> /* needed for malloc, etc */ 456264790Sbapt#include <string.h> /* needed for memset */ 457264790Sbapt 458264790Sbapt/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 459264790Sbaptstatic int yygrowstack(YYSTACKDATA *data) 460264790Sbapt{ 461264790Sbapt int i; 462264790Sbapt unsigned newsize; 463264790Sbapt short *newss; 464264790Sbapt YYSTYPE *newvs; 465264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 466264790Sbapt YYLTYPE *newps; 467264790Sbapt#endif 468264790Sbapt 469264790Sbapt if ((newsize = data->stacksize) == 0) 470264790Sbapt newsize = YYINITSTACKSIZE; 471264790Sbapt else if (newsize >= YYMAXDEPTH) 472264790Sbapt return YYENOMEM; 473264790Sbapt else if ((newsize *= 2) > YYMAXDEPTH) 474264790Sbapt newsize = YYMAXDEPTH; 475264790Sbapt 476264790Sbapt i = (int) (data->s_mark - data->s_base); 477264790Sbapt newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 478264790Sbapt if (newss == 0) 479264790Sbapt return YYENOMEM; 480264790Sbapt 481264790Sbapt data->s_base = newss; 482264790Sbapt data->s_mark = newss + i; 483264790Sbapt 484264790Sbapt newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 485264790Sbapt if (newvs == 0) 486264790Sbapt return YYENOMEM; 487264790Sbapt 488264790Sbapt data->l_base = newvs; 489264790Sbapt data->l_mark = newvs + i; 490264790Sbapt 491264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 492264790Sbapt newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 493264790Sbapt if (newps == 0) 494264790Sbapt return YYENOMEM; 495264790Sbapt 496264790Sbapt data->p_base = newps; 497264790Sbapt data->p_mark = newps + i; 498264790Sbapt#endif 499264790Sbapt 500264790Sbapt data->stacksize = newsize; 501264790Sbapt data->s_last = data->s_base + newsize - 1; 502264790Sbapt 503264790Sbapt#if YYDEBUG 504264790Sbapt if (yydebug) 505264790Sbapt fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 506264790Sbapt#endif 507264790Sbapt return 0; 508264790Sbapt} 509264790Sbapt 510264790Sbapt#if YYPURE || defined(YY_NO_LEAKS) 511264790Sbaptstatic void yyfreestack(YYSTACKDATA *data) 512264790Sbapt{ 513264790Sbapt free(data->s_base); 514264790Sbapt free(data->l_base); 515264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 516264790Sbapt free(data->p_base); 517264790Sbapt#endif 518264790Sbapt memset(data, 0, sizeof(*data)); 519264790Sbapt} 520264790Sbapt#else 521264790Sbapt#define yyfreestack(data) /* nothing */ 522264790Sbapt#endif /* YYPURE || defined(YY_NO_LEAKS) */ 523264790Sbapt#if YYBTYACC 524264790Sbapt 525264790Sbaptstatic YYParseState * 526264790SbaptyyNewState(unsigned size) 527264790Sbapt{ 528264790Sbapt YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 529264790Sbapt if (p == NULL) return NULL; 530264790Sbapt 531264790Sbapt p->yystack.stacksize = size; 532264790Sbapt if (size == 0) 533264790Sbapt { 534264790Sbapt p->yystack.s_base = NULL; 535264790Sbapt p->yystack.l_base = NULL; 536264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 537264790Sbapt p->yystack.p_base = NULL; 538264790Sbapt#endif 539264790Sbapt return p; 540264790Sbapt } 541264790Sbapt p->yystack.s_base = (short *) malloc(size * sizeof(short)); 542264790Sbapt if (p->yystack.s_base == NULL) return NULL; 543264790Sbapt p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 544264790Sbapt if (p->yystack.l_base == NULL) return NULL; 545264790Sbapt memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 546264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 547264790Sbapt p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 548264790Sbapt if (p->yystack.p_base == NULL) return NULL; 549264790Sbapt memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 550264790Sbapt#endif 551264790Sbapt 552264790Sbapt return p; 553264790Sbapt} 554264790Sbapt 555264790Sbaptstatic void 556264790SbaptyyFreeState(YYParseState *p) 557264790Sbapt{ 558264790Sbapt yyfreestack(&p->yystack); 559264790Sbapt free(p); 560264790Sbapt} 561264790Sbapt#endif /* YYBTYACC */ 562264790Sbapt 563264790Sbapt#define YYABORT goto yyabort 564264790Sbapt#define YYREJECT goto yyabort 565264790Sbapt#define YYACCEPT goto yyaccept 566264790Sbapt#define YYERROR goto yyerrlab 567264790Sbapt#if YYBTYACC 568264790Sbapt#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 569264790Sbapt#define YYVALID_NESTED do { if (yyps->save && \ 570264790Sbapt yyps->save->save == 0) goto yyvalid; } while(0) 571264790Sbapt#endif /* YYBTYACC */ 572264790Sbapt 573264790Sbaptint 574264790SbaptYYPARSE_DECL() 575264790Sbapt{ 576264790Sbapt int yyerrflag; 577264790Sbapt int yychar; 578264790Sbapt YYSTYPE yyval; 579264790Sbapt YYSTYPE yylval; 580264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 581264790Sbapt YYLTYPE yyloc; /* position returned by actions */ 582264790Sbapt YYLTYPE yylloc; /* position from the lexer */ 583264790Sbapt#endif 584264790Sbapt 585264790Sbapt /* variables for the parser stack */ 586264790Sbapt YYSTACKDATA yystack; 587264790Sbapt#if YYBTYACC 588264790Sbapt 589264790Sbapt /* Current parser state */ 590264790Sbapt static YYParseState *yyps = 0; 591264790Sbapt 592264790Sbapt /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 593264790Sbapt static YYParseState *yypath = 0; 594264790Sbapt 595264790Sbapt /* Base of the lexical value queue */ 596264790Sbapt static YYSTYPE *yylvals = 0; 597264790Sbapt 598264790Sbapt /* Current position at lexical value queue */ 599264790Sbapt static YYSTYPE *yylvp = 0; 600264790Sbapt 601264790Sbapt /* End position of lexical value queue */ 602264790Sbapt static YYSTYPE *yylve = 0; 603264790Sbapt 604264790Sbapt /* The last allocated position at the lexical value queue */ 605264790Sbapt static YYSTYPE *yylvlim = 0; 606264790Sbapt 607264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 608264790Sbapt /* Base of the lexical position queue */ 609264790Sbapt static YYLTYPE *yylpsns = 0; 610264790Sbapt 611264790Sbapt /* Current position at lexical position queue */ 612264790Sbapt static YYLTYPE *yylpp = 0; 613264790Sbapt 614264790Sbapt /* End position of lexical position queue */ 615264790Sbapt static YYLTYPE *yylpe = 0; 616264790Sbapt 617264790Sbapt /* The last allocated position at the lexical position queue */ 618264790Sbapt static YYLTYPE *yylplim = 0; 619264790Sbapt#endif 620264790Sbapt 621264790Sbapt /* Current position at lexical token queue */ 622264790Sbapt static short *yylexp = 0; 623264790Sbapt 624264790Sbapt static short *yylexemes = 0; 625264790Sbapt#endif /* YYBTYACC */ 626264790Sbapt int yym, yyn, yystate, yyresult; 627264790Sbapt#if YYBTYACC 628264790Sbapt int yynewerrflag; 629264790Sbapt YYParseState *yyerrctx = NULL; 630264790Sbapt#endif /* YYBTYACC */ 631264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 632264790Sbapt YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 633264790Sbapt#endif 634264790Sbapt#if YYDEBUG 635264790Sbapt const char *yys; 636264790Sbapt 637264790Sbapt if ((yys = getenv("YYDEBUG")) != 0) 638264790Sbapt { 639264790Sbapt yyn = *yys; 640264790Sbapt if (yyn >= '0' && yyn <= '9') 641264790Sbapt yydebug = yyn - '0'; 642264790Sbapt } 643264790Sbapt if (yydebug) 644264790Sbapt fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 645264790Sbapt#endif 646264790Sbapt 647264790Sbapt#if YYBTYACC 648264790Sbapt yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 649264790Sbapt yyps->save = 0; 650264790Sbapt#endif /* YYBTYACC */ 651264790Sbapt yynerrs = 0; 652264790Sbapt yyerrflag = 0; 653264790Sbapt yychar = YYEMPTY; 654264790Sbapt yystate = 0; 655264790Sbapt 656264790Sbapt#if YYPURE 657264790Sbapt memset(&yystack, 0, sizeof(yystack)); 658264790Sbapt#endif 659264790Sbapt 660264790Sbapt if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 661264790Sbapt yystack.s_mark = yystack.s_base; 662264790Sbapt yystack.l_mark = yystack.l_base; 663264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 664264790Sbapt yystack.p_mark = yystack.p_base; 665264790Sbapt#endif 666264790Sbapt yystate = 0; 667264790Sbapt *yystack.s_mark = 0; 668264790Sbapt 669264790Sbaptyyloop: 670264790Sbapt if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 671264790Sbapt if (yychar < 0) 672264790Sbapt { 673264790Sbapt#if YYBTYACC 674264790Sbapt do { 675264790Sbapt if (yylvp < yylve) 676264790Sbapt { 677264790Sbapt /* we're currently re-reading tokens */ 678264790Sbapt yylval = *yylvp++; 679264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 680264790Sbapt yylloc = *yylpp++; 681264790Sbapt#endif 682264790Sbapt yychar = *yylexp++; 683264790Sbapt break; 684264790Sbapt } 685264790Sbapt if (yyps->save) 686264790Sbapt { 687264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 688264790Sbapt if (yylvp == yylvlim) 689264790Sbapt { /* Enlarge lexical value queue */ 690264790Sbapt int p = yylvp - yylvals; 691264790Sbapt int s = yylvlim - yylvals; 692264790Sbapt 693264790Sbapt s += YYLVQUEUEGROWTH; 694264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 695264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 696264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 697264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 698264790Sbapt#endif 699264790Sbapt yylvp = yylve = yylvals + p; 700264790Sbapt yylvlim = yylvals + s; 701264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 702264790Sbapt yylpp = yylpe = yylpsns + p; 703264790Sbapt yylplim = yylpsns + s; 704264790Sbapt#endif 705264790Sbapt yylexp = yylexemes + p; 706264790Sbapt } 707264790Sbapt *yylexp = (short) YYLEX; 708264790Sbapt *yylvp++ = yylval; 709264790Sbapt yylve++; 710264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 711264790Sbapt *yylpp++ = yylloc; 712264790Sbapt yylpe++; 713264790Sbapt#endif 714264790Sbapt yychar = *yylexp++; 715264790Sbapt break; 716264790Sbapt } 717264790Sbapt /* normal operation, no conflict encountered */ 718264790Sbapt#endif /* YYBTYACC */ 719264790Sbapt yychar = YYLEX; 720264790Sbapt#if YYBTYACC 721264790Sbapt } while (0); 722264790Sbapt#endif /* YYBTYACC */ 723264790Sbapt if (yychar < 0) yychar = YYEOF; 724264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 725264790Sbapt#if YYDEBUG 726264790Sbapt if (yydebug) 727264790Sbapt { 728264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 729264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 730264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 731264790Sbapt#ifdef YYSTYPE_TOSTRING 732264790Sbapt#if YYBTYACC 733264790Sbapt if (!yytrial) 734264790Sbapt#endif /* YYBTYACC */ 735264790Sbapt fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 736264790Sbapt#endif 737264790Sbapt fputc('\n', stderr); 738264790Sbapt } 739264790Sbapt#endif 740264790Sbapt } 741264790Sbapt#if YYBTYACC 742264790Sbapt 743264790Sbapt /* Do we have a conflict? */ 744264790Sbapt if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 745264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 746264790Sbapt { 747264790Sbapt YYINT ctry; 748264790Sbapt 749264790Sbapt if (yypath) 750264790Sbapt { 751264790Sbapt YYParseState *save; 752264790Sbapt#if YYDEBUG 753264790Sbapt if (yydebug) 754264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 755264790Sbapt YYDEBUGSTR, yydepth, yystate); 756264790Sbapt#endif 757264790Sbapt /* Switch to the next conflict context */ 758264790Sbapt save = yypath; 759264790Sbapt yypath = save->save; 760264790Sbapt save->save = NULL; 761264790Sbapt ctry = save->ctry; 762264790Sbapt if (save->state != yystate) YYABORT; 763264790Sbapt yyFreeState(save); 764264790Sbapt 765264790Sbapt } 766264790Sbapt else 767264790Sbapt { 768264790Sbapt 769264790Sbapt /* Unresolved conflict - start/continue trial parse */ 770264790Sbapt YYParseState *save; 771264790Sbapt#if YYDEBUG 772264790Sbapt if (yydebug) 773264790Sbapt { 774264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 775264790Sbapt if (yyps->save) 776264790Sbapt fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 777264790Sbapt else 778264790Sbapt fputs("Starting trial parse.\n", stderr); 779264790Sbapt } 780264790Sbapt#endif 781264790Sbapt save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 782264790Sbapt if (save == NULL) goto yyenomem; 783264790Sbapt save->save = yyps->save; 784264790Sbapt save->state = yystate; 785264790Sbapt save->errflag = yyerrflag; 786264790Sbapt save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 787264790Sbapt memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 788264790Sbapt save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 789264790Sbapt memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 790264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 791264790Sbapt save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 792264790Sbapt memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 793264790Sbapt#endif 794264790Sbapt ctry = yytable[yyn]; 795264790Sbapt if (yyctable[ctry] == -1) 796264790Sbapt { 797264790Sbapt#if YYDEBUG 798264790Sbapt if (yydebug && yychar >= YYEOF) 799264790Sbapt fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 800264790Sbapt#endif 801264790Sbapt ctry++; 802264790Sbapt } 803264790Sbapt save->ctry = ctry; 804264790Sbapt if (yyps->save == NULL) 805264790Sbapt { 806264790Sbapt /* If this is a first conflict in the stack, start saving lexemes */ 807264790Sbapt if (!yylexemes) 808264790Sbapt { 809264790Sbapt yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 810264790Sbapt if (yylexemes == NULL) goto yyenomem; 811264790Sbapt yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 812264790Sbapt if (yylvals == NULL) goto yyenomem; 813264790Sbapt yylvlim = yylvals + YYLVQUEUEGROWTH; 814264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 815264790Sbapt yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 816264790Sbapt if (yylpsns == NULL) goto yyenomem; 817264790Sbapt yylplim = yylpsns + YYLVQUEUEGROWTH; 818264790Sbapt#endif 819264790Sbapt } 820264790Sbapt if (yylvp == yylve) 821264790Sbapt { 822264790Sbapt yylvp = yylve = yylvals; 823264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 824264790Sbapt yylpp = yylpe = yylpsns; 825264790Sbapt#endif 826264790Sbapt yylexp = yylexemes; 827264790Sbapt if (yychar >= YYEOF) 828264790Sbapt { 829264790Sbapt *yylve++ = yylval; 830264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 831264790Sbapt *yylpe++ = yylloc; 832264790Sbapt#endif 833264790Sbapt *yylexp = (short) yychar; 834264790Sbapt yychar = YYEMPTY; 835264790Sbapt } 836264790Sbapt } 837264790Sbapt } 838264790Sbapt if (yychar >= YYEOF) 839264790Sbapt { 840264790Sbapt yylvp--; 841264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 842264790Sbapt yylpp--; 843264790Sbapt#endif 844264790Sbapt yylexp--; 845264790Sbapt yychar = YYEMPTY; 846264790Sbapt } 847264790Sbapt save->lexeme = yylvp - yylvals; 848264790Sbapt yyps->save = save; 849264790Sbapt } 850264790Sbapt if (yytable[yyn] == ctry) 851264790Sbapt { 852264790Sbapt#if YYDEBUG 853264790Sbapt if (yydebug) 854264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 855264790Sbapt YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 856264790Sbapt#endif 857264790Sbapt if (yychar < 0) 858264790Sbapt { 859264790Sbapt yylvp++; 860264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 861264790Sbapt yylpp++; 862264790Sbapt#endif 863264790Sbapt yylexp++; 864264790Sbapt } 865264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 866264790Sbapt goto yyoverflow; 867264790Sbapt yystate = yyctable[ctry]; 868264790Sbapt *++yystack.s_mark = (short) yystate; 869264790Sbapt *++yystack.l_mark = yylval; 870264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 871264790Sbapt *++yystack.p_mark = yylloc; 872264790Sbapt#endif 873264790Sbapt yychar = YYEMPTY; 874264790Sbapt if (yyerrflag > 0) --yyerrflag; 875264790Sbapt goto yyloop; 876264790Sbapt } 877264790Sbapt else 878264790Sbapt { 879264790Sbapt yyn = yyctable[ctry]; 880264790Sbapt goto yyreduce; 881264790Sbapt } 882264790Sbapt } /* End of code dealing with conflicts */ 883264790Sbapt#endif /* YYBTYACC */ 884264790Sbapt if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 885264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 886264790Sbapt { 887264790Sbapt#if YYDEBUG 888264790Sbapt if (yydebug) 889264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 890264790Sbapt YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 891264790Sbapt#endif 892264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 893264790Sbapt yystate = yytable[yyn]; 894264790Sbapt *++yystack.s_mark = yytable[yyn]; 895264790Sbapt *++yystack.l_mark = yylval; 896264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 897264790Sbapt *++yystack.p_mark = yylloc; 898264790Sbapt#endif 899264790Sbapt yychar = YYEMPTY; 900264790Sbapt if (yyerrflag > 0) --yyerrflag; 901264790Sbapt goto yyloop; 902264790Sbapt } 903264790Sbapt if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 904264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 905264790Sbapt { 906264790Sbapt yyn = yytable[yyn]; 907264790Sbapt goto yyreduce; 908264790Sbapt } 909264790Sbapt if (yyerrflag != 0) goto yyinrecovery; 910264790Sbapt#if YYBTYACC 911264790Sbapt 912264790Sbapt yynewerrflag = 1; 913264790Sbapt goto yyerrhandler; 914264790Sbapt goto yyerrlab; 915264790Sbapt 916264790Sbaptyyerrlab: 917264790Sbapt yynewerrflag = 0; 918264790Sbaptyyerrhandler: 919264790Sbapt while (yyps->save) 920264790Sbapt { 921264790Sbapt int ctry; 922264790Sbapt YYParseState *save = yyps->save; 923264790Sbapt#if YYDEBUG 924264790Sbapt if (yydebug) 925264790Sbapt fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 926264790Sbapt YYDEBUGSTR, yydepth, yystate, yyps->save->state, 927264790Sbapt (int)(yylvp - yylvals - yyps->save->lexeme)); 928264790Sbapt#endif 929264790Sbapt /* Memorize most forward-looking error state in case it's really an error. */ 930264790Sbapt if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 931264790Sbapt { 932264790Sbapt /* Free old saved error context state */ 933264790Sbapt if (yyerrctx) yyFreeState(yyerrctx); 934264790Sbapt /* Create and fill out new saved error context state */ 935264790Sbapt yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 936264790Sbapt if (yyerrctx == NULL) goto yyenomem; 937264790Sbapt yyerrctx->save = yyps->save; 938264790Sbapt yyerrctx->state = yystate; 939264790Sbapt yyerrctx->errflag = yyerrflag; 940264790Sbapt yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 941264790Sbapt memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 942264790Sbapt yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 943264790Sbapt memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 944264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 945264790Sbapt yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 946264790Sbapt memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 947264790Sbapt#endif 948264790Sbapt yyerrctx->lexeme = yylvp - yylvals; 949264790Sbapt } 950264790Sbapt yylvp = yylvals + save->lexeme; 951264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 952264790Sbapt yylpp = yylpsns + save->lexeme; 953264790Sbapt#endif 954264790Sbapt yylexp = yylexemes + save->lexeme; 955264790Sbapt yychar = YYEMPTY; 956264790Sbapt yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 957264790Sbapt memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 958264790Sbapt yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 959264790Sbapt memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 960264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 961264790Sbapt yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 962264790Sbapt memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 963264790Sbapt#endif 964264790Sbapt ctry = ++save->ctry; 965264790Sbapt yystate = save->state; 966264790Sbapt /* We tried shift, try reduce now */ 967264790Sbapt if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 968264790Sbapt yyps->save = save->save; 969264790Sbapt save->save = NULL; 970264790Sbapt yyFreeState(save); 971264790Sbapt 972264790Sbapt /* Nothing left on the stack -- error */ 973264790Sbapt if (!yyps->save) 974264790Sbapt { 975264790Sbapt#if YYDEBUG 976264790Sbapt if (yydebug) 977264790Sbapt fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 978264790Sbapt YYPREFIX, yydepth); 979264790Sbapt#endif 980264790Sbapt /* Restore state as it was in the most forward-advanced error */ 981264790Sbapt yylvp = yylvals + yyerrctx->lexeme; 982264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 983264790Sbapt yylpp = yylpsns + yyerrctx->lexeme; 984264790Sbapt#endif 985264790Sbapt yylexp = yylexemes + yyerrctx->lexeme; 986264790Sbapt yychar = yylexp[-1]; 987264790Sbapt yylval = yylvp[-1]; 988264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 989264790Sbapt yylloc = yylpp[-1]; 990264790Sbapt#endif 991264790Sbapt yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 992264790Sbapt memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 993264790Sbapt yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 994264790Sbapt memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 995264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 996264790Sbapt yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 997264790Sbapt memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 998264790Sbapt#endif 999264790Sbapt yystate = yyerrctx->state; 1000264790Sbapt yyFreeState(yyerrctx); 1001264790Sbapt yyerrctx = NULL; 1002264790Sbapt } 1003264790Sbapt yynewerrflag = 1; 1004264790Sbapt } 1005264790Sbapt if (yynewerrflag == 0) goto yyinrecovery; 1006264790Sbapt#endif /* YYBTYACC */ 1007264790Sbapt 1008264790Sbapt YYERROR_CALL("syntax error"); 1009264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1010264790Sbapt yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1011264790Sbapt#endif 1012264790Sbapt 1013264790Sbapt#if !YYBTYACC 1014264790Sbapt goto yyerrlab; 1015264790Sbaptyyerrlab: 1016264790Sbapt#endif 1017264790Sbapt ++yynerrs; 1018264790Sbapt 1019264790Sbaptyyinrecovery: 1020264790Sbapt if (yyerrflag < 3) 1021264790Sbapt { 1022264790Sbapt yyerrflag = 3; 1023264790Sbapt for (;;) 1024264790Sbapt { 1025264790Sbapt if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1026264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1027264790Sbapt { 1028264790Sbapt#if YYDEBUG 1029264790Sbapt if (yydebug) 1030264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1031264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1032264790Sbapt#endif 1033264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1034264790Sbapt yystate = yytable[yyn]; 1035264790Sbapt *++yystack.s_mark = yytable[yyn]; 1036264790Sbapt *++yystack.l_mark = yylval; 1037264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1038264790Sbapt /* lookahead position is error end position */ 1039264790Sbapt yyerror_loc_range[1] = yylloc; 1040264790Sbapt YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1041264790Sbapt *++yystack.p_mark = yyloc; 1042264790Sbapt#endif 1043264790Sbapt goto yyloop; 1044264790Sbapt } 1045264790Sbapt else 1046264790Sbapt { 1047264790Sbapt#if YYDEBUG 1048264790Sbapt if (yydebug) 1049264790Sbapt fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1050264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark); 1051264790Sbapt#endif 1052264790Sbapt if (yystack.s_mark <= yystack.s_base) goto yyabort; 1053264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1054264790Sbapt /* the current TOS position is the error start position */ 1055264790Sbapt yyerror_loc_range[0] = *yystack.p_mark; 1056264790Sbapt#endif 1057264790Sbapt#if defined(YYDESTRUCT_CALL) 1058264790Sbapt#if YYBTYACC 1059264790Sbapt if (!yytrial) 1060264790Sbapt#endif /* YYBTYACC */ 1061264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1062264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1063264790Sbapt yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1064264790Sbapt#else 1065264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1066264790Sbapt yystos[*yystack.s_mark], yystack.l_mark); 1067264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1068264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1069264790Sbapt --yystack.s_mark; 1070264790Sbapt --yystack.l_mark; 1071264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1072264790Sbapt --yystack.p_mark; 1073264790Sbapt#endif 1074264790Sbapt } 1075264790Sbapt } 1076264790Sbapt } 1077264790Sbapt else 1078264790Sbapt { 1079264790Sbapt if (yychar == YYEOF) goto yyabort; 1080264790Sbapt#if YYDEBUG 1081264790Sbapt if (yydebug) 1082264790Sbapt { 1083264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1084264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1085264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 1086264790Sbapt } 1087264790Sbapt#endif 1088264790Sbapt#if defined(YYDESTRUCT_CALL) 1089264790Sbapt#if YYBTYACC 1090264790Sbapt if (!yytrial) 1091264790Sbapt#endif /* YYBTYACC */ 1092264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1093264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1094264790Sbapt#else 1095264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1096264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1097264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1098264790Sbapt yychar = YYEMPTY; 1099264790Sbapt goto yyloop; 1100264790Sbapt } 1101264790Sbapt 1102264790Sbaptyyreduce: 1103264790Sbapt yym = yylen[yyn]; 1104264790Sbapt#if YYDEBUG 1105264790Sbapt if (yydebug) 1106264790Sbapt { 1107264790Sbapt fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1108264790Sbapt YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1109264790Sbapt#ifdef YYSTYPE_TOSTRING 1110264790Sbapt#if YYBTYACC 1111264790Sbapt if (!yytrial) 1112264790Sbapt#endif /* YYBTYACC */ 1113264790Sbapt if (yym > 0) 1114264790Sbapt { 1115264790Sbapt int i; 1116264790Sbapt fputc('<', stderr); 1117264790Sbapt for (i = yym; i > 0; i--) 1118264790Sbapt { 1119264790Sbapt if (i != yym) fputs(", ", stderr); 1120264790Sbapt fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1121264790Sbapt yystack.l_mark[1-i]), stderr); 1122264790Sbapt } 1123264790Sbapt fputc('>', stderr); 1124264790Sbapt } 1125264790Sbapt#endif 1126264790Sbapt fputc('\n', stderr); 1127264790Sbapt } 1128264790Sbapt#endif 1129264790Sbapt if (yym > 0) 1130264790Sbapt yyval = yystack.l_mark[1-yym]; 1131264790Sbapt else 1132264790Sbapt memset(&yyval, 0, sizeof yyval); 1133264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1134264790Sbapt 1135264790Sbapt /* Perform position reduction */ 1136264790Sbapt memset(&yyloc, 0, sizeof(yyloc)); 1137264790Sbapt#if YYBTYACC 1138264790Sbapt if (!yytrial) 1139264790Sbapt#endif /* YYBTYACC */ 1140264790Sbapt { 1141264790Sbapt YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1142264790Sbapt /* just in case YYERROR is invoked within the action, save 1143264790Sbapt the start of the rhs as the error start position */ 1144264790Sbapt yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1145264790Sbapt } 1146264790Sbapt#endif 1147264790Sbapt 1148264790Sbapt switch (yyn) 1149264790Sbapt { 1150264790Sbaptcase 3: 1151264790Sbapt#line 34 "pure_calc.y" 1152264790Sbapt { yyerrok ; } 1153264790Sbaptbreak; 1154264790Sbaptcase 4: 1155264790Sbapt#line 38 "pure_calc.y" 1156264790Sbapt { printf("%d\n",yystack.l_mark[0]);} 1157264790Sbaptbreak; 1158264790Sbaptcase 5: 1159264790Sbapt#line 40 "pure_calc.y" 1160264790Sbapt { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1161264790Sbaptbreak; 1162264790Sbaptcase 6: 1163264790Sbapt#line 44 "pure_calc.y" 1164264790Sbapt { yyval = yystack.l_mark[-1]; } 1165264790Sbaptbreak; 1166264790Sbaptcase 7: 1167264790Sbapt#line 46 "pure_calc.y" 1168264790Sbapt { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1169264790Sbaptbreak; 1170264790Sbaptcase 8: 1171264790Sbapt#line 48 "pure_calc.y" 1172264790Sbapt { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1173264790Sbaptbreak; 1174264790Sbaptcase 9: 1175264790Sbapt#line 50 "pure_calc.y" 1176264790Sbapt { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1177264790Sbaptbreak; 1178264790Sbaptcase 10: 1179264790Sbapt#line 52 "pure_calc.y" 1180264790Sbapt { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1181264790Sbaptbreak; 1182264790Sbaptcase 11: 1183264790Sbapt#line 54 "pure_calc.y" 1184264790Sbapt { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1185264790Sbaptbreak; 1186264790Sbaptcase 12: 1187264790Sbapt#line 56 "pure_calc.y" 1188264790Sbapt { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1189264790Sbaptbreak; 1190264790Sbaptcase 13: 1191264790Sbapt#line 58 "pure_calc.y" 1192264790Sbapt { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1193264790Sbaptbreak; 1194264790Sbaptcase 14: 1195264790Sbapt#line 60 "pure_calc.y" 1196264790Sbapt { yyval = - yystack.l_mark[0]; } 1197264790Sbaptbreak; 1198264790Sbaptcase 15: 1199264790Sbapt#line 62 "pure_calc.y" 1200264790Sbapt { yyval = regs[yystack.l_mark[0]]; } 1201264790Sbaptbreak; 1202264790Sbaptcase 17: 1203264790Sbapt#line 67 "pure_calc.y" 1204264790Sbapt { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1205264790Sbaptbreak; 1206264790Sbaptcase 18: 1207264790Sbapt#line 69 "pure_calc.y" 1208264790Sbapt { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1209264790Sbaptbreak; 1210264790Sbapt#line 1211 "pure_calc.tab.c" 1211264790Sbapt default: 1212264790Sbapt break; 1213264790Sbapt } 1214264790Sbapt yystack.s_mark -= yym; 1215264790Sbapt yystate = *yystack.s_mark; 1216264790Sbapt yystack.l_mark -= yym; 1217264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1218264790Sbapt yystack.p_mark -= yym; 1219264790Sbapt#endif 1220264790Sbapt yym = yylhs[yyn]; 1221264790Sbapt if (yystate == 0 && yym == 0) 1222264790Sbapt { 1223264790Sbapt#if YYDEBUG 1224264790Sbapt if (yydebug) 1225264790Sbapt { 1226264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1227264790Sbapt#ifdef YYSTYPE_TOSTRING 1228264790Sbapt#if YYBTYACC 1229264790Sbapt if (!yytrial) 1230264790Sbapt#endif /* YYBTYACC */ 1231264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1232264790Sbapt#endif 1233264790Sbapt fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1234264790Sbapt } 1235264790Sbapt#endif 1236264790Sbapt yystate = YYFINAL; 1237264790Sbapt *++yystack.s_mark = YYFINAL; 1238264790Sbapt *++yystack.l_mark = yyval; 1239264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1240264790Sbapt *++yystack.p_mark = yyloc; 1241264790Sbapt#endif 1242264790Sbapt if (yychar < 0) 1243264790Sbapt { 1244264790Sbapt#if YYBTYACC 1245264790Sbapt do { 1246264790Sbapt if (yylvp < yylve) 1247264790Sbapt { 1248264790Sbapt /* we're currently re-reading tokens */ 1249264790Sbapt yylval = *yylvp++; 1250264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1251264790Sbapt yylloc = *yylpp++; 1252264790Sbapt#endif 1253264790Sbapt yychar = *yylexp++; 1254264790Sbapt break; 1255264790Sbapt } 1256264790Sbapt if (yyps->save) 1257264790Sbapt { 1258264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 1259264790Sbapt if (yylvp == yylvlim) 1260264790Sbapt { /* Enlarge lexical value queue */ 1261264790Sbapt int p = yylvp - yylvals; 1262264790Sbapt int s = yylvlim - yylvals; 1263264790Sbapt 1264264790Sbapt s += YYLVQUEUEGROWTH; 1265264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1266264790Sbapt goto yyenomem; 1267264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1268264790Sbapt goto yyenomem; 1269264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1270264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1271264790Sbapt goto yyenomem; 1272264790Sbapt#endif 1273264790Sbapt yylvp = yylve = yylvals + p; 1274264790Sbapt yylvlim = yylvals + s; 1275264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1276264790Sbapt yylpp = yylpe = yylpsns + p; 1277264790Sbapt yylplim = yylpsns + s; 1278264790Sbapt#endif 1279264790Sbapt yylexp = yylexemes + p; 1280264790Sbapt } 1281264790Sbapt *yylexp = (short) YYLEX; 1282264790Sbapt *yylvp++ = yylval; 1283264790Sbapt yylve++; 1284264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1285264790Sbapt *yylpp++ = yylloc; 1286264790Sbapt yylpe++; 1287264790Sbapt#endif 1288264790Sbapt yychar = *yylexp++; 1289264790Sbapt break; 1290264790Sbapt } 1291264790Sbapt /* normal operation, no conflict encountered */ 1292264790Sbapt#endif /* YYBTYACC */ 1293264790Sbapt yychar = YYLEX; 1294264790Sbapt#if YYBTYACC 1295264790Sbapt } while (0); 1296264790Sbapt#endif /* YYBTYACC */ 1297264790Sbapt if (yychar < 0) yychar = YYEOF; 1298264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1299264790Sbapt#if YYDEBUG 1300264790Sbapt if (yydebug) 1301264790Sbapt { 1302264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1303264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1304264790Sbapt YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1305264790Sbapt } 1306264790Sbapt#endif 1307264790Sbapt } 1308264790Sbapt if (yychar == YYEOF) goto yyaccept; 1309264790Sbapt goto yyloop; 1310264790Sbapt } 1311264790Sbapt if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1312264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1313264790Sbapt yystate = yytable[yyn]; 1314264790Sbapt else 1315264790Sbapt yystate = yydgoto[yym]; 1316264790Sbapt#if YYDEBUG 1317264790Sbapt if (yydebug) 1318264790Sbapt { 1319264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1320264790Sbapt#ifdef YYSTYPE_TOSTRING 1321264790Sbapt#if YYBTYACC 1322264790Sbapt if (!yytrial) 1323264790Sbapt#endif /* YYBTYACC */ 1324264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1325264790Sbapt#endif 1326264790Sbapt fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1327264790Sbapt } 1328264790Sbapt#endif 1329264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1330264790Sbapt *++yystack.s_mark = (short) yystate; 1331264790Sbapt *++yystack.l_mark = yyval; 1332264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1333264790Sbapt *++yystack.p_mark = yyloc; 1334264790Sbapt#endif 1335264790Sbapt goto yyloop; 1336264790Sbapt#if YYBTYACC 1337264790Sbapt 1338264790Sbapt /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1339264790Sbaptyyvalid: 1340264790Sbapt if (yypath) YYABORT; 1341264790Sbapt while (yyps->save) 1342264790Sbapt { 1343264790Sbapt YYParseState *save = yyps->save; 1344264790Sbapt yyps->save = save->save; 1345264790Sbapt save->save = yypath; 1346264790Sbapt yypath = save; 1347264790Sbapt } 1348264790Sbapt#if YYDEBUG 1349264790Sbapt if (yydebug) 1350264790Sbapt fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1351264790Sbapt YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1352264790Sbapt#endif 1353264790Sbapt if (yyerrctx) 1354264790Sbapt { 1355264790Sbapt yyFreeState(yyerrctx); 1356264790Sbapt yyerrctx = NULL; 1357264790Sbapt } 1358264790Sbapt yylvp = yylvals + yypath->lexeme; 1359264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1360264790Sbapt yylpp = yylpsns + yypath->lexeme; 1361264790Sbapt#endif 1362264790Sbapt yylexp = yylexemes + yypath->lexeme; 1363264790Sbapt yychar = YYEMPTY; 1364264790Sbapt yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1365264790Sbapt memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1366264790Sbapt yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1367264790Sbapt memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1368264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1369264790Sbapt yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1370264790Sbapt memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1371264790Sbapt#endif 1372264790Sbapt yystate = yypath->state; 1373264790Sbapt goto yyloop; 1374264790Sbapt#endif /* YYBTYACC */ 1375264790Sbapt 1376264790Sbaptyyoverflow: 1377264790Sbapt YYERROR_CALL("yacc stack overflow"); 1378264790Sbapt#if YYBTYACC 1379264790Sbapt goto yyabort_nomem; 1380264790Sbaptyyenomem: 1381264790Sbapt YYERROR_CALL("memory exhausted"); 1382264790Sbaptyyabort_nomem: 1383264790Sbapt#endif /* YYBTYACC */ 1384264790Sbapt yyresult = 2; 1385264790Sbapt goto yyreturn; 1386264790Sbapt 1387264790Sbaptyyabort: 1388264790Sbapt yyresult = 1; 1389264790Sbapt goto yyreturn; 1390264790Sbapt 1391264790Sbaptyyaccept: 1392264790Sbapt#if YYBTYACC 1393264790Sbapt if (yyps->save) goto yyvalid; 1394264790Sbapt#endif /* YYBTYACC */ 1395264790Sbapt yyresult = 0; 1396264790Sbapt 1397264790Sbaptyyreturn: 1398264790Sbapt#if defined(YYDESTRUCT_CALL) 1399264790Sbapt if (yychar != YYEOF && yychar != YYEMPTY) 1400264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1401264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1402264790Sbapt#else 1403264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1404264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1405264790Sbapt 1406264790Sbapt { 1407264790Sbapt YYSTYPE *pv; 1408264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1409264790Sbapt YYLTYPE *pp; 1410264790Sbapt 1411264790Sbapt for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1412264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1413264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1414264790Sbapt#else 1415264790Sbapt for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1416264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1417264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1418264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1419264790Sbapt } 1420264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1421264790Sbapt 1422264790Sbapt#if YYBTYACC 1423264790Sbapt if (yyerrctx) 1424264790Sbapt { 1425264790Sbapt yyFreeState(yyerrctx); 1426264790Sbapt yyerrctx = NULL; 1427264790Sbapt } 1428264790Sbapt while (yyps) 1429264790Sbapt { 1430264790Sbapt YYParseState *save = yyps; 1431264790Sbapt yyps = save->save; 1432264790Sbapt save->save = NULL; 1433264790Sbapt yyFreeState(save); 1434264790Sbapt } 1435264790Sbapt while (yypath) 1436264790Sbapt { 1437264790Sbapt YYParseState *save = yypath; 1438264790Sbapt yypath = save->save; 1439264790Sbapt save->save = NULL; 1440264790Sbapt yyFreeState(save); 1441264790Sbapt } 1442264790Sbapt#endif /* YYBTYACC */ 1443264790Sbapt yyfreestack(&yystack); 1444264790Sbapt return (yyresult); 1445264790Sbapt} 1446