1264790Sbapt/* original parser id follows */ 2264790Sbapt/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3272955Srodrigc/* (use YYMAJOR/YYMINOR for ifdefs dependent of 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}; 279272955Srodrigc#if YYBTYACC 280272955Srodrigcstatic const YYINT calc_ctable[] = { -1, 281272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 282272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 283272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 284272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 285272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 286272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 287272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 288272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 289272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 290272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 291272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 292272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 293272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 294272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 295272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 296272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 297272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 298272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 299272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 300272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 301272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 302272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, 303272955Srodrigc}; 304272955Srodrigc#endif 305264790Sbapt#define YYFINAL 1 306264790Sbapt#ifndef YYDEBUG 307264790Sbapt#define YYDEBUG 0 308264790Sbapt#endif 309264790Sbapt#define YYMAXTOKEN 259 310264790Sbapt#define YYUNDFTOKEN 265 311264790Sbapt#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 312264790Sbapt#if YYDEBUG 313264790Sbaptstatic const char *const calc_name[] = { 314264790Sbapt 315264790Sbapt"$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, 316264790Sbapt0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0, 317264790Sbapt0,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, 318264790Sbapt0,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, 319264790Sbapt0,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, 320264790Sbapt0,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, 321264790Sbapt0,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, 322264790Sbapt0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number", 323264790Sbapt"illegal-symbol", 324264790Sbapt}; 325264790Sbaptstatic const char *const calc_rule[] = { 326264790Sbapt"$accept : list", 327264790Sbapt"list :", 328264790Sbapt"list : list stat '\\n'", 329264790Sbapt"list : list error '\\n'", 330264790Sbapt"stat : expr", 331264790Sbapt"stat : LETTER '=' expr", 332264790Sbapt"expr : '(' expr ')'", 333264790Sbapt"expr : expr '+' expr", 334264790Sbapt"expr : expr '-' expr", 335264790Sbapt"expr : expr '*' expr", 336264790Sbapt"expr : expr '/' expr", 337264790Sbapt"expr : expr '%' expr", 338264790Sbapt"expr : expr '&' expr", 339264790Sbapt"expr : expr '|' expr", 340264790Sbapt"expr : '-' expr", 341264790Sbapt"expr : LETTER", 342264790Sbapt"expr : number", 343264790Sbapt"number : DIGIT", 344264790Sbapt"number : number DIGIT", 345264790Sbapt 346264790Sbapt}; 347264790Sbapt#endif 348264790Sbapt 349264790Sbaptint yydebug; 350264790Sbaptint yynerrs; 351264790Sbapt 352264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 353264790Sbapt#ifndef YYLLOC_DEFAULT 354264790Sbapt#define YYLLOC_DEFAULT(loc, rhs, n) \ 355264790Sbaptdo \ 356264790Sbapt{ \ 357264790Sbapt if (n == 0) \ 358264790Sbapt { \ 359264790Sbapt (loc).first_line = ((rhs)[-1]).last_line; \ 360264790Sbapt (loc).first_column = ((rhs)[-1]).last_column; \ 361264790Sbapt (loc).last_line = ((rhs)[-1]).last_line; \ 362264790Sbapt (loc).last_column = ((rhs)[-1]).last_column; \ 363264790Sbapt } \ 364264790Sbapt else \ 365264790Sbapt { \ 366264790Sbapt (loc).first_line = ((rhs)[ 0 ]).first_line; \ 367264790Sbapt (loc).first_column = ((rhs)[ 0 ]).first_column; \ 368264790Sbapt (loc).last_line = ((rhs)[n-1]).last_line; \ 369264790Sbapt (loc).last_column = ((rhs)[n-1]).last_column; \ 370264790Sbapt } \ 371264790Sbapt} while (0) 372264790Sbapt#endif /* YYLLOC_DEFAULT */ 373264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 374264790Sbapt#if YYBTYACC 375264790Sbapt 376264790Sbapt#ifndef YYLVQUEUEGROWTH 377264790Sbapt#define YYLVQUEUEGROWTH 32 378264790Sbapt#endif 379264790Sbapt#endif /* YYBTYACC */ 380264790Sbapt 381264790Sbapt/* define the initial stack-sizes */ 382264790Sbapt#ifdef YYSTACKSIZE 383264790Sbapt#undef YYMAXDEPTH 384264790Sbapt#define YYMAXDEPTH YYSTACKSIZE 385264790Sbapt#else 386264790Sbapt#ifdef YYMAXDEPTH 387264790Sbapt#define YYSTACKSIZE YYMAXDEPTH 388264790Sbapt#else 389264790Sbapt#define YYSTACKSIZE 10000 390264790Sbapt#define YYMAXDEPTH 10000 391264790Sbapt#endif 392264790Sbapt#endif 393264790Sbapt 394264790Sbapt#ifndef YYINITSTACKSIZE 395264790Sbapt#define YYINITSTACKSIZE 200 396264790Sbapt#endif 397264790Sbapt 398264790Sbapttypedef struct { 399264790Sbapt unsigned stacksize; 400264790Sbapt short *s_base; 401264790Sbapt short *s_mark; 402264790Sbapt short *s_last; 403264790Sbapt YYSTYPE *l_base; 404264790Sbapt YYSTYPE *l_mark; 405264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 406264790Sbapt YYLTYPE *p_base; 407264790Sbapt YYLTYPE *p_mark; 408264790Sbapt#endif 409264790Sbapt} YYSTACKDATA; 410264790Sbapt#if YYBTYACC 411264790Sbapt 412264790Sbaptstruct YYParseState_s 413264790Sbapt{ 414264790Sbapt struct YYParseState_s *save; /* Previously saved parser state */ 415264790Sbapt YYSTACKDATA yystack; /* saved parser stack */ 416264790Sbapt int state; /* saved parser state */ 417264790Sbapt int errflag; /* saved error recovery status */ 418264790Sbapt int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 419264790Sbapt YYINT ctry; /* saved index in yyctable[] for this conflict */ 420264790Sbapt}; 421264790Sbapttypedef struct YYParseState_s YYParseState; 422264790Sbapt#endif /* YYBTYACC */ 423264790Sbapt#line 72 "pure_calc.y" 424264790Sbapt /* start of programs */ 425264790Sbapt 426264790Sbapt#ifdef YYBYACC 427264790Sbaptstatic int YYLEX_DECL(); 428264790Sbapt#endif 429264790Sbapt 430264790Sbaptint 431264790Sbaptmain (void) 432264790Sbapt{ 433264790Sbapt while(!feof(stdin)) { 434264790Sbapt yyparse(); 435264790Sbapt } 436264790Sbapt return 0; 437264790Sbapt} 438264790Sbapt 439264790Sbaptstatic void 440264790SbaptYYERROR_DECL() 441264790Sbapt{ 442264790Sbapt fprintf(stderr, "%s\n", s); 443264790Sbapt} 444264790Sbapt 445264790Sbaptint 446264790SbaptYYLEX_DECL() 447264790Sbapt{ 448264790Sbapt /* lexical analysis routine */ 449264790Sbapt /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 450264790Sbapt /* return DIGIT for a digit, yylval = 0 through 9 */ 451264790Sbapt /* all other characters are returned immediately */ 452264790Sbapt 453264790Sbapt int c; 454264790Sbapt 455264790Sbapt while( (c=getchar()) == ' ' ) { /* skip blanks */ } 456264790Sbapt 457264790Sbapt /* c is now nonblank */ 458264790Sbapt 459264790Sbapt if( islower( c )) { 460264790Sbapt *yylval = c - 'a'; 461264790Sbapt return ( LETTER ); 462264790Sbapt } 463264790Sbapt if( isdigit( c )) { 464264790Sbapt *yylval = c - '0'; 465264790Sbapt return ( DIGIT ); 466264790Sbapt } 467264790Sbapt return( c ); 468264790Sbapt} 469272955Srodrigc#line 470 "pure_calc.tab.c" 470264790Sbapt 471264790Sbapt/* For use in generated program */ 472264790Sbapt#define yydepth (int)(yystack.s_mark - yystack.s_base) 473264790Sbapt#if YYBTYACC 474264790Sbapt#define yytrial (yyps->save) 475264790Sbapt#endif /* YYBTYACC */ 476264790Sbapt 477264790Sbapt#if YYDEBUG 478272955Srodrigc#include <stdio.h> /* needed for printf */ 479264790Sbapt#endif 480264790Sbapt 481272955Srodrigc#include <stdlib.h> /* needed for malloc, etc */ 482272955Srodrigc#include <string.h> /* needed for memset */ 483264790Sbapt 484264790Sbapt/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 485264790Sbaptstatic int yygrowstack(YYSTACKDATA *data) 486264790Sbapt{ 487264790Sbapt int i; 488264790Sbapt unsigned newsize; 489264790Sbapt short *newss; 490264790Sbapt YYSTYPE *newvs; 491264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 492264790Sbapt YYLTYPE *newps; 493264790Sbapt#endif 494264790Sbapt 495264790Sbapt if ((newsize = data->stacksize) == 0) 496264790Sbapt newsize = YYINITSTACKSIZE; 497264790Sbapt else if (newsize >= YYMAXDEPTH) 498264790Sbapt return YYENOMEM; 499264790Sbapt else if ((newsize *= 2) > YYMAXDEPTH) 500264790Sbapt newsize = YYMAXDEPTH; 501264790Sbapt 502264790Sbapt i = (int) (data->s_mark - data->s_base); 503264790Sbapt newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 504264790Sbapt if (newss == 0) 505264790Sbapt return YYENOMEM; 506264790Sbapt 507264790Sbapt data->s_base = newss; 508264790Sbapt data->s_mark = newss + i; 509264790Sbapt 510264790Sbapt newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 511264790Sbapt if (newvs == 0) 512264790Sbapt return YYENOMEM; 513264790Sbapt 514264790Sbapt data->l_base = newvs; 515264790Sbapt data->l_mark = newvs + i; 516264790Sbapt 517264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 518264790Sbapt newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 519264790Sbapt if (newps == 0) 520264790Sbapt return YYENOMEM; 521264790Sbapt 522264790Sbapt data->p_base = newps; 523264790Sbapt data->p_mark = newps + i; 524264790Sbapt#endif 525264790Sbapt 526264790Sbapt data->stacksize = newsize; 527264790Sbapt data->s_last = data->s_base + newsize - 1; 528264790Sbapt 529264790Sbapt#if YYDEBUG 530264790Sbapt if (yydebug) 531264790Sbapt fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 532264790Sbapt#endif 533264790Sbapt return 0; 534264790Sbapt} 535264790Sbapt 536264790Sbapt#if YYPURE || defined(YY_NO_LEAKS) 537264790Sbaptstatic void yyfreestack(YYSTACKDATA *data) 538264790Sbapt{ 539264790Sbapt free(data->s_base); 540264790Sbapt free(data->l_base); 541264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 542264790Sbapt free(data->p_base); 543264790Sbapt#endif 544264790Sbapt memset(data, 0, sizeof(*data)); 545264790Sbapt} 546264790Sbapt#else 547264790Sbapt#define yyfreestack(data) /* nothing */ 548264790Sbapt#endif /* YYPURE || defined(YY_NO_LEAKS) */ 549264790Sbapt#if YYBTYACC 550264790Sbapt 551264790Sbaptstatic YYParseState * 552264790SbaptyyNewState(unsigned size) 553264790Sbapt{ 554264790Sbapt YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 555264790Sbapt if (p == NULL) return NULL; 556264790Sbapt 557264790Sbapt p->yystack.stacksize = size; 558264790Sbapt if (size == 0) 559264790Sbapt { 560264790Sbapt p->yystack.s_base = NULL; 561264790Sbapt p->yystack.l_base = NULL; 562264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 563264790Sbapt p->yystack.p_base = NULL; 564264790Sbapt#endif 565264790Sbapt return p; 566264790Sbapt } 567264790Sbapt p->yystack.s_base = (short *) malloc(size * sizeof(short)); 568264790Sbapt if (p->yystack.s_base == NULL) return NULL; 569264790Sbapt p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 570264790Sbapt if (p->yystack.l_base == NULL) return NULL; 571264790Sbapt memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 572264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 573264790Sbapt p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 574264790Sbapt if (p->yystack.p_base == NULL) return NULL; 575264790Sbapt memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 576264790Sbapt#endif 577264790Sbapt 578264790Sbapt return p; 579264790Sbapt} 580264790Sbapt 581264790Sbaptstatic void 582264790SbaptyyFreeState(YYParseState *p) 583264790Sbapt{ 584264790Sbapt yyfreestack(&p->yystack); 585264790Sbapt free(p); 586264790Sbapt} 587264790Sbapt#endif /* YYBTYACC */ 588264790Sbapt 589264790Sbapt#define YYABORT goto yyabort 590264790Sbapt#define YYREJECT goto yyabort 591264790Sbapt#define YYACCEPT goto yyaccept 592264790Sbapt#define YYERROR goto yyerrlab 593264790Sbapt#if YYBTYACC 594264790Sbapt#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 595264790Sbapt#define YYVALID_NESTED do { if (yyps->save && \ 596264790Sbapt yyps->save->save == 0) goto yyvalid; } while(0) 597264790Sbapt#endif /* YYBTYACC */ 598264790Sbapt 599264790Sbaptint 600264790SbaptYYPARSE_DECL() 601264790Sbapt{ 602264790Sbapt int yyerrflag; 603264790Sbapt int yychar; 604264790Sbapt YYSTYPE yyval; 605264790Sbapt YYSTYPE yylval; 606264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 607264790Sbapt YYLTYPE yyloc; /* position returned by actions */ 608264790Sbapt YYLTYPE yylloc; /* position from the lexer */ 609264790Sbapt#endif 610264790Sbapt 611264790Sbapt /* variables for the parser stack */ 612264790Sbapt YYSTACKDATA yystack; 613264790Sbapt#if YYBTYACC 614264790Sbapt 615264790Sbapt /* Current parser state */ 616264790Sbapt static YYParseState *yyps = 0; 617264790Sbapt 618264790Sbapt /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 619264790Sbapt static YYParseState *yypath = 0; 620264790Sbapt 621264790Sbapt /* Base of the lexical value queue */ 622264790Sbapt static YYSTYPE *yylvals = 0; 623264790Sbapt 624264790Sbapt /* Current position at lexical value queue */ 625264790Sbapt static YYSTYPE *yylvp = 0; 626264790Sbapt 627264790Sbapt /* End position of lexical value queue */ 628264790Sbapt static YYSTYPE *yylve = 0; 629264790Sbapt 630264790Sbapt /* The last allocated position at the lexical value queue */ 631264790Sbapt static YYSTYPE *yylvlim = 0; 632264790Sbapt 633264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 634264790Sbapt /* Base of the lexical position queue */ 635264790Sbapt static YYLTYPE *yylpsns = 0; 636264790Sbapt 637264790Sbapt /* Current position at lexical position queue */ 638264790Sbapt static YYLTYPE *yylpp = 0; 639264790Sbapt 640264790Sbapt /* End position of lexical position queue */ 641264790Sbapt static YYLTYPE *yylpe = 0; 642264790Sbapt 643264790Sbapt /* The last allocated position at the lexical position queue */ 644264790Sbapt static YYLTYPE *yylplim = 0; 645264790Sbapt#endif 646264790Sbapt 647264790Sbapt /* Current position at lexical token queue */ 648264790Sbapt static short *yylexp = 0; 649264790Sbapt 650264790Sbapt static short *yylexemes = 0; 651264790Sbapt#endif /* YYBTYACC */ 652264790Sbapt int yym, yyn, yystate, yyresult; 653264790Sbapt#if YYBTYACC 654264790Sbapt int yynewerrflag; 655264790Sbapt YYParseState *yyerrctx = NULL; 656264790Sbapt#endif /* YYBTYACC */ 657264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 658264790Sbapt YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 659264790Sbapt#endif 660264790Sbapt#if YYDEBUG 661264790Sbapt const char *yys; 662264790Sbapt 663264790Sbapt if ((yys = getenv("YYDEBUG")) != 0) 664264790Sbapt { 665264790Sbapt yyn = *yys; 666264790Sbapt if (yyn >= '0' && yyn <= '9') 667264790Sbapt yydebug = yyn - '0'; 668264790Sbapt } 669264790Sbapt if (yydebug) 670264790Sbapt fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 671264790Sbapt#endif 672264790Sbapt 673264790Sbapt#if YYBTYACC 674264790Sbapt yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 675264790Sbapt yyps->save = 0; 676264790Sbapt#endif /* YYBTYACC */ 677264790Sbapt yynerrs = 0; 678264790Sbapt yyerrflag = 0; 679264790Sbapt yychar = YYEMPTY; 680264790Sbapt yystate = 0; 681264790Sbapt 682264790Sbapt#if YYPURE 683264790Sbapt memset(&yystack, 0, sizeof(yystack)); 684264790Sbapt#endif 685264790Sbapt 686264790Sbapt if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 687264790Sbapt yystack.s_mark = yystack.s_base; 688264790Sbapt yystack.l_mark = yystack.l_base; 689264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 690264790Sbapt yystack.p_mark = yystack.p_base; 691264790Sbapt#endif 692264790Sbapt yystate = 0; 693264790Sbapt *yystack.s_mark = 0; 694264790Sbapt 695264790Sbaptyyloop: 696264790Sbapt if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 697264790Sbapt if (yychar < 0) 698264790Sbapt { 699264790Sbapt#if YYBTYACC 700264790Sbapt do { 701264790Sbapt if (yylvp < yylve) 702264790Sbapt { 703264790Sbapt /* we're currently re-reading tokens */ 704264790Sbapt yylval = *yylvp++; 705264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 706264790Sbapt yylloc = *yylpp++; 707264790Sbapt#endif 708264790Sbapt yychar = *yylexp++; 709264790Sbapt break; 710264790Sbapt } 711264790Sbapt if (yyps->save) 712264790Sbapt { 713264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 714264790Sbapt if (yylvp == yylvlim) 715264790Sbapt { /* Enlarge lexical value queue */ 716272955Srodrigc size_t p = (size_t) (yylvp - yylvals); 717272955Srodrigc size_t s = (size_t) (yylvlim - yylvals); 718264790Sbapt 719264790Sbapt s += YYLVQUEUEGROWTH; 720264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 721264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 722264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 723264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 724264790Sbapt#endif 725264790Sbapt yylvp = yylve = yylvals + p; 726264790Sbapt yylvlim = yylvals + s; 727264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 728264790Sbapt yylpp = yylpe = yylpsns + p; 729264790Sbapt yylplim = yylpsns + s; 730264790Sbapt#endif 731264790Sbapt yylexp = yylexemes + p; 732264790Sbapt } 733264790Sbapt *yylexp = (short) YYLEX; 734264790Sbapt *yylvp++ = yylval; 735264790Sbapt yylve++; 736264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 737264790Sbapt *yylpp++ = yylloc; 738264790Sbapt yylpe++; 739264790Sbapt#endif 740264790Sbapt yychar = *yylexp++; 741264790Sbapt break; 742264790Sbapt } 743264790Sbapt /* normal operation, no conflict encountered */ 744264790Sbapt#endif /* YYBTYACC */ 745264790Sbapt yychar = YYLEX; 746264790Sbapt#if YYBTYACC 747264790Sbapt } while (0); 748264790Sbapt#endif /* YYBTYACC */ 749264790Sbapt if (yychar < 0) yychar = YYEOF; 750264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 751264790Sbapt#if YYDEBUG 752264790Sbapt if (yydebug) 753264790Sbapt { 754264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 755264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 756264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 757264790Sbapt#ifdef YYSTYPE_TOSTRING 758264790Sbapt#if YYBTYACC 759264790Sbapt if (!yytrial) 760264790Sbapt#endif /* YYBTYACC */ 761264790Sbapt fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 762264790Sbapt#endif 763264790Sbapt fputc('\n', stderr); 764264790Sbapt } 765264790Sbapt#endif 766264790Sbapt } 767264790Sbapt#if YYBTYACC 768264790Sbapt 769264790Sbapt /* Do we have a conflict? */ 770264790Sbapt if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 771264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 772264790Sbapt { 773264790Sbapt YYINT ctry; 774264790Sbapt 775264790Sbapt if (yypath) 776264790Sbapt { 777264790Sbapt YYParseState *save; 778264790Sbapt#if YYDEBUG 779264790Sbapt if (yydebug) 780264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 781264790Sbapt YYDEBUGSTR, yydepth, yystate); 782264790Sbapt#endif 783264790Sbapt /* Switch to the next conflict context */ 784264790Sbapt save = yypath; 785264790Sbapt yypath = save->save; 786264790Sbapt save->save = NULL; 787264790Sbapt ctry = save->ctry; 788264790Sbapt if (save->state != yystate) YYABORT; 789264790Sbapt yyFreeState(save); 790264790Sbapt 791264790Sbapt } 792264790Sbapt else 793264790Sbapt { 794264790Sbapt 795264790Sbapt /* Unresolved conflict - start/continue trial parse */ 796264790Sbapt YYParseState *save; 797264790Sbapt#if YYDEBUG 798264790Sbapt if (yydebug) 799264790Sbapt { 800264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 801264790Sbapt if (yyps->save) 802264790Sbapt fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 803264790Sbapt else 804264790Sbapt fputs("Starting trial parse.\n", stderr); 805264790Sbapt } 806264790Sbapt#endif 807264790Sbapt save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 808264790Sbapt if (save == NULL) goto yyenomem; 809264790Sbapt save->save = yyps->save; 810264790Sbapt save->state = yystate; 811264790Sbapt save->errflag = yyerrflag; 812264790Sbapt save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 813272955Srodrigc memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 814264790Sbapt save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 815272955Srodrigc memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 816264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 817264790Sbapt save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 818272955Srodrigc memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 819264790Sbapt#endif 820264790Sbapt ctry = yytable[yyn]; 821264790Sbapt if (yyctable[ctry] == -1) 822264790Sbapt { 823264790Sbapt#if YYDEBUG 824264790Sbapt if (yydebug && yychar >= YYEOF) 825264790Sbapt fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 826264790Sbapt#endif 827264790Sbapt ctry++; 828264790Sbapt } 829264790Sbapt save->ctry = ctry; 830264790Sbapt if (yyps->save == NULL) 831264790Sbapt { 832264790Sbapt /* If this is a first conflict in the stack, start saving lexemes */ 833264790Sbapt if (!yylexemes) 834264790Sbapt { 835264790Sbapt yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 836264790Sbapt if (yylexemes == NULL) goto yyenomem; 837264790Sbapt yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 838264790Sbapt if (yylvals == NULL) goto yyenomem; 839264790Sbapt yylvlim = yylvals + YYLVQUEUEGROWTH; 840264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 841264790Sbapt yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 842264790Sbapt if (yylpsns == NULL) goto yyenomem; 843264790Sbapt yylplim = yylpsns + YYLVQUEUEGROWTH; 844264790Sbapt#endif 845264790Sbapt } 846264790Sbapt if (yylvp == yylve) 847264790Sbapt { 848264790Sbapt yylvp = yylve = yylvals; 849264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 850264790Sbapt yylpp = yylpe = yylpsns; 851264790Sbapt#endif 852264790Sbapt yylexp = yylexemes; 853264790Sbapt if (yychar >= YYEOF) 854264790Sbapt { 855264790Sbapt *yylve++ = yylval; 856264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 857264790Sbapt *yylpe++ = yylloc; 858264790Sbapt#endif 859264790Sbapt *yylexp = (short) yychar; 860264790Sbapt yychar = YYEMPTY; 861264790Sbapt } 862264790Sbapt } 863264790Sbapt } 864264790Sbapt if (yychar >= YYEOF) 865264790Sbapt { 866264790Sbapt yylvp--; 867264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 868264790Sbapt yylpp--; 869264790Sbapt#endif 870264790Sbapt yylexp--; 871264790Sbapt yychar = YYEMPTY; 872264790Sbapt } 873272955Srodrigc save->lexeme = (int) (yylvp - yylvals); 874264790Sbapt yyps->save = save; 875264790Sbapt } 876264790Sbapt if (yytable[yyn] == ctry) 877264790Sbapt { 878264790Sbapt#if YYDEBUG 879264790Sbapt if (yydebug) 880264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 881264790Sbapt YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 882264790Sbapt#endif 883264790Sbapt if (yychar < 0) 884264790Sbapt { 885264790Sbapt yylvp++; 886264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 887264790Sbapt yylpp++; 888264790Sbapt#endif 889264790Sbapt yylexp++; 890264790Sbapt } 891264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 892264790Sbapt goto yyoverflow; 893264790Sbapt yystate = yyctable[ctry]; 894264790Sbapt *++yystack.s_mark = (short) yystate; 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 else 904264790Sbapt { 905264790Sbapt yyn = yyctable[ctry]; 906264790Sbapt goto yyreduce; 907264790Sbapt } 908264790Sbapt } /* End of code dealing with conflicts */ 909264790Sbapt#endif /* YYBTYACC */ 910264790Sbapt if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 911264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 912264790Sbapt { 913264790Sbapt#if YYDEBUG 914264790Sbapt if (yydebug) 915264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 916264790Sbapt YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 917264790Sbapt#endif 918264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 919264790Sbapt yystate = yytable[yyn]; 920264790Sbapt *++yystack.s_mark = yytable[yyn]; 921264790Sbapt *++yystack.l_mark = yylval; 922264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 923264790Sbapt *++yystack.p_mark = yylloc; 924264790Sbapt#endif 925264790Sbapt yychar = YYEMPTY; 926264790Sbapt if (yyerrflag > 0) --yyerrflag; 927264790Sbapt goto yyloop; 928264790Sbapt } 929264790Sbapt if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 930264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 931264790Sbapt { 932264790Sbapt yyn = yytable[yyn]; 933264790Sbapt goto yyreduce; 934264790Sbapt } 935264790Sbapt if (yyerrflag != 0) goto yyinrecovery; 936264790Sbapt#if YYBTYACC 937264790Sbapt 938264790Sbapt yynewerrflag = 1; 939264790Sbapt goto yyerrhandler; 940264790Sbapt goto yyerrlab; 941264790Sbapt 942264790Sbaptyyerrlab: 943264790Sbapt yynewerrflag = 0; 944264790Sbaptyyerrhandler: 945264790Sbapt while (yyps->save) 946264790Sbapt { 947264790Sbapt int ctry; 948264790Sbapt YYParseState *save = yyps->save; 949264790Sbapt#if YYDEBUG 950264790Sbapt if (yydebug) 951264790Sbapt fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 952264790Sbapt YYDEBUGSTR, yydepth, yystate, yyps->save->state, 953264790Sbapt (int)(yylvp - yylvals - yyps->save->lexeme)); 954264790Sbapt#endif 955264790Sbapt /* Memorize most forward-looking error state in case it's really an error. */ 956264790Sbapt if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 957264790Sbapt { 958264790Sbapt /* Free old saved error context state */ 959264790Sbapt if (yyerrctx) yyFreeState(yyerrctx); 960264790Sbapt /* Create and fill out new saved error context state */ 961264790Sbapt yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 962264790Sbapt if (yyerrctx == NULL) goto yyenomem; 963264790Sbapt yyerrctx->save = yyps->save; 964264790Sbapt yyerrctx->state = yystate; 965264790Sbapt yyerrctx->errflag = yyerrflag; 966264790Sbapt yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 967272955Srodrigc memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 968264790Sbapt yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 969272955Srodrigc memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 970264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 971264790Sbapt yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 972272955Srodrigc memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 973264790Sbapt#endif 974272955Srodrigc yyerrctx->lexeme = (int) (yylvp - yylvals); 975264790Sbapt } 976264790Sbapt yylvp = yylvals + save->lexeme; 977264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 978264790Sbapt yylpp = yylpsns + save->lexeme; 979264790Sbapt#endif 980264790Sbapt yylexp = yylexemes + save->lexeme; 981264790Sbapt yychar = YYEMPTY; 982264790Sbapt yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 983272955Srodrigc memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 984264790Sbapt yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 985272955Srodrigc memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 986264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 987264790Sbapt yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 988272955Srodrigc memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 989264790Sbapt#endif 990264790Sbapt ctry = ++save->ctry; 991264790Sbapt yystate = save->state; 992264790Sbapt /* We tried shift, try reduce now */ 993264790Sbapt if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 994264790Sbapt yyps->save = save->save; 995264790Sbapt save->save = NULL; 996264790Sbapt yyFreeState(save); 997264790Sbapt 998264790Sbapt /* Nothing left on the stack -- error */ 999264790Sbapt if (!yyps->save) 1000264790Sbapt { 1001264790Sbapt#if YYDEBUG 1002264790Sbapt if (yydebug) 1003264790Sbapt fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1004264790Sbapt YYPREFIX, yydepth); 1005264790Sbapt#endif 1006264790Sbapt /* Restore state as it was in the most forward-advanced error */ 1007264790Sbapt yylvp = yylvals + yyerrctx->lexeme; 1008264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1009264790Sbapt yylpp = yylpsns + yyerrctx->lexeme; 1010264790Sbapt#endif 1011264790Sbapt yylexp = yylexemes + yyerrctx->lexeme; 1012264790Sbapt yychar = yylexp[-1]; 1013264790Sbapt yylval = yylvp[-1]; 1014264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1015264790Sbapt yylloc = yylpp[-1]; 1016264790Sbapt#endif 1017264790Sbapt yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1018272955Srodrigc memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1019264790Sbapt yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1020272955Srodrigc memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1021264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1022264790Sbapt yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1023272955Srodrigc memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1024264790Sbapt#endif 1025264790Sbapt yystate = yyerrctx->state; 1026264790Sbapt yyFreeState(yyerrctx); 1027264790Sbapt yyerrctx = NULL; 1028264790Sbapt } 1029264790Sbapt yynewerrflag = 1; 1030264790Sbapt } 1031264790Sbapt if (yynewerrflag == 0) goto yyinrecovery; 1032264790Sbapt#endif /* YYBTYACC */ 1033264790Sbapt 1034264790Sbapt YYERROR_CALL("syntax error"); 1035264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1036264790Sbapt yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1037264790Sbapt#endif 1038264790Sbapt 1039264790Sbapt#if !YYBTYACC 1040264790Sbapt goto yyerrlab; 1041264790Sbaptyyerrlab: 1042264790Sbapt#endif 1043264790Sbapt ++yynerrs; 1044264790Sbapt 1045264790Sbaptyyinrecovery: 1046264790Sbapt if (yyerrflag < 3) 1047264790Sbapt { 1048264790Sbapt yyerrflag = 3; 1049264790Sbapt for (;;) 1050264790Sbapt { 1051264790Sbapt if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1052264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1053264790Sbapt { 1054264790Sbapt#if YYDEBUG 1055264790Sbapt if (yydebug) 1056264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1057264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1058264790Sbapt#endif 1059264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1060264790Sbapt yystate = yytable[yyn]; 1061264790Sbapt *++yystack.s_mark = yytable[yyn]; 1062264790Sbapt *++yystack.l_mark = yylval; 1063264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1064264790Sbapt /* lookahead position is error end position */ 1065264790Sbapt yyerror_loc_range[1] = yylloc; 1066264790Sbapt YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1067264790Sbapt *++yystack.p_mark = yyloc; 1068264790Sbapt#endif 1069264790Sbapt goto yyloop; 1070264790Sbapt } 1071264790Sbapt else 1072264790Sbapt { 1073264790Sbapt#if YYDEBUG 1074264790Sbapt if (yydebug) 1075264790Sbapt fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1076264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark); 1077264790Sbapt#endif 1078264790Sbapt if (yystack.s_mark <= yystack.s_base) goto yyabort; 1079264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1080264790Sbapt /* the current TOS position is the error start position */ 1081264790Sbapt yyerror_loc_range[0] = *yystack.p_mark; 1082264790Sbapt#endif 1083264790Sbapt#if defined(YYDESTRUCT_CALL) 1084264790Sbapt#if YYBTYACC 1085264790Sbapt if (!yytrial) 1086264790Sbapt#endif /* YYBTYACC */ 1087264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1088264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1089264790Sbapt yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1090264790Sbapt#else 1091264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1092264790Sbapt yystos[*yystack.s_mark], yystack.l_mark); 1093264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1094264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1095264790Sbapt --yystack.s_mark; 1096264790Sbapt --yystack.l_mark; 1097264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1098264790Sbapt --yystack.p_mark; 1099264790Sbapt#endif 1100264790Sbapt } 1101264790Sbapt } 1102264790Sbapt } 1103264790Sbapt else 1104264790Sbapt { 1105264790Sbapt if (yychar == YYEOF) goto yyabort; 1106264790Sbapt#if YYDEBUG 1107264790Sbapt if (yydebug) 1108264790Sbapt { 1109264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1110264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1111264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 1112264790Sbapt } 1113264790Sbapt#endif 1114264790Sbapt#if defined(YYDESTRUCT_CALL) 1115264790Sbapt#if YYBTYACC 1116264790Sbapt if (!yytrial) 1117264790Sbapt#endif /* YYBTYACC */ 1118264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1119264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1120264790Sbapt#else 1121264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1122264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1123264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1124264790Sbapt yychar = YYEMPTY; 1125264790Sbapt goto yyloop; 1126264790Sbapt } 1127264790Sbapt 1128264790Sbaptyyreduce: 1129264790Sbapt yym = yylen[yyn]; 1130264790Sbapt#if YYDEBUG 1131264790Sbapt if (yydebug) 1132264790Sbapt { 1133264790Sbapt fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1134264790Sbapt YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1135264790Sbapt#ifdef YYSTYPE_TOSTRING 1136264790Sbapt#if YYBTYACC 1137264790Sbapt if (!yytrial) 1138264790Sbapt#endif /* YYBTYACC */ 1139264790Sbapt if (yym > 0) 1140264790Sbapt { 1141264790Sbapt int i; 1142264790Sbapt fputc('<', stderr); 1143264790Sbapt for (i = yym; i > 0; i--) 1144264790Sbapt { 1145264790Sbapt if (i != yym) fputs(", ", stderr); 1146264790Sbapt fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1147264790Sbapt yystack.l_mark[1-i]), stderr); 1148264790Sbapt } 1149264790Sbapt fputc('>', stderr); 1150264790Sbapt } 1151264790Sbapt#endif 1152264790Sbapt fputc('\n', stderr); 1153264790Sbapt } 1154264790Sbapt#endif 1155264790Sbapt if (yym > 0) 1156264790Sbapt yyval = yystack.l_mark[1-yym]; 1157264790Sbapt else 1158264790Sbapt memset(&yyval, 0, sizeof yyval); 1159264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1160264790Sbapt 1161264790Sbapt /* Perform position reduction */ 1162264790Sbapt memset(&yyloc, 0, sizeof(yyloc)); 1163264790Sbapt#if YYBTYACC 1164264790Sbapt if (!yytrial) 1165264790Sbapt#endif /* YYBTYACC */ 1166264790Sbapt { 1167264790Sbapt YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1168264790Sbapt /* just in case YYERROR is invoked within the action, save 1169264790Sbapt the start of the rhs as the error start position */ 1170264790Sbapt yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1171264790Sbapt } 1172264790Sbapt#endif 1173264790Sbapt 1174264790Sbapt switch (yyn) 1175264790Sbapt { 1176264790Sbaptcase 3: 1177264790Sbapt#line 34 "pure_calc.y" 1178264790Sbapt { yyerrok ; } 1179264790Sbaptbreak; 1180264790Sbaptcase 4: 1181264790Sbapt#line 38 "pure_calc.y" 1182264790Sbapt { printf("%d\n",yystack.l_mark[0]);} 1183264790Sbaptbreak; 1184264790Sbaptcase 5: 1185264790Sbapt#line 40 "pure_calc.y" 1186264790Sbapt { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1187264790Sbaptbreak; 1188264790Sbaptcase 6: 1189264790Sbapt#line 44 "pure_calc.y" 1190264790Sbapt { yyval = yystack.l_mark[-1]; } 1191264790Sbaptbreak; 1192264790Sbaptcase 7: 1193264790Sbapt#line 46 "pure_calc.y" 1194264790Sbapt { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1195264790Sbaptbreak; 1196264790Sbaptcase 8: 1197264790Sbapt#line 48 "pure_calc.y" 1198264790Sbapt { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1199264790Sbaptbreak; 1200264790Sbaptcase 9: 1201264790Sbapt#line 50 "pure_calc.y" 1202264790Sbapt { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1203264790Sbaptbreak; 1204264790Sbaptcase 10: 1205264790Sbapt#line 52 "pure_calc.y" 1206264790Sbapt { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1207264790Sbaptbreak; 1208264790Sbaptcase 11: 1209264790Sbapt#line 54 "pure_calc.y" 1210264790Sbapt { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1211264790Sbaptbreak; 1212264790Sbaptcase 12: 1213264790Sbapt#line 56 "pure_calc.y" 1214264790Sbapt { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1215264790Sbaptbreak; 1216264790Sbaptcase 13: 1217264790Sbapt#line 58 "pure_calc.y" 1218264790Sbapt { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1219264790Sbaptbreak; 1220264790Sbaptcase 14: 1221264790Sbapt#line 60 "pure_calc.y" 1222264790Sbapt { yyval = - yystack.l_mark[0]; } 1223264790Sbaptbreak; 1224264790Sbaptcase 15: 1225264790Sbapt#line 62 "pure_calc.y" 1226264790Sbapt { yyval = regs[yystack.l_mark[0]]; } 1227264790Sbaptbreak; 1228264790Sbaptcase 17: 1229264790Sbapt#line 67 "pure_calc.y" 1230264790Sbapt { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; } 1231264790Sbaptbreak; 1232264790Sbaptcase 18: 1233264790Sbapt#line 69 "pure_calc.y" 1234264790Sbapt { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; } 1235264790Sbaptbreak; 1236272955Srodrigc#line 1237 "pure_calc.tab.c" 1237264790Sbapt default: 1238264790Sbapt break; 1239264790Sbapt } 1240264790Sbapt yystack.s_mark -= yym; 1241264790Sbapt yystate = *yystack.s_mark; 1242264790Sbapt yystack.l_mark -= yym; 1243264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1244264790Sbapt yystack.p_mark -= yym; 1245264790Sbapt#endif 1246264790Sbapt yym = yylhs[yyn]; 1247264790Sbapt if (yystate == 0 && yym == 0) 1248264790Sbapt { 1249264790Sbapt#if YYDEBUG 1250264790Sbapt if (yydebug) 1251264790Sbapt { 1252264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1253264790Sbapt#ifdef YYSTYPE_TOSTRING 1254264790Sbapt#if YYBTYACC 1255264790Sbapt if (!yytrial) 1256264790Sbapt#endif /* YYBTYACC */ 1257264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1258264790Sbapt#endif 1259264790Sbapt fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1260264790Sbapt } 1261264790Sbapt#endif 1262264790Sbapt yystate = YYFINAL; 1263264790Sbapt *++yystack.s_mark = YYFINAL; 1264264790Sbapt *++yystack.l_mark = yyval; 1265264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1266264790Sbapt *++yystack.p_mark = yyloc; 1267264790Sbapt#endif 1268264790Sbapt if (yychar < 0) 1269264790Sbapt { 1270264790Sbapt#if YYBTYACC 1271264790Sbapt do { 1272264790Sbapt if (yylvp < yylve) 1273264790Sbapt { 1274264790Sbapt /* we're currently re-reading tokens */ 1275264790Sbapt yylval = *yylvp++; 1276264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1277264790Sbapt yylloc = *yylpp++; 1278264790Sbapt#endif 1279264790Sbapt yychar = *yylexp++; 1280264790Sbapt break; 1281264790Sbapt } 1282264790Sbapt if (yyps->save) 1283264790Sbapt { 1284264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 1285264790Sbapt if (yylvp == yylvlim) 1286264790Sbapt { /* Enlarge lexical value queue */ 1287272955Srodrigc size_t p = (size_t) (yylvp - yylvals); 1288272955Srodrigc size_t s = (size_t) (yylvlim - yylvals); 1289264790Sbapt 1290264790Sbapt s += YYLVQUEUEGROWTH; 1291264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1292264790Sbapt goto yyenomem; 1293264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1294264790Sbapt goto yyenomem; 1295264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1296264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1297264790Sbapt goto yyenomem; 1298264790Sbapt#endif 1299264790Sbapt yylvp = yylve = yylvals + p; 1300264790Sbapt yylvlim = yylvals + s; 1301264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1302264790Sbapt yylpp = yylpe = yylpsns + p; 1303264790Sbapt yylplim = yylpsns + s; 1304264790Sbapt#endif 1305264790Sbapt yylexp = yylexemes + p; 1306264790Sbapt } 1307264790Sbapt *yylexp = (short) YYLEX; 1308264790Sbapt *yylvp++ = yylval; 1309264790Sbapt yylve++; 1310264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1311264790Sbapt *yylpp++ = yylloc; 1312264790Sbapt yylpe++; 1313264790Sbapt#endif 1314264790Sbapt yychar = *yylexp++; 1315264790Sbapt break; 1316264790Sbapt } 1317264790Sbapt /* normal operation, no conflict encountered */ 1318264790Sbapt#endif /* YYBTYACC */ 1319264790Sbapt yychar = YYLEX; 1320264790Sbapt#if YYBTYACC 1321264790Sbapt } while (0); 1322264790Sbapt#endif /* YYBTYACC */ 1323264790Sbapt if (yychar < 0) yychar = YYEOF; 1324264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1325264790Sbapt#if YYDEBUG 1326264790Sbapt if (yydebug) 1327264790Sbapt { 1328264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1329264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1330264790Sbapt YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1331264790Sbapt } 1332264790Sbapt#endif 1333264790Sbapt } 1334264790Sbapt if (yychar == YYEOF) goto yyaccept; 1335264790Sbapt goto yyloop; 1336264790Sbapt } 1337264790Sbapt if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1338264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1339264790Sbapt yystate = yytable[yyn]; 1340264790Sbapt else 1341264790Sbapt yystate = yydgoto[yym]; 1342264790Sbapt#if YYDEBUG 1343264790Sbapt if (yydebug) 1344264790Sbapt { 1345264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1346264790Sbapt#ifdef YYSTYPE_TOSTRING 1347264790Sbapt#if YYBTYACC 1348264790Sbapt if (!yytrial) 1349264790Sbapt#endif /* YYBTYACC */ 1350264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1351264790Sbapt#endif 1352264790Sbapt fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1353264790Sbapt } 1354264790Sbapt#endif 1355264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1356264790Sbapt *++yystack.s_mark = (short) yystate; 1357264790Sbapt *++yystack.l_mark = yyval; 1358264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1359264790Sbapt *++yystack.p_mark = yyloc; 1360264790Sbapt#endif 1361264790Sbapt goto yyloop; 1362264790Sbapt#if YYBTYACC 1363264790Sbapt 1364264790Sbapt /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1365264790Sbaptyyvalid: 1366264790Sbapt if (yypath) YYABORT; 1367264790Sbapt while (yyps->save) 1368264790Sbapt { 1369264790Sbapt YYParseState *save = yyps->save; 1370264790Sbapt yyps->save = save->save; 1371264790Sbapt save->save = yypath; 1372264790Sbapt yypath = save; 1373264790Sbapt } 1374264790Sbapt#if YYDEBUG 1375264790Sbapt if (yydebug) 1376264790Sbapt fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1377264790Sbapt YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1378264790Sbapt#endif 1379264790Sbapt if (yyerrctx) 1380264790Sbapt { 1381264790Sbapt yyFreeState(yyerrctx); 1382264790Sbapt yyerrctx = NULL; 1383264790Sbapt } 1384264790Sbapt yylvp = yylvals + yypath->lexeme; 1385264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1386264790Sbapt yylpp = yylpsns + yypath->lexeme; 1387264790Sbapt#endif 1388264790Sbapt yylexp = yylexemes + yypath->lexeme; 1389264790Sbapt yychar = YYEMPTY; 1390264790Sbapt yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1391272955Srodrigc memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1392264790Sbapt yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1393272955Srodrigc memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1394264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1395264790Sbapt yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1396272955Srodrigc memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1397264790Sbapt#endif 1398264790Sbapt yystate = yypath->state; 1399264790Sbapt goto yyloop; 1400264790Sbapt#endif /* YYBTYACC */ 1401264790Sbapt 1402264790Sbaptyyoverflow: 1403264790Sbapt YYERROR_CALL("yacc stack overflow"); 1404264790Sbapt#if YYBTYACC 1405264790Sbapt goto yyabort_nomem; 1406264790Sbaptyyenomem: 1407264790Sbapt YYERROR_CALL("memory exhausted"); 1408264790Sbaptyyabort_nomem: 1409264790Sbapt#endif /* YYBTYACC */ 1410264790Sbapt yyresult = 2; 1411264790Sbapt goto yyreturn; 1412264790Sbapt 1413264790Sbaptyyabort: 1414264790Sbapt yyresult = 1; 1415264790Sbapt goto yyreturn; 1416264790Sbapt 1417264790Sbaptyyaccept: 1418264790Sbapt#if YYBTYACC 1419264790Sbapt if (yyps->save) goto yyvalid; 1420264790Sbapt#endif /* YYBTYACC */ 1421264790Sbapt yyresult = 0; 1422264790Sbapt 1423264790Sbaptyyreturn: 1424264790Sbapt#if defined(YYDESTRUCT_CALL) 1425264790Sbapt if (yychar != YYEOF && yychar != YYEMPTY) 1426264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1427264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1428264790Sbapt#else 1429264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1430264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1431264790Sbapt 1432264790Sbapt { 1433264790Sbapt YYSTYPE *pv; 1434264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1435264790Sbapt YYLTYPE *pp; 1436264790Sbapt 1437264790Sbapt for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1438264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1439264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1440264790Sbapt#else 1441264790Sbapt for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1442264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1443264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1444264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1445264790Sbapt } 1446264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1447264790Sbapt 1448264790Sbapt#if YYBTYACC 1449264790Sbapt if (yyerrctx) 1450264790Sbapt { 1451264790Sbapt yyFreeState(yyerrctx); 1452264790Sbapt yyerrctx = NULL; 1453264790Sbapt } 1454264790Sbapt while (yyps) 1455264790Sbapt { 1456264790Sbapt YYParseState *save = yyps; 1457264790Sbapt yyps = save->save; 1458264790Sbapt save->save = NULL; 1459264790Sbapt yyFreeState(save); 1460264790Sbapt } 1461264790Sbapt while (yypath) 1462264790Sbapt { 1463264790Sbapt YYParseState *save = yypath; 1464264790Sbapt yypath = save->save; 1465264790Sbapt save->save = NULL; 1466264790Sbapt yyFreeState(save); 1467264790Sbapt } 1468264790Sbapt#endif /* YYBTYACC */ 1469264790Sbapt yyfreestack(&yystack); 1470264790Sbapt return (yyresult); 1471264790Sbapt} 1472