calc2.tab.c revision 272955
1261421Sjhibbits/* original parser id follows */ 2261421Sjhibbits/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3261421Sjhibbits/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */ 4261421Sjhibbits 5261421Sjhibbits#define YYBYACC 1 6261421Sjhibbits#define YYMAJOR 1 7261421Sjhibbits#define YYMINOR 9 8261421Sjhibbits#define YYCHECK "yyyymmdd" 9261421Sjhibbits 10261421Sjhibbits#define YYEMPTY (-1) 11261421Sjhibbits#define yyclearin (yychar = YYEMPTY) 12261421Sjhibbits#define yyerrok (yyerrflag = 0) 13261421Sjhibbits#define YYRECOVERING() (yyerrflag != 0) 14261421Sjhibbits#define YYENOMEM (-2) 15261421Sjhibbits#define YYEOF 0 16261421Sjhibbits#undef YYBTYACC 17261421Sjhibbits#define YYBTYACC 0 18261421Sjhibbits#define YYDEBUGSTR YYPREFIX "debug" 19261421Sjhibbits 20261421Sjhibbits#ifndef yyparse 21261421Sjhibbits#define yyparse calc2_parse 22261421Sjhibbits#endif /* yyparse */ 23261421Sjhibbits 24261421Sjhibbits#ifndef yylex 25261421Sjhibbits#define yylex calc2_lex 26261421Sjhibbits#endif /* yylex */ 27261421Sjhibbits 28261421Sjhibbits#ifndef yyerror 29261421Sjhibbits#define yyerror calc2_error 30261421Sjhibbits#endif /* yyerror */ 31261421Sjhibbits 32261421Sjhibbits#ifndef yychar 33261421Sjhibbits#define yychar calc2_char 34261421Sjhibbits#endif /* yychar */ 35261421Sjhibbits 36261421Sjhibbits#ifndef yyval 37261421Sjhibbits#define yyval calc2_val 38261421Sjhibbits#endif /* yyval */ 39261421Sjhibbits 40261421Sjhibbits#ifndef yylval 41261421Sjhibbits#define yylval calc2_lval 42261421Sjhibbits#endif /* yylval */ 43261421Sjhibbits 44261421Sjhibbits#ifndef yydebug 45261421Sjhibbits#define yydebug calc2_debug 46261421Sjhibbits#endif /* yydebug */ 47261421Sjhibbits 48261421Sjhibbits#ifndef yynerrs 49261421Sjhibbits#define yynerrs calc2_nerrs 50261421Sjhibbits#endif /* yynerrs */ 51261421Sjhibbits 52261421Sjhibbits#ifndef yyerrflag 53261421Sjhibbits#define yyerrflag calc2_errflag 54261421Sjhibbits#endif /* yyerrflag */ 55261421Sjhibbits 56261421Sjhibbits#ifndef yylhs 57261421Sjhibbits#define yylhs calc2_lhs 58261421Sjhibbits#endif /* yylhs */ 59261421Sjhibbits 60261421Sjhibbits#ifndef yylen 61261421Sjhibbits#define yylen calc2_len 62261421Sjhibbits#endif /* yylen */ 63261421Sjhibbits 64261421Sjhibbits#ifndef yydefred 65261421Sjhibbits#define yydefred calc2_defred 66261421Sjhibbits#endif /* yydefred */ 67261421Sjhibbits 68261421Sjhibbits#ifndef yystos 69261421Sjhibbits#define yystos calc2_stos 70261421Sjhibbits#endif /* yystos */ 71261421Sjhibbits 72261421Sjhibbits#ifndef yydgoto 73261421Sjhibbits#define yydgoto calc2_dgoto 74261421Sjhibbits#endif /* yydgoto */ 75261421Sjhibbits 76261421Sjhibbits#ifndef yysindex 77261421Sjhibbits#define yysindex calc2_sindex 78261421Sjhibbits#endif /* yysindex */ 79261421Sjhibbits 80261421Sjhibbits#ifndef yyrindex 81261421Sjhibbits#define yyrindex calc2_rindex 82261421Sjhibbits#endif /* yyrindex */ 83261421Sjhibbits 84261421Sjhibbits#ifndef yygindex 85261421Sjhibbits#define yygindex calc2_gindex 86261421Sjhibbits#endif /* yygindex */ 87261421Sjhibbits 88261421Sjhibbits#ifndef yytable 89261421Sjhibbits#define yytable calc2_table 90261421Sjhibbits#endif /* yytable */ 91261421Sjhibbits 92261421Sjhibbits#ifndef yycheck 93261421Sjhibbits#define yycheck calc2_check 94261421Sjhibbits#endif /* yycheck */ 95261421Sjhibbits 96261421Sjhibbits#ifndef yyname 97261421Sjhibbits#define yyname calc2_name 98261421Sjhibbits#endif /* yyname */ 99261421Sjhibbits 100261421Sjhibbits#ifndef yyrule 101261421Sjhibbits#define yyrule calc2_rule 102261421Sjhibbits#endif /* yyrule */ 103261421Sjhibbits 104261421Sjhibbits#if YYBTYACC 105261421Sjhibbits 106261421Sjhibbits#ifndef yycindex 107261421Sjhibbits#define yycindex calc2_cindex 108261421Sjhibbits#endif /* yycindex */ 109261421Sjhibbits 110261421Sjhibbits#ifndef yyctable 111261421Sjhibbits#define yyctable calc2_ctable 112261421Sjhibbits#endif /* yyctable */ 113261421Sjhibbits 114261421Sjhibbits#endif /* YYBTYACC */ 115261421Sjhibbits 116261421Sjhibbits#define YYPREFIX "calc2_" 117261421Sjhibbits 118261421Sjhibbits#define YYPURE 0 119261421Sjhibbits 120261421Sjhibbits#line 7 "calc2.y" 121261421Sjhibbits# include <stdio.h> 122261421Sjhibbits# include <ctype.h> 123261421Sjhibbits 124261421Sjhibbits#ifdef YYBISON 125261421Sjhibbits#define YYLEX_PARAM base 126261421Sjhibbits#define YYLEX_DECL() yylex(int *YYLEX_PARAM) 127261421Sjhibbits#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s) 128261421Sjhibbitsint YYLEX_DECL(); 129261421Sjhibbitsstatic void YYERROR_DECL(); 130261421Sjhibbits#endif 131261421Sjhibbits 132261421Sjhibbits#line 133 "calc2.tab.c" 133261421Sjhibbits 134261421Sjhibbits#if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED) 135261421Sjhibbits/* Default: YYSTYPE is the semantic value type. */ 136261421Sjhibbitstypedef int YYSTYPE; 137261421Sjhibbits# define YYSTYPE_IS_DECLARED 1 138261421Sjhibbits#endif 139261421Sjhibbits 140261421Sjhibbits/* compatibility with bison */ 141261421Sjhibbits#ifdef YYPARSE_PARAM 142261421Sjhibbits/* compatibility with FreeBSD */ 143261421Sjhibbits# ifdef YYPARSE_PARAM_TYPE 144261421Sjhibbits# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 145261421Sjhibbits# else 146261421Sjhibbits# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 147261421Sjhibbits# endif 148261421Sjhibbits#else 149261421Sjhibbits# define YYPARSE_DECL() yyparse(int regs[26], int *base) 150261421Sjhibbits#endif 151261421Sjhibbits 152261421Sjhibbits/* Parameters sent to lex. */ 153261421Sjhibbits#ifdef YYLEX_PARAM 154261421Sjhibbits# define YYLEX_DECL() yylex(void *YYLEX_PARAM) 155261421Sjhibbits# define YYLEX yylex(YYLEX_PARAM) 156261421Sjhibbits#else 157261421Sjhibbits# define YYLEX_DECL() yylex(int *base) 158261421Sjhibbits# define YYLEX yylex(base) 159261421Sjhibbits#endif 160261421Sjhibbits 161261421Sjhibbits/* Parameters sent to yyerror. */ 162261421Sjhibbits#ifndef YYERROR_DECL 163261421Sjhibbits#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s) 164261421Sjhibbits#endif 165261421Sjhibbits#ifndef YYERROR_CALL 166261421Sjhibbits#define YYERROR_CALL(msg) yyerror(regs, base, msg) 167261421Sjhibbits#endif 168261421Sjhibbits 169261421Sjhibbitsextern int YYPARSE_DECL(); 170261421Sjhibbits 171261421Sjhibbits#define DIGIT 257 172261421Sjhibbits#define LETTER 258 173261421Sjhibbits#define UMINUS 259 174261421Sjhibbits#define YYERRCODE 256 175261421Sjhibbitstypedef short YYINT; 176261421Sjhibbitsstatic const YYINT calc2_lhs[] = { -1, 177261421Sjhibbits 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 178261421Sjhibbits 2, 2, 2, 2, 2, 2, 3, 3, 179261421Sjhibbits}; 180261421Sjhibbitsstatic const YYINT calc2_len[] = { 2, 181261421Sjhibbits 0, 3, 3, 1, 3, 3, 3, 3, 3, 3, 182261421Sjhibbits 3, 3, 3, 2, 1, 1, 1, 2, 183261421Sjhibbits}; 184261421Sjhibbitsstatic const YYINT calc2_defred[] = { 1, 185261421Sjhibbits 0, 0, 17, 0, 0, 0, 0, 0, 0, 3, 186261421Sjhibbits 0, 15, 14, 0, 2, 0, 0, 0, 0, 0, 187261421Sjhibbits 0, 0, 18, 0, 6, 0, 0, 0, 0, 9, 188261421Sjhibbits 10, 11, 189261421Sjhibbits}; 190261421Sjhibbitsstatic const YYINT calc2_stos[] = { 0, 191261421Sjhibbits 261, 256, 257, 258, 45, 40, 262, 263, 264, 10, 192261421Sjhibbits 61, 258, 263, 263, 10, 124, 38, 43, 45, 42, 193261421Sjhibbits 47, 37, 257, 263, 41, 263, 263, 263, 263, 263, 194261421Sjhibbits 263, 263, 195261421Sjhibbits}; 196261421Sjhibbitsstatic const YYINT calc2_dgoto[] = { 1, 197261421Sjhibbits 7, 8, 9, 198261421Sjhibbits}; 199261421Sjhibbitsstatic const YYINT calc2_sindex[] = { 0, 200261421Sjhibbits -40, -7, 0, -55, -38, -38, 1, -29, -247, 0, 201261421Sjhibbits -38, 0, 0, 22, 0, -38, -38, -38, -38, -38, 202261421Sjhibbits -38, -38, 0, -29, 0, 51, 60, -20, -20, 0, 203261421Sjhibbits 0, 0, 204261421Sjhibbits}; 205261421Sjhibbitsstatic const YYINT calc2_rindex[] = { 0, 206261421Sjhibbits 0, 0, 0, 2, 0, 0, 0, 9, -9, 0, 207261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 208261421Sjhibbits 0, 0, 0, 10, 0, -6, 14, 5, 13, 0, 209261421Sjhibbits 0, 0, 210261421Sjhibbits}; 211261421Sjhibbits#if YYBTYACC 212261421Sjhibbitsstatic const YYINT calc2_cindex[] = { 0, 213261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 214261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 215261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 216261421Sjhibbits 0, 0, 217261421Sjhibbits}; 218261421Sjhibbits#endif 219261421Sjhibbitsstatic const YYINT calc2_gindex[] = { 0, 220261421Sjhibbits 0, 65, 0, 221261421Sjhibbits}; 222261421Sjhibbits#define YYTABLESIZE 220 223261421Sjhibbitsstatic const YYINT calc2_table[] = { 6, 224261421Sjhibbits 16, 6, 10, 13, 5, 11, 5, 22, 17, 23, 225261421Sjhibbits 15, 15, 20, 18, 7, 19, 22, 21, 4, 5, 226261421Sjhibbits 0, 20, 8, 12, 0, 0, 21, 16, 16, 0, 227261421Sjhibbits 0, 16, 16, 16, 13, 16, 0, 16, 15, 15, 228261421Sjhibbits 0, 0, 7, 15, 15, 7, 15, 7, 15, 7, 229261421Sjhibbits 8, 12, 0, 8, 12, 8, 0, 8, 22, 17, 230261421Sjhibbits 0, 0, 25, 20, 18, 0, 19, 0, 21, 13, 231261421Sjhibbits 14, 0, 0, 0, 0, 24, 0, 0, 0, 0, 232261421Sjhibbits 26, 27, 28, 29, 30, 31, 32, 22, 17, 0, 233261421Sjhibbits 0, 0, 20, 18, 16, 19, 22, 21, 0, 0, 234261421Sjhibbits 0, 20, 18, 0, 19, 0, 21, 0, 0, 0, 235261421Sjhibbits 0, 0, 0, 0, 16, 0, 0, 13, 0, 0, 236261421Sjhibbits 0, 0, 0, 0, 0, 15, 0, 0, 7, 0, 237261421Sjhibbits 0, 0, 0, 0, 0, 0, 8, 12, 0, 0, 238261421Sjhibbits 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 239261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 242261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 243261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 244261421Sjhibbits 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 245261421Sjhibbits 0, 0, 0, 0, 0, 2, 3, 4, 3, 12, 246261421Sjhibbits}; 247261421Sjhibbitsstatic const YYINT calc2_check[] = { 40, 248261421Sjhibbits 10, 40, 10, 10, 45, 61, 45, 37, 38, 257, 249261421Sjhibbits 10, 10, 42, 43, 10, 45, 37, 47, 10, 10, 250261421Sjhibbits -1, 42, 10, 10, -1, -1, 47, 37, 38, -1, 251261421Sjhibbits -1, 41, 42, 43, 41, 45, -1, 47, 37, 38, 252261421Sjhibbits -1, -1, 38, 42, 43, 41, 45, 43, 47, 45, 253261421Sjhibbits 38, 38, -1, 41, 41, 43, -1, 45, 37, 38, 254261421Sjhibbits -1, -1, 41, 42, 43, -1, 45, -1, 47, 5, 255261421Sjhibbits 6, -1, -1, -1, -1, 11, -1, -1, -1, -1, 256261421Sjhibbits 16, 17, 18, 19, 20, 21, 22, 37, 38, -1, 257261421Sjhibbits -1, -1, 42, 43, 124, 45, 37, 47, -1, -1, 258261421Sjhibbits -1, 42, 43, -1, 45, -1, 47, -1, -1, -1, 259261421Sjhibbits -1, -1, -1, -1, 124, -1, -1, 124, -1, -1, 260261421Sjhibbits -1, -1, -1, -1, -1, 124, -1, -1, 124, -1, 261261421Sjhibbits -1, -1, -1, -1, -1, -1, 124, 124, -1, -1, 262261421Sjhibbits -1, -1, -1, -1, -1, 124, -1, -1, -1, -1, 263261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 264261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 265261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 266261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 267261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 268261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 269261421Sjhibbits -1, -1, -1, -1, -1, 256, 257, 258, 257, 258, 270261421Sjhibbits}; 271261421Sjhibbits#if YYBTYACC 272261421Sjhibbitsstatic const YYINT calc2_ctable[] = { -1, 273261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 274261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 275261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 276261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 277261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 278261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 279261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 280261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 281261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 282261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 283261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 284261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 285261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 286261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 287261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 288261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 289261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 290261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 291261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 292261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 293261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 294261421Sjhibbits -1, -1, -1, -1, -1, -1, -1, -1, -1, 295261421Sjhibbits}; 296261421Sjhibbits#endif 297261421Sjhibbits#define YYFINAL 1 298261421Sjhibbits#ifndef YYDEBUG 299261421Sjhibbits#define YYDEBUG 0 300261421Sjhibbits#endif 301261421Sjhibbits#define YYMAXTOKEN 259 302261421Sjhibbits#define YYUNDFTOKEN 265 303261421Sjhibbits#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 304261421Sjhibbits#if YYDEBUG 305261421Sjhibbitsstatic const char *const calc2_name[] = { 306261421Sjhibbits 307261421Sjhibbits"$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, 308261421Sjhibbits0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0, 309261421Sjhibbits0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 310261421Sjhibbits0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0, 311261421Sjhibbits0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 312261421Sjhibbits0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 313261421Sjhibbits0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 314261421Sjhibbits0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number", 315261421Sjhibbits"illegal-symbol", 316261421Sjhibbits}; 317261421Sjhibbitsstatic const char *const calc2_rule[] = { 318261421Sjhibbits"$accept : list", 319261421Sjhibbits"list :", 320261421Sjhibbits"list : list stat '\\n'", 321261421Sjhibbits"list : list error '\\n'", 322261421Sjhibbits"stat : expr", 323261421Sjhibbits"stat : LETTER '=' expr", 324261421Sjhibbits"expr : '(' expr ')'", 325261421Sjhibbits"expr : expr '+' expr", 326261421Sjhibbits"expr : expr '-' expr", 327261421Sjhibbits"expr : expr '*' expr", 328261421Sjhibbits"expr : expr '/' expr", 329261421Sjhibbits"expr : expr '%' expr", 330261421Sjhibbits"expr : expr '&' expr", 331261421Sjhibbits"expr : expr '|' expr", 332261421Sjhibbits"expr : '-' expr", 333261421Sjhibbits"expr : LETTER", 334261421Sjhibbits"expr : number", 335261421Sjhibbits"number : DIGIT", 336261421Sjhibbits"number : number DIGIT", 337261421Sjhibbits 338261421Sjhibbits}; 339261421Sjhibbits#endif 340261421Sjhibbits 341261421Sjhibbitsint yydebug; 342261421Sjhibbitsint yynerrs; 343261421Sjhibbits 344261421Sjhibbitsint yyerrflag; 345261421Sjhibbitsint yychar; 346261421SjhibbitsYYSTYPE yyval; 347261421SjhibbitsYYSTYPE yylval; 348261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 349261421SjhibbitsYYLTYPE yyloc; /* position returned by actions */ 350261421SjhibbitsYYLTYPE yylloc; /* position from the lexer */ 351261421Sjhibbits#endif 352261421Sjhibbits 353261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 354261421Sjhibbits#ifndef YYLLOC_DEFAULT 355261421Sjhibbits#define YYLLOC_DEFAULT(loc, rhs, n) \ 356261421Sjhibbitsdo \ 357261421Sjhibbits{ \ 358261421Sjhibbits if (n == 0) \ 359261421Sjhibbits { \ 360261421Sjhibbits (loc).first_line = ((rhs)[-1]).last_line; \ 361261421Sjhibbits (loc).first_column = ((rhs)[-1]).last_column; \ 362261421Sjhibbits (loc).last_line = ((rhs)[-1]).last_line; \ 363261421Sjhibbits (loc).last_column = ((rhs)[-1]).last_column; \ 364261421Sjhibbits } \ 365261421Sjhibbits else \ 366261421Sjhibbits { \ 367261421Sjhibbits (loc).first_line = ((rhs)[ 0 ]).first_line; \ 368261421Sjhibbits (loc).first_column = ((rhs)[ 0 ]).first_column; \ 369261421Sjhibbits (loc).last_line = ((rhs)[n-1]).last_line; \ 370261421Sjhibbits (loc).last_column = ((rhs)[n-1]).last_column; \ 371261421Sjhibbits } \ 372261421Sjhibbits} while (0) 373261421Sjhibbits#endif /* YYLLOC_DEFAULT */ 374261421Sjhibbits#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 375261421Sjhibbits#if YYBTYACC 376261421Sjhibbits 377261421Sjhibbits#ifndef YYLVQUEUEGROWTH 378261421Sjhibbits#define YYLVQUEUEGROWTH 32 379261421Sjhibbits#endif 380261421Sjhibbits#endif /* YYBTYACC */ 381261421Sjhibbits 382261421Sjhibbits/* define the initial stack-sizes */ 383261421Sjhibbits#ifdef YYSTACKSIZE 384261421Sjhibbits#undef YYMAXDEPTH 385261421Sjhibbits#define YYMAXDEPTH YYSTACKSIZE 386261421Sjhibbits#else 387261421Sjhibbits#ifdef YYMAXDEPTH 388261421Sjhibbits#define YYSTACKSIZE YYMAXDEPTH 389261421Sjhibbits#else 390261421Sjhibbits#define YYSTACKSIZE 10000 391261421Sjhibbits#define YYMAXDEPTH 10000 392261421Sjhibbits#endif 393261421Sjhibbits#endif 394261421Sjhibbits 395261421Sjhibbits#ifndef YYINITSTACKSIZE 396261421Sjhibbits#define YYINITSTACKSIZE 200 397261421Sjhibbits#endif 398261421Sjhibbits 399261421Sjhibbitstypedef struct { 400261421Sjhibbits unsigned stacksize; 401261421Sjhibbits short *s_base; 402261421Sjhibbits short *s_mark; 403261421Sjhibbits short *s_last; 404261421Sjhibbits YYSTYPE *l_base; 405261421Sjhibbits YYSTYPE *l_mark; 406261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 407261421Sjhibbits YYLTYPE *p_base; 408261421Sjhibbits YYLTYPE *p_mark; 409261421Sjhibbits#endif 410261421Sjhibbits} YYSTACKDATA; 411261421Sjhibbits#if YYBTYACC 412261421Sjhibbits 413261421Sjhibbitsstruct YYParseState_s 414261421Sjhibbits{ 415261421Sjhibbits struct YYParseState_s *save; /* Previously saved parser state */ 416261421Sjhibbits YYSTACKDATA yystack; /* saved parser stack */ 417261421Sjhibbits int state; /* saved parser state */ 418261421Sjhibbits int errflag; /* saved error recovery status */ 419261421Sjhibbits int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 420261421Sjhibbits YYINT ctry; /* saved index in yyctable[] for this conflict */ 421261421Sjhibbits}; 422261421Sjhibbitstypedef struct YYParseState_s YYParseState; 423261421Sjhibbits#endif /* YYBTYACC */ 424261421Sjhibbits/* variables for the parser stack */ 425261421Sjhibbitsstatic YYSTACKDATA yystack; 426261421Sjhibbits#if YYBTYACC 427261421Sjhibbits 428261421Sjhibbits/* Current parser state */ 429261421Sjhibbitsstatic YYParseState *yyps = 0; 430261421Sjhibbits 431261421Sjhibbits/* yypath != NULL: do the full parse, starting at *yypath parser state. */ 432261421Sjhibbitsstatic YYParseState *yypath = 0; 433261421Sjhibbits 434261421Sjhibbits/* Base of the lexical value queue */ 435261421Sjhibbitsstatic YYSTYPE *yylvals = 0; 436261421Sjhibbits 437261421Sjhibbits/* Current position at lexical value queue */ 438261421Sjhibbitsstatic YYSTYPE *yylvp = 0; 439261421Sjhibbits 440261421Sjhibbits/* End position of lexical value queue */ 441261421Sjhibbitsstatic YYSTYPE *yylve = 0; 442261421Sjhibbits 443261421Sjhibbits/* The last allocated position at the lexical value queue */ 444261421Sjhibbitsstatic YYSTYPE *yylvlim = 0; 445261421Sjhibbits 446261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 447261421Sjhibbits/* Base of the lexical position queue */ 448261421Sjhibbitsstatic YYLTYPE *yylpsns = 0; 449261421Sjhibbits 450261421Sjhibbits/* Current position at lexical position queue */ 451261421Sjhibbitsstatic YYLTYPE *yylpp = 0; 452261421Sjhibbits 453261421Sjhibbits/* End position of lexical position queue */ 454261421Sjhibbitsstatic YYLTYPE *yylpe = 0; 455261421Sjhibbits 456261421Sjhibbits/* The last allocated position at the lexical position queue */ 457261421Sjhibbitsstatic YYLTYPE *yylplim = 0; 458261421Sjhibbits#endif 459261421Sjhibbits 460261421Sjhibbits/* Current position at lexical token queue */ 461261421Sjhibbitsstatic short *yylexp = 0; 462261421Sjhibbits 463261421Sjhibbitsstatic short *yylexemes = 0; 464261421Sjhibbits#endif /* YYBTYACC */ 465261421Sjhibbits#line 73 "calc2.y" 466261421Sjhibbits /* start of programs */ 467261421Sjhibbits 468261421Sjhibbits#ifdef YYBYACC 469261421Sjhibbitsextern int YYLEX_DECL(); 470261421Sjhibbits#endif 471261421Sjhibbits 472261421Sjhibbitsint 473261421Sjhibbitsmain (void) 474261421Sjhibbits{ 475261421Sjhibbits int regs[26]; 476261421Sjhibbits int base = 10; 477261421Sjhibbits 478261421Sjhibbits while(!feof(stdin)) { 479261421Sjhibbits yyparse(regs, &base); 480261421Sjhibbits } 481261421Sjhibbits return 0; 482261421Sjhibbits} 483261421Sjhibbits 484261421Sjhibbits#define UNUSED(x) ((void)(x)) 485261421Sjhibbits 486261421Sjhibbitsstatic void 487261421SjhibbitsYYERROR_DECL() 488261421Sjhibbits{ 489261421Sjhibbits UNUSED(regs); /* %parse-param regs is not actually used here */ 490261421Sjhibbits UNUSED(base); /* %parse-param base is not actually used here */ 491261421Sjhibbits fprintf(stderr, "%s\n", s); 492261421Sjhibbits} 493261421Sjhibbits 494261421Sjhibbitsint 495261421SjhibbitsYYLEX_DECL() 496261421Sjhibbits{ 497261421Sjhibbits /* lexical analysis routine */ 498261421Sjhibbits /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 499261421Sjhibbits /* return DIGIT for a digit, yylval = 0 through 9 */ 500261421Sjhibbits /* all other characters are returned immediately */ 501261421Sjhibbits 502261421Sjhibbits int c; 503261421Sjhibbits 504261421Sjhibbits while( (c=getchar()) == ' ' ) { /* skip blanks */ } 505261421Sjhibbits 506261421Sjhibbits /* c is now nonblank */ 507261421Sjhibbits 508261421Sjhibbits if( islower( c )) { 509261421Sjhibbits yylval = c - 'a'; 510261421Sjhibbits return ( LETTER ); 511261421Sjhibbits } 512261421Sjhibbits if( isdigit( c )) { 513261421Sjhibbits yylval = (c - '0') % (*base); 514261421Sjhibbits return ( DIGIT ); 515261421Sjhibbits } 516261421Sjhibbits return( c ); 517261421Sjhibbits} 518261421Sjhibbits#line 519 "calc2.tab.c" 519261421Sjhibbits 520261421Sjhibbits/* For use in generated program */ 521261421Sjhibbits#define yydepth (int)(yystack.s_mark - yystack.s_base) 522261421Sjhibbits#if YYBTYACC 523261421Sjhibbits#define yytrial (yyps->save) 524261421Sjhibbits#endif /* YYBTYACC */ 525261421Sjhibbits 526261421Sjhibbits#if YYDEBUG 527261421Sjhibbits#include <stdio.h> /* needed for printf */ 528261421Sjhibbits#endif 529261421Sjhibbits 530261421Sjhibbits#include <stdlib.h> /* needed for malloc, etc */ 531261421Sjhibbits#include <string.h> /* needed for memset */ 532261421Sjhibbits 533261421Sjhibbits/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 534261421Sjhibbitsstatic int yygrowstack(YYSTACKDATA *data) 535261421Sjhibbits{ 536261421Sjhibbits int i; 537261421Sjhibbits unsigned newsize; 538261421Sjhibbits short *newss; 539261421Sjhibbits YYSTYPE *newvs; 540261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 541261421Sjhibbits YYLTYPE *newps; 542261421Sjhibbits#endif 543261421Sjhibbits 544261421Sjhibbits if ((newsize = data->stacksize) == 0) 545261421Sjhibbits newsize = YYINITSTACKSIZE; 546261421Sjhibbits else if (newsize >= YYMAXDEPTH) 547261421Sjhibbits return YYENOMEM; 548261421Sjhibbits else if ((newsize *= 2) > YYMAXDEPTH) 549261421Sjhibbits newsize = YYMAXDEPTH; 550261421Sjhibbits 551261421Sjhibbits i = (int) (data->s_mark - data->s_base); 552261421Sjhibbits newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 553261421Sjhibbits if (newss == 0) 554261421Sjhibbits return YYENOMEM; 555261421Sjhibbits 556261421Sjhibbits data->s_base = newss; 557261421Sjhibbits data->s_mark = newss + i; 558261421Sjhibbits 559261421Sjhibbits newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 560261421Sjhibbits if (newvs == 0) 561261421Sjhibbits return YYENOMEM; 562261421Sjhibbits 563261421Sjhibbits data->l_base = newvs; 564261421Sjhibbits data->l_mark = newvs + i; 565261421Sjhibbits 566261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 567261421Sjhibbits newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 568261421Sjhibbits if (newps == 0) 569261421Sjhibbits return YYENOMEM; 570261421Sjhibbits 571261421Sjhibbits data->p_base = newps; 572261421Sjhibbits data->p_mark = newps + i; 573261421Sjhibbits#endif 574261421Sjhibbits 575261421Sjhibbits data->stacksize = newsize; 576261421Sjhibbits data->s_last = data->s_base + newsize - 1; 577261421Sjhibbits 578261421Sjhibbits#if YYDEBUG 579261421Sjhibbits if (yydebug) 580261421Sjhibbits fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 581261421Sjhibbits#endif 582261421Sjhibbits return 0; 583261421Sjhibbits} 584261421Sjhibbits 585261421Sjhibbits#if YYPURE || defined(YY_NO_LEAKS) 586261421Sjhibbitsstatic void yyfreestack(YYSTACKDATA *data) 587261421Sjhibbits{ 588261421Sjhibbits free(data->s_base); 589261421Sjhibbits free(data->l_base); 590261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 591261421Sjhibbits free(data->p_base); 592261421Sjhibbits#endif 593261421Sjhibbits memset(data, 0, sizeof(*data)); 594261421Sjhibbits} 595261421Sjhibbits#else 596261421Sjhibbits#define yyfreestack(data) /* nothing */ 597261421Sjhibbits#endif /* YYPURE || defined(YY_NO_LEAKS) */ 598261421Sjhibbits#if YYBTYACC 599261421Sjhibbits 600261421Sjhibbitsstatic YYParseState * 601261421SjhibbitsyyNewState(unsigned size) 602261421Sjhibbits{ 603261421Sjhibbits YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 604261421Sjhibbits if (p == NULL) return NULL; 605261421Sjhibbits 606261421Sjhibbits p->yystack.stacksize = size; 607261421Sjhibbits if (size == 0) 608261421Sjhibbits { 609261421Sjhibbits p->yystack.s_base = NULL; 610261421Sjhibbits p->yystack.l_base = NULL; 611261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 612261421Sjhibbits p->yystack.p_base = NULL; 613261421Sjhibbits#endif 614261421Sjhibbits return p; 615261421Sjhibbits } 616261421Sjhibbits p->yystack.s_base = (short *) malloc(size * sizeof(short)); 617261421Sjhibbits if (p->yystack.s_base == NULL) return NULL; 618261421Sjhibbits p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 619261421Sjhibbits if (p->yystack.l_base == NULL) return NULL; 620261421Sjhibbits memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 621261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 622261421Sjhibbits p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 623261421Sjhibbits if (p->yystack.p_base == NULL) return NULL; 624261421Sjhibbits memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 625261421Sjhibbits#endif 626261421Sjhibbits 627261421Sjhibbits return p; 628261421Sjhibbits} 629261421Sjhibbits 630261421Sjhibbitsstatic void 631261421SjhibbitsyyFreeState(YYParseState *p) 632261421Sjhibbits{ 633261421Sjhibbits yyfreestack(&p->yystack); 634261421Sjhibbits free(p); 635261421Sjhibbits} 636261421Sjhibbits#endif /* YYBTYACC */ 637261421Sjhibbits 638261421Sjhibbits#define YYABORT goto yyabort 639261421Sjhibbits#define YYREJECT goto yyabort 640261421Sjhibbits#define YYACCEPT goto yyaccept 641261421Sjhibbits#define YYERROR goto yyerrlab 642261421Sjhibbits#if YYBTYACC 643261421Sjhibbits#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 644261421Sjhibbits#define YYVALID_NESTED do { if (yyps->save && \ 645261421Sjhibbits yyps->save->save == 0) goto yyvalid; } while(0) 646261421Sjhibbits#endif /* YYBTYACC */ 647261421Sjhibbits 648261421Sjhibbitsint 649261421SjhibbitsYYPARSE_DECL() 650261421Sjhibbits{ 651261421Sjhibbits int yym, yyn, yystate, yyresult; 652261421Sjhibbits#if YYBTYACC 653261421Sjhibbits int yynewerrflag; 654261421Sjhibbits YYParseState *yyerrctx = NULL; 655261421Sjhibbits#endif /* YYBTYACC */ 656261421Sjhibbits#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 657261421Sjhibbits YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 658261421Sjhibbits#endif 659261421Sjhibbits#if YYDEBUG 660261421Sjhibbits const char *yys; 661261421Sjhibbits 662261421Sjhibbits if ((yys = getenv("YYDEBUG")) != 0) 663261421Sjhibbits { 664261421Sjhibbits yyn = *yys; 665 if (yyn >= '0' && yyn <= '9') 666 yydebug = yyn - '0'; 667 } 668 if (yydebug) 669 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 670#endif 671 672#if YYBTYACC 673 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 674 yyps->save = 0; 675#endif /* YYBTYACC */ 676 yynerrs = 0; 677 yyerrflag = 0; 678 yychar = YYEMPTY; 679 yystate = 0; 680 681#if YYPURE 682 memset(&yystack, 0, sizeof(yystack)); 683#endif 684 685 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 686 yystack.s_mark = yystack.s_base; 687 yystack.l_mark = yystack.l_base; 688#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 689 yystack.p_mark = yystack.p_base; 690#endif 691 yystate = 0; 692 *yystack.s_mark = 0; 693 694yyloop: 695 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 696 if (yychar < 0) 697 { 698#if YYBTYACC 699 do { 700 if (yylvp < yylve) 701 { 702 /* we're currently re-reading tokens */ 703 yylval = *yylvp++; 704#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 705 yylloc = *yylpp++; 706#endif 707 yychar = *yylexp++; 708 break; 709 } 710 if (yyps->save) 711 { 712 /* in trial mode; save scanner results for future parse attempts */ 713 if (yylvp == yylvlim) 714 { /* Enlarge lexical value queue */ 715 size_t p = (size_t) (yylvp - yylvals); 716 size_t s = (size_t) (yylvlim - yylvals); 717 718 s += YYLVQUEUEGROWTH; 719 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 720 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 721#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 722 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 723#endif 724 yylvp = yylve = yylvals + p; 725 yylvlim = yylvals + s; 726#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 727 yylpp = yylpe = yylpsns + p; 728 yylplim = yylpsns + s; 729#endif 730 yylexp = yylexemes + p; 731 } 732 *yylexp = (short) YYLEX; 733 *yylvp++ = yylval; 734 yylve++; 735#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 736 *yylpp++ = yylloc; 737 yylpe++; 738#endif 739 yychar = *yylexp++; 740 break; 741 } 742 /* normal operation, no conflict encountered */ 743#endif /* YYBTYACC */ 744 yychar = YYLEX; 745#if YYBTYACC 746 } while (0); 747#endif /* YYBTYACC */ 748 if (yychar < 0) yychar = YYEOF; 749 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 750#if YYDEBUG 751 if (yydebug) 752 { 753 yys = yyname[YYTRANSLATE(yychar)]; 754 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 755 YYDEBUGSTR, yydepth, yystate, yychar, yys); 756#ifdef YYSTYPE_TOSTRING 757#if YYBTYACC 758 if (!yytrial) 759#endif /* YYBTYACC */ 760 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 761#endif 762 fputc('\n', stderr); 763 } 764#endif 765 } 766#if YYBTYACC 767 768 /* Do we have a conflict? */ 769 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 770 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 771 { 772 YYINT ctry; 773 774 if (yypath) 775 { 776 YYParseState *save; 777#if YYDEBUG 778 if (yydebug) 779 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 780 YYDEBUGSTR, yydepth, yystate); 781#endif 782 /* Switch to the next conflict context */ 783 save = yypath; 784 yypath = save->save; 785 save->save = NULL; 786 ctry = save->ctry; 787 if (save->state != yystate) YYABORT; 788 yyFreeState(save); 789 790 } 791 else 792 { 793 794 /* Unresolved conflict - start/continue trial parse */ 795 YYParseState *save; 796#if YYDEBUG 797 if (yydebug) 798 { 799 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 800 if (yyps->save) 801 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 802 else 803 fputs("Starting trial parse.\n", stderr); 804 } 805#endif 806 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 807 if (save == NULL) goto yyenomem; 808 save->save = yyps->save; 809 save->state = yystate; 810 save->errflag = yyerrflag; 811 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 812 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 813 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 814 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 815#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 816 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 817 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 818#endif 819 ctry = yytable[yyn]; 820 if (yyctable[ctry] == -1) 821 { 822#if YYDEBUG 823 if (yydebug && yychar >= YYEOF) 824 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 825#endif 826 ctry++; 827 } 828 save->ctry = ctry; 829 if (yyps->save == NULL) 830 { 831 /* If this is a first conflict in the stack, start saving lexemes */ 832 if (!yylexemes) 833 { 834 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 835 if (yylexemes == NULL) goto yyenomem; 836 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 837 if (yylvals == NULL) goto yyenomem; 838 yylvlim = yylvals + YYLVQUEUEGROWTH; 839#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 840 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 841 if (yylpsns == NULL) goto yyenomem; 842 yylplim = yylpsns + YYLVQUEUEGROWTH; 843#endif 844 } 845 if (yylvp == yylve) 846 { 847 yylvp = yylve = yylvals; 848#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 849 yylpp = yylpe = yylpsns; 850#endif 851 yylexp = yylexemes; 852 if (yychar >= YYEOF) 853 { 854 *yylve++ = yylval; 855#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 856 *yylpe++ = yylloc; 857#endif 858 *yylexp = (short) yychar; 859 yychar = YYEMPTY; 860 } 861 } 862 } 863 if (yychar >= YYEOF) 864 { 865 yylvp--; 866#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 867 yylpp--; 868#endif 869 yylexp--; 870 yychar = YYEMPTY; 871 } 872 save->lexeme = (int) (yylvp - yylvals); 873 yyps->save = save; 874 } 875 if (yytable[yyn] == ctry) 876 { 877#if YYDEBUG 878 if (yydebug) 879 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 880 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 881#endif 882 if (yychar < 0) 883 { 884 yylvp++; 885#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 886 yylpp++; 887#endif 888 yylexp++; 889 } 890 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 891 goto yyoverflow; 892 yystate = yyctable[ctry]; 893 *++yystack.s_mark = (short) yystate; 894 *++yystack.l_mark = yylval; 895#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 896 *++yystack.p_mark = yylloc; 897#endif 898 yychar = YYEMPTY; 899 if (yyerrflag > 0) --yyerrflag; 900 goto yyloop; 901 } 902 else 903 { 904 yyn = yyctable[ctry]; 905 goto yyreduce; 906 } 907 } /* End of code dealing with conflicts */ 908#endif /* YYBTYACC */ 909 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 910 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 911 { 912#if YYDEBUG 913 if (yydebug) 914 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 915 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 916#endif 917 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 918 yystate = yytable[yyn]; 919 *++yystack.s_mark = yytable[yyn]; 920 *++yystack.l_mark = yylval; 921#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 922 *++yystack.p_mark = yylloc; 923#endif 924 yychar = YYEMPTY; 925 if (yyerrflag > 0) --yyerrflag; 926 goto yyloop; 927 } 928 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 929 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 930 { 931 yyn = yytable[yyn]; 932 goto yyreduce; 933 } 934 if (yyerrflag != 0) goto yyinrecovery; 935#if YYBTYACC 936 937 yynewerrflag = 1; 938 goto yyerrhandler; 939 goto yyerrlab; 940 941yyerrlab: 942 yynewerrflag = 0; 943yyerrhandler: 944 while (yyps->save) 945 { 946 int ctry; 947 YYParseState *save = yyps->save; 948#if YYDEBUG 949 if (yydebug) 950 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 951 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 952 (int)(yylvp - yylvals - yyps->save->lexeme)); 953#endif 954 /* Memorize most forward-looking error state in case it's really an error. */ 955 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 956 { 957 /* Free old saved error context state */ 958 if (yyerrctx) yyFreeState(yyerrctx); 959 /* Create and fill out new saved error context state */ 960 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 961 if (yyerrctx == NULL) goto yyenomem; 962 yyerrctx->save = yyps->save; 963 yyerrctx->state = yystate; 964 yyerrctx->errflag = yyerrflag; 965 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 966 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 967 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 968 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 969#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 970 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 971 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 972#endif 973 yyerrctx->lexeme = (int) (yylvp - yylvals); 974 } 975 yylvp = yylvals + save->lexeme; 976#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 977 yylpp = yylpsns + save->lexeme; 978#endif 979 yylexp = yylexemes + save->lexeme; 980 yychar = YYEMPTY; 981 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 982 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 983 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 984 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 985#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 986 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 987 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 988#endif 989 ctry = ++save->ctry; 990 yystate = save->state; 991 /* We tried shift, try reduce now */ 992 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 993 yyps->save = save->save; 994 save->save = NULL; 995 yyFreeState(save); 996 997 /* Nothing left on the stack -- error */ 998 if (!yyps->save) 999 { 1000#if YYDEBUG 1001 if (yydebug) 1002 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1003 YYPREFIX, yydepth); 1004#endif 1005 /* Restore state as it was in the most forward-advanced error */ 1006 yylvp = yylvals + yyerrctx->lexeme; 1007#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1008 yylpp = yylpsns + yyerrctx->lexeme; 1009#endif 1010 yylexp = yylexemes + yyerrctx->lexeme; 1011 yychar = yylexp[-1]; 1012 yylval = yylvp[-1]; 1013#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1014 yylloc = yylpp[-1]; 1015#endif 1016 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1017 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1018 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1019 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1020#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1021 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1022 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1023#endif 1024 yystate = yyerrctx->state; 1025 yyFreeState(yyerrctx); 1026 yyerrctx = NULL; 1027 } 1028 yynewerrflag = 1; 1029 } 1030 if (yynewerrflag == 0) goto yyinrecovery; 1031#endif /* YYBTYACC */ 1032 1033 YYERROR_CALL("syntax error"); 1034#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1035 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1036#endif 1037 1038#if !YYBTYACC 1039 goto yyerrlab; 1040yyerrlab: 1041#endif 1042 ++yynerrs; 1043 1044yyinrecovery: 1045 if (yyerrflag < 3) 1046 { 1047 yyerrflag = 3; 1048 for (;;) 1049 { 1050 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1051 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1052 { 1053#if YYDEBUG 1054 if (yydebug) 1055 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1056 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1057#endif 1058 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1059 yystate = yytable[yyn]; 1060 *++yystack.s_mark = yytable[yyn]; 1061 *++yystack.l_mark = yylval; 1062#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1063 /* lookahead position is error end position */ 1064 yyerror_loc_range[1] = yylloc; 1065 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1066 *++yystack.p_mark = yyloc; 1067#endif 1068 goto yyloop; 1069 } 1070 else 1071 { 1072#if YYDEBUG 1073 if (yydebug) 1074 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1075 YYDEBUGSTR, yydepth, *yystack.s_mark); 1076#endif 1077 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1078#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1079 /* the current TOS position is the error start position */ 1080 yyerror_loc_range[0] = *yystack.p_mark; 1081#endif 1082#if defined(YYDESTRUCT_CALL) 1083#if YYBTYACC 1084 if (!yytrial) 1085#endif /* YYBTYACC */ 1086#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1087 YYDESTRUCT_CALL("error: discarding state", 1088 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1089#else 1090 YYDESTRUCT_CALL("error: discarding state", 1091 yystos[*yystack.s_mark], yystack.l_mark); 1092#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1093#endif /* defined(YYDESTRUCT_CALL) */ 1094 --yystack.s_mark; 1095 --yystack.l_mark; 1096#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1097 --yystack.p_mark; 1098#endif 1099 } 1100 } 1101 } 1102 else 1103 { 1104 if (yychar == YYEOF) goto yyabort; 1105#if YYDEBUG 1106 if (yydebug) 1107 { 1108 yys = yyname[YYTRANSLATE(yychar)]; 1109 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1110 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1111 } 1112#endif 1113#if defined(YYDESTRUCT_CALL) 1114#if YYBTYACC 1115 if (!yytrial) 1116#endif /* YYBTYACC */ 1117#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1118 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1119#else 1120 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1121#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1122#endif /* defined(YYDESTRUCT_CALL) */ 1123 yychar = YYEMPTY; 1124 goto yyloop; 1125 } 1126 1127yyreduce: 1128 yym = yylen[yyn]; 1129#if YYDEBUG 1130 if (yydebug) 1131 { 1132 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1133 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1134#ifdef YYSTYPE_TOSTRING 1135#if YYBTYACC 1136 if (!yytrial) 1137#endif /* YYBTYACC */ 1138 if (yym > 0) 1139 { 1140 int i; 1141 fputc('<', stderr); 1142 for (i = yym; i > 0; i--) 1143 { 1144 if (i != yym) fputs(", ", stderr); 1145 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1146 yystack.l_mark[1-i]), stderr); 1147 } 1148 fputc('>', stderr); 1149 } 1150#endif 1151 fputc('\n', stderr); 1152 } 1153#endif 1154 if (yym > 0) 1155 yyval = yystack.l_mark[1-yym]; 1156 else 1157 memset(&yyval, 0, sizeof yyval); 1158#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1159 1160 /* Perform position reduction */ 1161 memset(&yyloc, 0, sizeof(yyloc)); 1162#if YYBTYACC 1163 if (!yytrial) 1164#endif /* YYBTYACC */ 1165 { 1166 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1167 /* just in case YYERROR is invoked within the action, save 1168 the start of the rhs as the error start position */ 1169 yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1170 } 1171#endif 1172 1173 switch (yyn) 1174 { 1175case 3: 1176#line 35 "calc2.y" 1177 { yyerrok ; } 1178break; 1179case 4: 1180#line 39 "calc2.y" 1181 { printf("%d\n",yystack.l_mark[0]);} 1182break; 1183case 5: 1184#line 41 "calc2.y" 1185 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; } 1186break; 1187case 6: 1188#line 45 "calc2.y" 1189 { yyval = yystack.l_mark[-1]; } 1190break; 1191case 7: 1192#line 47 "calc2.y" 1193 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; } 1194break; 1195case 8: 1196#line 49 "calc2.y" 1197 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; } 1198break; 1199case 9: 1200#line 51 "calc2.y" 1201 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; } 1202break; 1203case 10: 1204#line 53 "calc2.y" 1205 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; } 1206break; 1207case 11: 1208#line 55 "calc2.y" 1209 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; } 1210break; 1211case 12: 1212#line 57 "calc2.y" 1213 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; } 1214break; 1215case 13: 1216#line 59 "calc2.y" 1217 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; } 1218break; 1219case 14: 1220#line 61 "calc2.y" 1221 { yyval = - yystack.l_mark[0]; } 1222break; 1223case 15: 1224#line 63 "calc2.y" 1225 { yyval = regs[yystack.l_mark[0]]; } 1226break; 1227case 17: 1228#line 68 "calc2.y" 1229 { yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; } 1230break; 1231case 18: 1232#line 70 "calc2.y" 1233 { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; } 1234break; 1235#line 1236 "calc2.tab.c" 1236 default: 1237 break; 1238 } 1239 yystack.s_mark -= yym; 1240 yystate = *yystack.s_mark; 1241 yystack.l_mark -= yym; 1242#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1243 yystack.p_mark -= yym; 1244#endif 1245 yym = yylhs[yyn]; 1246 if (yystate == 0 && yym == 0) 1247 { 1248#if YYDEBUG 1249 if (yydebug) 1250 { 1251 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1252#ifdef YYSTYPE_TOSTRING 1253#if YYBTYACC 1254 if (!yytrial) 1255#endif /* YYBTYACC */ 1256 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1257#endif 1258 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1259 } 1260#endif 1261 yystate = YYFINAL; 1262 *++yystack.s_mark = YYFINAL; 1263 *++yystack.l_mark = yyval; 1264#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1265 *++yystack.p_mark = yyloc; 1266#endif 1267 if (yychar < 0) 1268 { 1269#if YYBTYACC 1270 do { 1271 if (yylvp < yylve) 1272 { 1273 /* we're currently re-reading tokens */ 1274 yylval = *yylvp++; 1275#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1276 yylloc = *yylpp++; 1277#endif 1278 yychar = *yylexp++; 1279 break; 1280 } 1281 if (yyps->save) 1282 { 1283 /* in trial mode; save scanner results for future parse attempts */ 1284 if (yylvp == yylvlim) 1285 { /* Enlarge lexical value queue */ 1286 size_t p = (size_t) (yylvp - yylvals); 1287 size_t s = (size_t) (yylvlim - yylvals); 1288 1289 s += YYLVQUEUEGROWTH; 1290 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1291 goto yyenomem; 1292 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1293 goto yyenomem; 1294#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1295 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1296 goto yyenomem; 1297#endif 1298 yylvp = yylve = yylvals + p; 1299 yylvlim = yylvals + s; 1300#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1301 yylpp = yylpe = yylpsns + p; 1302 yylplim = yylpsns + s; 1303#endif 1304 yylexp = yylexemes + p; 1305 } 1306 *yylexp = (short) YYLEX; 1307 *yylvp++ = yylval; 1308 yylve++; 1309#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1310 *yylpp++ = yylloc; 1311 yylpe++; 1312#endif 1313 yychar = *yylexp++; 1314 break; 1315 } 1316 /* normal operation, no conflict encountered */ 1317#endif /* YYBTYACC */ 1318 yychar = YYLEX; 1319#if YYBTYACC 1320 } while (0); 1321#endif /* YYBTYACC */ 1322 if (yychar < 0) yychar = YYEOF; 1323 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1324#if YYDEBUG 1325 if (yydebug) 1326 { 1327 yys = yyname[YYTRANSLATE(yychar)]; 1328 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1329 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1330 } 1331#endif 1332 } 1333 if (yychar == YYEOF) goto yyaccept; 1334 goto yyloop; 1335 } 1336 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1337 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1338 yystate = yytable[yyn]; 1339 else 1340 yystate = yydgoto[yym]; 1341#if YYDEBUG 1342 if (yydebug) 1343 { 1344 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1345#ifdef YYSTYPE_TOSTRING 1346#if YYBTYACC 1347 if (!yytrial) 1348#endif /* YYBTYACC */ 1349 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1350#endif 1351 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1352 } 1353#endif 1354 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1355 *++yystack.s_mark = (short) yystate; 1356 *++yystack.l_mark = yyval; 1357#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1358 *++yystack.p_mark = yyloc; 1359#endif 1360 goto yyloop; 1361#if YYBTYACC 1362 1363 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1364yyvalid: 1365 if (yypath) YYABORT; 1366 while (yyps->save) 1367 { 1368 YYParseState *save = yyps->save; 1369 yyps->save = save->save; 1370 save->save = yypath; 1371 yypath = save; 1372 } 1373#if YYDEBUG 1374 if (yydebug) 1375 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1376 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1377#endif 1378 if (yyerrctx) 1379 { 1380 yyFreeState(yyerrctx); 1381 yyerrctx = NULL; 1382 } 1383 yylvp = yylvals + yypath->lexeme; 1384#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1385 yylpp = yylpsns + yypath->lexeme; 1386#endif 1387 yylexp = yylexemes + yypath->lexeme; 1388 yychar = YYEMPTY; 1389 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1390 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1391 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1392 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1393#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1394 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1395 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1396#endif 1397 yystate = yypath->state; 1398 goto yyloop; 1399#endif /* YYBTYACC */ 1400 1401yyoverflow: 1402 YYERROR_CALL("yacc stack overflow"); 1403#if YYBTYACC 1404 goto yyabort_nomem; 1405yyenomem: 1406 YYERROR_CALL("memory exhausted"); 1407yyabort_nomem: 1408#endif /* YYBTYACC */ 1409 yyresult = 2; 1410 goto yyreturn; 1411 1412yyabort: 1413 yyresult = 1; 1414 goto yyreturn; 1415 1416yyaccept: 1417#if YYBTYACC 1418 if (yyps->save) goto yyvalid; 1419#endif /* YYBTYACC */ 1420 yyresult = 0; 1421 1422yyreturn: 1423#if defined(YYDESTRUCT_CALL) 1424 if (yychar != YYEOF && yychar != YYEMPTY) 1425#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1426 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1427#else 1428 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1429#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1430 1431 { 1432 YYSTYPE *pv; 1433#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1434 YYLTYPE *pp; 1435 1436 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1437 YYDESTRUCT_CALL("cleanup: discarding state", 1438 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1439#else 1440 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1441 YYDESTRUCT_CALL("cleanup: discarding state", 1442 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1443#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1444 } 1445#endif /* defined(YYDESTRUCT_CALL) */ 1446 1447#if YYBTYACC 1448 if (yyerrctx) 1449 { 1450 yyFreeState(yyerrctx); 1451 yyerrctx = NULL; 1452 } 1453 while (yyps) 1454 { 1455 YYParseState *save = yyps; 1456 yyps = save->save; 1457 save->save = NULL; 1458 yyFreeState(save); 1459 } 1460 while (yypath) 1461 { 1462 YYParseState *save = yypath; 1463 yypath = save->save; 1464 save->save = NULL; 1465 yyFreeState(save); 1466 } 1467#endif /* YYBTYACC */ 1468 yyfreestack(&yystack); 1469 return (yyresult); 1470} 1471