1 /* original parser id follows */ 2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 4 5 #define YYBYACC 1 6 #define YYMAJOR 1 7 #define YYMINOR 9 8 #define YYCHECK "yyyymmdd" 9 10 #define YYEMPTY (-1) 11 #define yyclearin (yychar = YYEMPTY) 12 #define yyerrok (yyerrflag = 0) 13 #define YYRECOVERING() (yyerrflag != 0) 14 #define YYENOMEM (-2) 15 #define YYEOF 0 16 #undef YYBTYACC 17 #define YYBTYACC 1 18 #define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug") 19 20 #ifndef yyparse 21 #define yyparse calc1_parse 22 #endif /* yyparse */ 23 24 #ifndef yylex 25 #define yylex calc1_lex 26 #endif /* yylex */ 27 28 #ifndef yyerror 29 #define yyerror calc1_error 30 #endif /* yyerror */ 31 32 #ifndef yychar 33 #define yychar calc1_char 34 #endif /* yychar */ 35 36 #ifndef yyval 37 #define yyval calc1_val 38 #endif /* yyval */ 39 40 #ifndef yylval 41 #define yylval calc1_lval 42 #endif /* yylval */ 43 44 #ifndef yydebug 45 #define yydebug calc1_debug 46 #endif /* yydebug */ 47 48 #ifndef yynerrs 49 #define yynerrs calc1_nerrs 50 #endif /* yynerrs */ 51 52 #ifndef yyerrflag 53 #define yyerrflag calc1_errflag 54 #endif /* yyerrflag */ 55 56 #ifndef yylhs 57 #define yylhs calc1_lhs 58 #endif /* yylhs */ 59 60 #ifndef yylen 61 #define yylen calc1_len 62 #endif /* yylen */ 63 64 #ifndef yydefred 65 #define yydefred calc1_defred 66 #endif /* yydefred */ 67 68 #ifndef yystos 69 #define yystos calc1_stos 70 #endif /* yystos */ 71 72 #ifndef yydgoto 73 #define yydgoto calc1_dgoto 74 #endif /* yydgoto */ 75 76 #ifndef yysindex 77 #define yysindex calc1_sindex 78 #endif /* yysindex */ 79 80 #ifndef yyrindex 81 #define yyrindex calc1_rindex 82 #endif /* yyrindex */ 83 84 #ifndef yygindex 85 #define yygindex calc1_gindex 86 #endif /* yygindex */ 87 88 #ifndef yytable 89 #define yytable calc1_table 90 #endif /* yytable */ 91 92 #ifndef yycheck 93 #define yycheck calc1_check 94 #endif /* yycheck */ 95 96 #ifndef yyname 97 #define yyname calc1_name 98 #endif /* yyname */ 99 100 #ifndef yyrule 101 #define yyrule calc1_rule 102 #endif /* yyrule */ 103 104 #if YYBTYACC 105 106 #ifndef yycindex 107 #define yycindex calc1_cindex 108 #endif /* yycindex */ 109 110 #ifndef yyctable 111 #define yyctable calc1_ctable 112 #endif /* yyctable */ 113 114 #endif /* YYBTYACC */ 115 116 #define YYPREFIX "calc1_" 117 118 #define YYPURE 1 119 120 #line 3 "btyacc_calc1.y" 121 122 /* http://dinosaur.compilertools.net/yacc/index.html */ 123 124 #include <stdlib.h> 125 #include <stdio.h> 126 #include <ctype.h> 127 #include <math.h> 128 129 typedef struct interval 130 { 131 double lo, hi; 132 } 133 INTERVAL; 134 135 INTERVAL vmul(double, double, INTERVAL); 136 INTERVAL vdiv(double, double, INTERVAL); 137 138 int dcheck(INTERVAL); 139 140 double dreg[26]; 141 INTERVAL vreg[26]; 142 143 #ifdef YYSTYPE 144 #undef YYSTYPE_IS_DECLARED 145 #define YYSTYPE_IS_DECLARED 1 146 #endif 147 #ifndef YYSTYPE_IS_DECLARED 148 #define YYSTYPE_IS_DECLARED 1 149 #line 29 "btyacc_calc1.y" 150 typedef union 151 { 152 int ival; 153 double dval; 154 INTERVAL vval; 155 } YYSTYPE; 156 #endif /* !YYSTYPE_IS_DECLARED */ 157 #line 158 "btyacc_calc1.tab.c" 158 159 /* compatibility with bison */ 160 #ifdef YYPARSE_PARAM 161 /* compatibility with FreeBSD */ 162 # ifdef YYPARSE_PARAM_TYPE 163 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 164 # else 165 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 166 # endif 167 #else 168 # define YYPARSE_DECL() yyparse(void) 169 #endif 170 171 /* Parameters sent to lex. */ 172 #ifdef YYLEX_PARAM 173 # ifdef YYLEX_PARAM_TYPE 174 # define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM) 175 # else 176 # define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM) 177 # endif 178 # define YYLEX yylex(&yylval, YYLEX_PARAM) 179 #else 180 # define YYLEX_DECL() yylex(YYSTYPE *yylval) 181 # define YYLEX yylex(&yylval) 182 #endif 183 184 /* Parameters sent to yyerror. */ 185 #ifndef YYERROR_DECL 186 #define YYERROR_DECL() yyerror(const char *s) 187 #endif 188 #ifndef YYERROR_CALL 189 #define YYERROR_CALL(msg) yyerror(msg) 190 #endif 191 192 extern int YYPARSE_DECL(); 193 194 #define DREG 257 195 #define VREG 258 196 #define CONST 259 197 #define UMINUS 260 198 #define YYERRCODE 256 199 typedef int YYINT; 200 static const YYINT calc1_lhs[] = { -1, 201 0, 0, 0, 3, 3, 3, 3, 1, 1, 1, 202 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 203 2, 2, 2, 2, 2, 2, 2, 2, 204 }; 205 static const YYINT calc1_len[] = { 2, 206 0, 3, 3, 1, 1, 3, 3, 1, 1, 3, 207 3, 3, 3, 2, 3, 1, 5, 1, 3, 3, 208 3, 3, 3, 3, 3, 3, 2, 3, 209 }; 210 static const YYINT calc1_defred[] = { 1, 211 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 212 3, 0, 0, 9, 18, 0, 27, 0, 0, 0, 213 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 214 0, 0, 0, 15, 0, 28, 0, 0, 0, 0, 215 0, 24, 0, 26, 0, 0, 23, 25, 14, 0, 216 0, 0, 0, 0, 0, 0, 0, 12, 13, 17, 217 }; 218 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) 219 static const YYINT calc1_stos[] = { 0, 220 262, 256, 257, 258, 259, 45, 40, 263, 264, 265, 221 10, 61, 61, 257, 258, 263, 264, 263, 264, 43, 222 45, 42, 47, 43, 45, 42, 47, 10, 45, 40, 223 263, 263, 264, 41, 44, 41, 263, 264, 263, 264, 224 263, 264, 263, 264, 264, 264, 264, 264, 263, 263, 225 43, 45, 42, 47, 263, 263, 263, 263, 263, 41, 226 }; 227 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ 228 static const YYINT calc1_dgoto[] = { 1, 229 32, 9, 10, 230 }; 231 static const YYINT calc1_sindex[] = { 0, 232 -40, -9, -59, -54, 0, -37, -37, 0, 82, 4, 233 0, -34, -37, 0, 0, 0, 0, -31, -25, -37, 234 -37, -37, -37, -37, -37, -37, -37, 0, -34, -34, 235 132, 0, 82, 0, -34, 0, 0, -12, 0, -12, 236 0, 0, 0, 0, -12, -12, 0, 0, 0, 112, 237 -34, -34, -34, -34, 119, -11, -11, 0, 0, 0, 238 }; 239 static const YYINT calc1_rindex[] = { 0, 240 0, 0, 51, 58, 0, 0, 0, 0, 11, 0, 241 0, 0, 0, 0, 0, -16, 0, 0, 0, 0, 242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 243 19, 9, 27, 0, 0, 0, -5, 41, -4, 77, 244 -2, 0, 8, 0, 78, 85, 0, 0, 0, 0, 245 0, 0, 0, 0, 0, 92, 99, 0, 0, 0, 246 }; 247 #if YYBTYACC 248 static const YYINT calc1_cindex[] = { 0, 249 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 250 0, 0, 0, 0, 0, 2, 0, 126, 0, 0, 251 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252 0, 138, 0, 0, 0, 0, 17, 0, 24, 0, 253 31, 0, 38, 0, 0, 0, 0, 0, 0, 0, 254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255 }; 256 #endif 257 static const YYINT calc1_gindex[] = { 0, 258 3, 125, 0, 259 }; 260 #define YYTABLESIZE 225 261 static const YYINT calc1_table[] = { 7, 262 11, 12, 7, 8, 6, 30, 13, 6, 16, 18, 263 29, 14, 35, 28, 31, 36, 26, 24, 16, 25, 264 5, 27, 37, 39, 41, 43, 20, 14, 6, 26, 265 53, 49, 50, 23, 27, 54, 7, 55, 10, 11, 266 26, 12, 14, 14, 14, 0, 14, 29, 14, 16, 267 20, 13, 0, 56, 57, 58, 59, 20, 6, 20, 268 9, 20, 0, 9, 23, 6, 23, 18, 23, 0, 269 9, 26, 26, 26, 11, 26, 0, 26, 29, 29, 270 29, 20, 29, 20, 29, 20, 22, 19, 0, 0, 271 0, 0, 9, 9, 21, 9, 0, 9, 0, 18, 272 18, 10, 18, 0, 18, 0, 6, 0, 11, 3, 273 0, 9, 0, 0, 0, 0, 0, 22, 19, 22, 274 19, 22, 19, 26, 24, 21, 25, 21, 27, 21, 275 17, 19, 10, 0, 10, 0, 10, 33, 0, 11, 276 0, 11, 0, 11, 38, 40, 42, 44, 45, 46, 277 47, 48, 34, 53, 51, 0, 52, 0, 54, 60, 278 53, 51, 0, 52, 0, 54, 18, 6, 0, 0, 279 3, 0, 9, 53, 51, 0, 52, 0, 54, 6, 280 0, 0, 3, 0, 9, 0, 0, 0, 0, 0, 281 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 282 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 283 0, 0, 0, 0, 0, 2, 3, 4, 5, 14, 284 15, 5, 14, 0, 5, 285 }; 286 static const YYINT calc1_check[] = { 40, 287 10, 61, 40, 1, 45, 40, 61, 45, 6, 7, 288 45, 10, 44, 10, 12, 41, 42, 43, 10, 45, 289 10, 47, 20, 21, 22, 23, 10, 44, 10, 42, 290 42, 29, 30, 10, 47, 47, 10, 35, 44, 44, 291 10, 44, 41, 42, 43, -1, 45, 10, 47, 41, 292 10, 44, -1, 51, 52, 53, 54, 41, 42, 43, 293 10, 45, -1, 47, 41, 42, 43, 10, 45, -1, 294 47, 41, 42, 43, 10, 45, -1, 47, 41, 42, 295 43, 41, 45, 43, 47, 45, 10, 10, -1, -1, 296 -1, -1, 42, 43, 10, 45, -1, 47, -1, 42, 297 43, 10, 45, -1, 47, -1, 42, 43, 10, 45, 298 -1, 47, -1, -1, -1, -1, -1, 41, 41, 43, 299 43, 45, 45, 42, 43, 41, 45, 43, 47, 45, 300 6, 7, 41, -1, 43, -1, 45, 13, -1, 41, 301 -1, 43, -1, 45, 20, 21, 22, 23, 24, 25, 302 26, 27, 41, 42, 43, -1, 45, -1, 47, 41, 303 42, 43, -1, 45, -1, 47, 41, 42, 43, -1, 304 45, -1, 47, 42, 43, -1, 45, -1, 47, 42, 305 43, -1, 45, -1, 47, -1, -1, -1, -1, -1, 306 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 308 -1, -1, -1, -1, -1, 256, 257, 258, 259, 257, 309 258, 259, 257, -1, 259, 310 }; 311 #if YYBTYACC 312 static const YYINT calc1_ctable[] = { 20, 313 16, -1, 21, 16, -1, 22, 16, -1, 23, 16, 314 -1, 4, 16, -1, 14, 16, -1, 34, 16, -1, 315 10, 16, -1, 11, 16, -1, 12, 16, -1, 13, 316 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, 317 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 318 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 319 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 320 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 321 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 322 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 323 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 324 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 325 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 326 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 327 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 328 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 329 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 330 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 331 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 332 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 333 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 334 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 335 -1, -1, -1, -1, 336 }; 337 #endif 338 #define YYFINAL 1 339 #ifndef YYDEBUG 340 #define YYDEBUG 0 341 #endif 342 #define YYMAXTOKEN 260 343 #define YYUNDFTOKEN 266 344 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 345 #if YYDEBUG 346 static const char *const calc1_name[] = { 347 348 "$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, 349 0,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0, 350 0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 351 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 352 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 353 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 354 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 355 "error","DREG","VREG","CONST","UMINUS","$accept","lines","dexp","vexp","line", 356 "illegal-symbol", 357 }; 358 static const char *const calc1_rule[] = { 359 "$accept : lines", 360 "lines :", 361 "lines : lines line '\\n'", 362 "lines : lines error '\\n'", 363 "line : dexp", 364 "line : vexp", 365 "line : DREG '=' dexp", 366 "line : VREG '=' vexp", 367 "dexp : CONST", 368 "dexp : DREG", 369 "dexp : dexp '+' dexp", 370 "dexp : dexp '-' dexp", 371 "dexp : dexp '*' dexp", 372 "dexp : dexp '/' dexp", 373 "dexp : '-' dexp", 374 "dexp : '(' dexp ')'", 375 "vexp : dexp", 376 "vexp : '(' dexp ',' dexp ')'", 377 "vexp : VREG", 378 "vexp : vexp '+' vexp", 379 "vexp : dexp '+' vexp", 380 "vexp : vexp '-' vexp", 381 "vexp : dexp '-' vexp", 382 "vexp : vexp '*' vexp", 383 "vexp : dexp '*' vexp", 384 "vexp : vexp '/' vexp", 385 "vexp : dexp '/' vexp", 386 "vexp : '-' vexp", 387 "vexp : '(' vexp ')'", 388 389 }; 390 #endif 391 392 #if YYDEBUG 393 int yydebug; 394 #endif 395 396 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 397 #ifndef YYLLOC_DEFAULT 398 #define YYLLOC_DEFAULT(loc, rhs, n) \ 399 do \ 400 { \ 401 if (n == 0) \ 402 { \ 403 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \ 404 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \ 405 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \ 406 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \ 407 } \ 408 else \ 409 { \ 410 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \ 411 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \ 412 (loc).last_line = YYRHSLOC(rhs, n).last_line; \ 413 (loc).last_column = YYRHSLOC(rhs, n).last_column; \ 414 } \ 415 } while (0) 416 #endif /* YYLLOC_DEFAULT */ 417 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 418 #if YYBTYACC 419 420 #ifndef YYLVQUEUEGROWTH 421 #define YYLVQUEUEGROWTH 32 422 #endif 423 #endif /* YYBTYACC */ 424 425 /* define the initial stack-sizes */ 426 #ifdef YYSTACKSIZE 427 #undef YYMAXDEPTH 428 #define YYMAXDEPTH YYSTACKSIZE 429 #else 430 #ifdef YYMAXDEPTH 431 #define YYSTACKSIZE YYMAXDEPTH 432 #else 433 #define YYSTACKSIZE 10000 434 #define YYMAXDEPTH 10000 435 #endif 436 #endif 437 438 #ifndef YYINITSTACKSIZE 439 #define YYINITSTACKSIZE 200 440 #endif 441 442 typedef struct { 443 unsigned stacksize; 444 YYINT *s_base; 445 YYINT *s_mark; 446 YYINT *s_last; 447 YYSTYPE *l_base; 448 YYSTYPE *l_mark; 449 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 450 YYLTYPE *p_base; 451 YYLTYPE *p_mark; 452 #endif 453 } YYSTACKDATA; 454 #if YYBTYACC 455 456 struct YYParseState_s 457 { 458 struct YYParseState_s *save; /* Previously saved parser state */ 459 YYSTACKDATA yystack; /* saved parser stack */ 460 int state; /* saved parser state */ 461 int errflag; /* saved error recovery status */ 462 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 463 YYINT ctry; /* saved index in yyctable[] for this conflict */ 464 }; 465 typedef struct YYParseState_s YYParseState; 466 #endif /* YYBTYACC */ 467 #line 174 "btyacc_calc1.y" 468 /* beginning of subroutines section */ 469 470 int 471 main (void) 472 { 473 while(!feof(stdin)) { 474 yyparse(); 475 } 476 return 0; 477 } 478 479 #define BSZ 50 /* buffer size for floating point numbers */ 480 481 static void 482 YYERROR_DECL() 483 { 484 fprintf(stderr, "%s\n", s); 485 } 486 487 /* lexical analysis */ 488 489 static int 490 YYLEX_DECL() 491 { 492 int c; 493 494 while ((c = getchar()) == ' ') 495 { /* skip over blanks */ 496 } 497 498 if (isupper(c)) 499 { 500 #if YYPURE 501 (*yylval).ival = c - 'A'; 502 #else 503 yylval.ival = c - 'A'; 504 #endif 505 return (VREG); 506 } 507 if (islower(c)) 508 { 509 #if YYPURE 510 (*yylval).ival = c - 'a'; 511 #else 512 yylval.ival = c - 'a'; 513 #endif 514 return (DREG); 515 } 516 517 if (isdigit(c) || c == '.') 518 { 519 /* gobble up digits, points, exponents */ 520 char buf[BSZ + 1], *cp = buf; 521 int dot = 0, expr = 0; 522 523 for (; (cp - buf) < BSZ; ++cp, c = getchar()) 524 { 525 526 *cp = (char) c; 527 if (isdigit(c)) 528 continue; 529 if (c == '.') 530 { 531 if (dot++ || expr) 532 return ('.'); /* will cause syntax error */ 533 continue; 534 } 535 536 if (c == 'e') 537 { 538 if (expr++) 539 return ('e'); /* will cause syntax error */ 540 continue; 541 } 542 543 /* end of number */ 544 break; 545 } 546 *cp = '\0'; 547 548 if ((cp - buf) >= BSZ) 549 printf("constant too long: truncated\n"); 550 else 551 ungetc(c, stdin); /* push back last char read */ 552 #if YYPURE 553 (*yylval).dval = atof(buf); 554 #else 555 yylval.dval = atof(buf); 556 #endif 557 return (CONST); 558 } 559 return (c); 560 } 561 562 static INTERVAL 563 hilo(double a, double b, double c, double d) 564 { 565 /* returns the smallest interval containing a, b, c, and d */ 566 /* used by *, / routines */ 567 INTERVAL v; 568 569 if (a > b) 570 { 571 v.hi = a; 572 v.lo = b; 573 } 574 else 575 { 576 v.hi = b; 577 v.lo = a; 578 } 579 580 if (c > d) 581 { 582 if (c > v.hi) 583 v.hi = c; 584 if (d < v.lo) 585 v.lo = d; 586 } 587 else 588 { 589 if (d > v.hi) 590 v.hi = d; 591 if (c < v.lo) 592 v.lo = c; 593 } 594 return (v); 595 } 596 597 INTERVAL 598 vmul(double a, double b, INTERVAL v) 599 { 600 return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo)); 601 } 602 603 int 604 dcheck(INTERVAL v) 605 { 606 if (v.hi >= 0. && v.lo <= 0.) 607 { 608 printf("divisor interval contains 0.\n"); 609 return (1); 610 } 611 return (0); 612 } 613 614 INTERVAL 615 vdiv(double a, double b, INTERVAL v) 616 { 617 return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo)); 618 } 619 #line 620 "btyacc_calc1.tab.c" 620 621 /* For use in generated program */ 622 #define yydepth (int)(yystack.s_mark - yystack.s_base) 623 #if YYBTYACC 624 #define yytrial (yyps->save) 625 #endif /* YYBTYACC */ 626 627 #if YYDEBUG 628 #include <stdio.h> /* needed for printf */ 629 #endif 630 631 #include <stdlib.h> /* needed for malloc, etc */ 632 #include <string.h> /* needed for memset */ 633 634 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ 635 static int yygrowstack(YYSTACKDATA *data) 636 { 637 int i; 638 unsigned newsize; 639 YYINT *newss; 640 YYSTYPE *newvs; 641 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 642 YYLTYPE *newps; 643 #endif 644 645 if ((newsize = data->stacksize) == 0) 646 newsize = YYINITSTACKSIZE; 647 else if (newsize >= YYMAXDEPTH) 648 return YYENOMEM; 649 else if ((newsize *= 2) > YYMAXDEPTH) 650 newsize = YYMAXDEPTH; 651 652 i = (int) (data->s_mark - data->s_base); 653 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 654 if (newss == 0) 655 return YYENOMEM; 656 657 data->s_base = newss; 658 data->s_mark = newss + i; 659 660 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 661 if (newvs == 0) 662 return YYENOMEM; 663 664 data->l_base = newvs; 665 data->l_mark = newvs + i; 666 667 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 668 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 669 if (newps == 0) 670 return YYENOMEM; 671 672 data->p_base = newps; 673 data->p_mark = newps + i; 674 #endif 675 676 data->stacksize = newsize; 677 data->s_last = data->s_base + newsize - 1; 678 679 #if YYDEBUG 680 if (yydebug) 681 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 682 #endif 683 return 0; 684 } 685 686 #if YYPURE || defined(YY_NO_LEAKS) 687 static void yyfreestack(YYSTACKDATA *data) 688 { 689 free(data->s_base); 690 free(data->l_base); 691 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 692 free(data->p_base); 693 #endif 694 memset(data, 0, sizeof(*data)); 695 } 696 #else 697 #define yyfreestack(data) /* nothing */ 698 #endif /* YYPURE || defined(YY_NO_LEAKS) */ 699 #if YYBTYACC 700 701 static YYParseState * 702 yyNewState(unsigned size) 703 { 704 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 705 if (p == NULL) return NULL; 706 707 p->yystack.stacksize = size; 708 if (size == 0) 709 { 710 p->yystack.s_base = NULL; 711 p->yystack.l_base = NULL; 712 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 713 p->yystack.p_base = NULL; 714 #endif 715 return p; 716 } 717 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 718 if (p->yystack.s_base == NULL) return NULL; 719 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 720 if (p->yystack.l_base == NULL) return NULL; 721 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 722 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 723 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 724 if (p->yystack.p_base == NULL) return NULL; 725 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 726 #endif 727 728 return p; 729 } 730 731 static void 732 yyFreeState(YYParseState *p) 733 { 734 yyfreestack(&p->yystack); 735 free(p); 736 } 737 #endif /* YYBTYACC */ 738 739 #define YYABORT goto yyabort 740 #define YYREJECT goto yyabort 741 #define YYACCEPT goto yyaccept 742 #define YYERROR goto yyerrlab 743 #if YYBTYACC 744 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 745 #define YYVALID_NESTED do { if (yyps->save && \ 746 yyps->save->save == 0) goto yyvalid; } while(0) 747 #endif /* YYBTYACC */ 748 749 int 750 YYPARSE_DECL() 751 { 752 int yyerrflag; 753 int yychar; 754 YYSTYPE yyval; 755 YYSTYPE yylval; 756 int yynerrs; 757 758 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 759 YYLTYPE yyloc; /* position returned by actions */ 760 YYLTYPE yylloc; /* position from the lexer */ 761 #endif 762 763 /* variables for the parser stack */ 764 YYSTACKDATA yystack; 765 #if YYBTYACC 766 767 /* Current parser state */ 768 static YYParseState *yyps = 0; 769 770 /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 771 static YYParseState *yypath = 0; 772 773 /* Base of the lexical value queue */ 774 static YYSTYPE *yylvals = 0; 775 776 /* Current position at lexical value queue */ 777 static YYSTYPE *yylvp = 0; 778 779 /* End position of lexical value queue */ 780 static YYSTYPE *yylve = 0; 781 782 /* The last allocated position at the lexical value queue */ 783 static YYSTYPE *yylvlim = 0; 784 785 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 786 /* Base of the lexical position queue */ 787 static YYLTYPE *yylpsns = 0; 788 789 /* Current position at lexical position queue */ 790 static YYLTYPE *yylpp = 0; 791 792 /* End position of lexical position queue */ 793 static YYLTYPE *yylpe = 0; 794 795 /* The last allocated position at the lexical position queue */ 796 static YYLTYPE *yylplim = 0; 797 #endif 798 799 /* Current position at lexical token queue */ 800 static YYINT *yylexp = 0; 801 802 static YYINT *yylexemes = 0; 803 #endif /* YYBTYACC */ 804 int yym, yyn, yystate, yyresult; 805 #if YYBTYACC 806 int yynewerrflag; 807 YYParseState *yyerrctx = NULL; 808 #endif /* YYBTYACC */ 809 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 810 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */ 811 #endif 812 #if YYDEBUG 813 const char *yys; 814 815 if ((yys = getenv("YYDEBUG")) != 0) 816 { 817 yyn = *yys; 818 if (yyn >= '0' && yyn <= '9') 819 yydebug = yyn - '0'; 820 } 821 if (yydebug) 822 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 823 #endif 824 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 825 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 826 #endif 827 828 yyerrflag = 0; 829 yychar = 0; 830 memset(&yyval, 0, sizeof(yyval)); 831 memset(&yylval, 0, sizeof(yylval)); 832 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 833 memset(&yyloc, 0, sizeof(yyloc)); 834 memset(&yylloc, 0, sizeof(yylloc)); 835 #endif 836 837 #if YYBTYACC 838 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 839 yyps->save = 0; 840 #endif /* YYBTYACC */ 841 yym = 0; 842 yyn = 0; 843 yynerrs = 0; 844 yyerrflag = 0; 845 yychar = YYEMPTY; 846 yystate = 0; 847 848 #if YYPURE 849 memset(&yystack, 0, sizeof(yystack)); 850 #endif 851 852 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 853 yystack.s_mark = yystack.s_base; 854 yystack.l_mark = yystack.l_base; 855 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 856 yystack.p_mark = yystack.p_base; 857 #endif 858 yystate = 0; 859 *yystack.s_mark = 0; 860 861 yyloop: 862 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 863 if (yychar < 0) 864 { 865 #if YYBTYACC 866 do { 867 if (yylvp < yylve) 868 { 869 /* we're currently re-reading tokens */ 870 yylval = *yylvp++; 871 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 872 yylloc = *yylpp++; 873 #endif 874 yychar = *yylexp++; 875 break; 876 } 877 if (yyps->save) 878 { 879 /* in trial mode; save scanner results for future parse attempts */ 880 if (yylvp == yylvlim) 881 { /* Enlarge lexical value queue */ 882 size_t p = (size_t) (yylvp - yylvals); 883 size_t s = (size_t) (yylvlim - yylvals); 884 885 s += YYLVQUEUEGROWTH; 886 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 887 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 888 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 889 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 890 #endif 891 yylvp = yylve = yylvals + p; 892 yylvlim = yylvals + s; 893 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 894 yylpp = yylpe = yylpsns + p; 895 yylplim = yylpsns + s; 896 #endif 897 yylexp = yylexemes + p; 898 } 899 *yylexp = (YYINT) YYLEX; 900 *yylvp++ = yylval; 901 yylve++; 902 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 903 *yylpp++ = yylloc; 904 yylpe++; 905 #endif 906 yychar = *yylexp++; 907 break; 908 } 909 /* normal operation, no conflict encountered */ 910 #endif /* YYBTYACC */ 911 yychar = YYLEX; 912 #if YYBTYACC 913 } while (0); 914 #endif /* YYBTYACC */ 915 if (yychar < 0) yychar = YYEOF; 916 #if YYDEBUG 917 if (yydebug) 918 { 919 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 920 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 921 YYDEBUGSTR, yydepth, yystate, yychar, yys); 922 #ifdef YYSTYPE_TOSTRING 923 #if YYBTYACC 924 if (!yytrial) 925 #endif /* YYBTYACC */ 926 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 927 #endif 928 fputc('\n', stderr); 929 } 930 #endif 931 } 932 #if YYBTYACC 933 934 /* Do we have a conflict? */ 935 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 936 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 937 { 938 YYINT ctry; 939 940 if (yypath) 941 { 942 YYParseState *save; 943 #if YYDEBUG 944 if (yydebug) 945 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 946 YYDEBUGSTR, yydepth, yystate); 947 #endif 948 /* Switch to the next conflict context */ 949 save = yypath; 950 yypath = save->save; 951 save->save = NULL; 952 ctry = save->ctry; 953 if (save->state != yystate) YYABORT; 954 yyFreeState(save); 955 956 } 957 else 958 { 959 960 /* Unresolved conflict - start/continue trial parse */ 961 YYParseState *save; 962 #if YYDEBUG 963 if (yydebug) 964 { 965 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 966 if (yyps->save) 967 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 968 else 969 fputs("Starting trial parse.\n", stderr); 970 } 971 #endif 972 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 973 if (save == NULL) goto yyenomem; 974 save->save = yyps->save; 975 save->state = yystate; 976 save->errflag = yyerrflag; 977 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 978 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 979 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 980 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 981 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 982 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 983 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 984 #endif 985 ctry = yytable[yyn]; 986 if (yyctable[ctry] == -1) 987 { 988 #if YYDEBUG 989 if (yydebug && yychar >= YYEOF) 990 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 991 #endif 992 ctry++; 993 } 994 save->ctry = ctry; 995 if (yyps->save == NULL) 996 { 997 /* If this is a first conflict in the stack, start saving lexemes */ 998 if (!yylexemes) 999 { 1000 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 1001 if (yylexemes == NULL) goto yyenomem; 1002 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 1003 if (yylvals == NULL) goto yyenomem; 1004 yylvlim = yylvals + YYLVQUEUEGROWTH; 1005 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1006 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 1007 if (yylpsns == NULL) goto yyenomem; 1008 yylplim = yylpsns + YYLVQUEUEGROWTH; 1009 #endif 1010 } 1011 if (yylvp == yylve) 1012 { 1013 yylvp = yylve = yylvals; 1014 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1015 yylpp = yylpe = yylpsns; 1016 #endif 1017 yylexp = yylexemes; 1018 if (yychar >= YYEOF) 1019 { 1020 *yylve++ = yylval; 1021 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1022 *yylpe++ = yylloc; 1023 #endif 1024 *yylexp = (YYINT) yychar; 1025 yychar = YYEMPTY; 1026 } 1027 } 1028 } 1029 if (yychar >= YYEOF) 1030 { 1031 yylvp--; 1032 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1033 yylpp--; 1034 #endif 1035 yylexp--; 1036 yychar = YYEMPTY; 1037 } 1038 save->lexeme = (int) (yylvp - yylvals); 1039 yyps->save = save; 1040 } 1041 if (yytable[yyn] == ctry) 1042 { 1043 #if YYDEBUG 1044 if (yydebug) 1045 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1046 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 1047 #endif 1048 if (yychar < 0) 1049 { 1050 yylvp++; 1051 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1052 yylpp++; 1053 #endif 1054 yylexp++; 1055 } 1056 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 1057 goto yyoverflow; 1058 yystate = yyctable[ctry]; 1059 *++yystack.s_mark = (YYINT) yystate; 1060 *++yystack.l_mark = yylval; 1061 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1062 *++yystack.p_mark = yylloc; 1063 #endif 1064 yychar = YYEMPTY; 1065 if (yyerrflag > 0) --yyerrflag; 1066 goto yyloop; 1067 } 1068 else 1069 { 1070 yyn = yyctable[ctry]; 1071 goto yyreduce; 1072 } 1073 } /* End of code dealing with conflicts */ 1074 #endif /* YYBTYACC */ 1075 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1076 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1077 { 1078 #if YYDEBUG 1079 if (yydebug) 1080 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1081 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 1082 #endif 1083 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1084 yystate = yytable[yyn]; 1085 *++yystack.s_mark = yytable[yyn]; 1086 *++yystack.l_mark = yylval; 1087 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1088 *++yystack.p_mark = yylloc; 1089 #endif 1090 yychar = YYEMPTY; 1091 if (yyerrflag > 0) --yyerrflag; 1092 goto yyloop; 1093 } 1094 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1095 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1096 { 1097 yyn = yytable[yyn]; 1098 goto yyreduce; 1099 } 1100 if (yyerrflag != 0) goto yyinrecovery; 1101 #if YYBTYACC 1102 1103 yynewerrflag = 1; 1104 goto yyerrhandler; 1105 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1106 1107 yyerrlab: 1108 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 1109 * before looking for error recovery */ 1110 yystack.s_mark -= yym; 1111 yystate = *yystack.s_mark; 1112 yystack.l_mark -= yym; 1113 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1114 yystack.p_mark -= yym; 1115 #endif 1116 1117 yynewerrflag = 0; 1118 yyerrhandler: 1119 while (yyps->save) 1120 { 1121 int ctry; 1122 YYParseState *save = yyps->save; 1123 #if YYDEBUG 1124 if (yydebug) 1125 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 1126 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 1127 (int)(yylvp - yylvals - yyps->save->lexeme)); 1128 #endif 1129 /* Memorize most forward-looking error state in case it's really an error. */ 1130 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 1131 { 1132 /* Free old saved error context state */ 1133 if (yyerrctx) yyFreeState(yyerrctx); 1134 /* Create and fill out new saved error context state */ 1135 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 1136 if (yyerrctx == NULL) goto yyenomem; 1137 yyerrctx->save = yyps->save; 1138 yyerrctx->state = yystate; 1139 yyerrctx->errflag = yyerrflag; 1140 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 1141 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1142 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 1143 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1144 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1145 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 1146 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1147 #endif 1148 yyerrctx->lexeme = (int) (yylvp - yylvals); 1149 } 1150 yylvp = yylvals + save->lexeme; 1151 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1152 yylpp = yylpsns + save->lexeme; 1153 #endif 1154 yylexp = yylexemes + save->lexeme; 1155 yychar = YYEMPTY; 1156 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1157 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1158 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1159 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1160 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1161 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1162 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1163 #endif 1164 ctry = ++save->ctry; 1165 yystate = save->state; 1166 /* We tried shift, try reduce now */ 1167 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1168 yyps->save = save->save; 1169 save->save = NULL; 1170 yyFreeState(save); 1171 1172 /* Nothing left on the stack -- error */ 1173 if (!yyps->save) 1174 { 1175 #if YYDEBUG 1176 if (yydebug) 1177 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1178 YYPREFIX, yydepth); 1179 #endif 1180 /* Restore state as it was in the most forward-advanced error */ 1181 yylvp = yylvals + yyerrctx->lexeme; 1182 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1183 yylpp = yylpsns + yyerrctx->lexeme; 1184 #endif 1185 yylexp = yylexemes + yyerrctx->lexeme; 1186 yychar = yylexp[-1]; 1187 yylval = yylvp[-1]; 1188 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1189 yylloc = yylpp[-1]; 1190 #endif 1191 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1192 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1193 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1194 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1195 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1196 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1197 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1198 #endif 1199 yystate = yyerrctx->state; 1200 yyFreeState(yyerrctx); 1201 yyerrctx = NULL; 1202 } 1203 yynewerrflag = 1; 1204 } 1205 if (yynewerrflag == 0) goto yyinrecovery; 1206 #endif /* YYBTYACC */ 1207 1208 YYERROR_CALL("syntax error"); 1209 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1210 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */ 1211 #endif 1212 1213 #if !YYBTYACC 1214 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1215 yyerrlab: 1216 #endif 1217 ++yynerrs; 1218 1219 yyinrecovery: 1220 if (yyerrflag < 3) 1221 { 1222 yyerrflag = 3; 1223 for (;;) 1224 { 1225 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1226 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1227 { 1228 #if YYDEBUG 1229 if (yydebug) 1230 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1231 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1232 #endif 1233 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1234 yystate = yytable[yyn]; 1235 *++yystack.s_mark = yytable[yyn]; 1236 *++yystack.l_mark = yylval; 1237 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1238 /* lookahead position is error end position */ 1239 yyerror_loc_range[2] = yylloc; 1240 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1241 *++yystack.p_mark = yyloc; 1242 #endif 1243 goto yyloop; 1244 } 1245 else 1246 { 1247 #if YYDEBUG 1248 if (yydebug) 1249 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1250 YYDEBUGSTR, yydepth, *yystack.s_mark); 1251 #endif 1252 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1253 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1254 /* the current TOS position is the error start position */ 1255 yyerror_loc_range[1] = *yystack.p_mark; 1256 #endif 1257 #if defined(YYDESTRUCT_CALL) 1258 #if YYBTYACC 1259 if (!yytrial) 1260 #endif /* YYBTYACC */ 1261 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1262 YYDESTRUCT_CALL("error: discarding state", 1263 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1264 #else 1265 YYDESTRUCT_CALL("error: discarding state", 1266 yystos[*yystack.s_mark], yystack.l_mark); 1267 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1268 #endif /* defined(YYDESTRUCT_CALL) */ 1269 --yystack.s_mark; 1270 --yystack.l_mark; 1271 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1272 --yystack.p_mark; 1273 #endif 1274 } 1275 } 1276 } 1277 else 1278 { 1279 if (yychar == YYEOF) goto yyabort; 1280 #if YYDEBUG 1281 if (yydebug) 1282 { 1283 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1284 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1285 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1286 } 1287 #endif 1288 #if defined(YYDESTRUCT_CALL) 1289 #if YYBTYACC 1290 if (!yytrial) 1291 #endif /* YYBTYACC */ 1292 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1293 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1294 #else 1295 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1296 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1297 #endif /* defined(YYDESTRUCT_CALL) */ 1298 yychar = YYEMPTY; 1299 goto yyloop; 1300 } 1301 1302 yyreduce: 1303 yym = yylen[yyn]; 1304 #if YYDEBUG 1305 if (yydebug) 1306 { 1307 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1308 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1309 #ifdef YYSTYPE_TOSTRING 1310 #if YYBTYACC 1311 if (!yytrial) 1312 #endif /* YYBTYACC */ 1313 if (yym > 0) 1314 { 1315 int i; 1316 fputc('<', stderr); 1317 for (i = yym; i > 0; i--) 1318 { 1319 if (i != yym) fputs(", ", stderr); 1320 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1321 yystack.l_mark[1-i]), stderr); 1322 } 1323 fputc('>', stderr); 1324 } 1325 #endif 1326 fputc('\n', stderr); 1327 } 1328 #endif 1329 if (yym > 0) 1330 yyval = yystack.l_mark[1-yym]; 1331 else 1332 memset(&yyval, 0, sizeof yyval); 1333 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1334 1335 /* Perform position reduction */ 1336 memset(&yyloc, 0, sizeof(yyloc)); 1337 #if YYBTYACC 1338 if (!yytrial) 1339 #endif /* YYBTYACC */ 1340 { 1341 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym); 1342 /* just in case YYERROR is invoked within the action, save 1343 the start of the rhs as the error start position */ 1344 yyerror_loc_range[1] = yystack.p_mark[1-yym]; 1345 } 1346 #endif 1347 1348 switch (yyn) 1349 { 1350 case 2: 1351 #line 51 "btyacc_calc1.y" 1352 {YYVALID;} 1353 break; 1354 case 3: 1355 #line 52 "btyacc_calc1.y" 1356 {YYVALID;} if (!yytrial) 1357 #line 53 "btyacc_calc1.y" 1358 { 1359 yyerrok; 1360 } 1361 break; 1362 case 4: 1363 if (!yytrial) 1364 #line 59 "btyacc_calc1.y" 1365 { 1366 (void) printf("%15.8f\n", yystack.l_mark[0].dval); 1367 } 1368 break; 1369 case 5: 1370 if (!yytrial) 1371 #line 63 "btyacc_calc1.y" 1372 { 1373 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[0].vval.lo, yystack.l_mark[0].vval.hi); 1374 } 1375 break; 1376 case 6: 1377 if (!yytrial) 1378 #line 67 "btyacc_calc1.y" 1379 { 1380 dreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].dval; 1381 } 1382 break; 1383 case 7: 1384 if (!yytrial) 1385 #line 71 "btyacc_calc1.y" 1386 { 1387 vreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].vval; 1388 } 1389 break; 1390 case 9: 1391 if (!yytrial) 1392 #line 78 "btyacc_calc1.y" 1393 { 1394 yyval.dval = dreg[yystack.l_mark[0].ival]; 1395 } 1396 break; 1397 case 10: 1398 if (!yytrial) 1399 #line 82 "btyacc_calc1.y" 1400 { 1401 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval; 1402 } 1403 break; 1404 case 11: 1405 if (!yytrial) 1406 #line 86 "btyacc_calc1.y" 1407 { 1408 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval; 1409 } 1410 break; 1411 case 12: 1412 if (!yytrial) 1413 #line 90 "btyacc_calc1.y" 1414 { 1415 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval; 1416 } 1417 break; 1418 case 13: 1419 if (!yytrial) 1420 #line 94 "btyacc_calc1.y" 1421 { 1422 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval; 1423 } 1424 break; 1425 case 14: 1426 if (!yytrial) 1427 #line 98 "btyacc_calc1.y" 1428 { 1429 yyval.dval = -yystack.l_mark[0].dval; 1430 } 1431 break; 1432 case 15: 1433 if (!yytrial) 1434 #line 102 "btyacc_calc1.y" 1435 { 1436 yyval.dval = yystack.l_mark[-1].dval; 1437 } 1438 break; 1439 case 16: 1440 if (!yytrial) 1441 #line 108 "btyacc_calc1.y" 1442 { 1443 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval; 1444 } 1445 break; 1446 case 17: 1447 if (!yytrial) 1448 #line 112 "btyacc_calc1.y" 1449 { 1450 yyval.vval.lo = yystack.l_mark[-3].dval; 1451 yyval.vval.hi = yystack.l_mark[-1].dval; 1452 if ( yyval.vval.lo > yyval.vval.hi ) 1453 { 1454 (void) printf("interval out of order\n"); 1455 YYERROR; 1456 } 1457 } 1458 break; 1459 case 18: 1460 if (!yytrial) 1461 #line 122 "btyacc_calc1.y" 1462 { 1463 yyval.vval = vreg[yystack.l_mark[0].ival]; 1464 } 1465 break; 1466 case 19: 1467 if (!yytrial) 1468 #line 126 "btyacc_calc1.y" 1469 { 1470 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi; 1471 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo; 1472 } 1473 break; 1474 case 20: 1475 if (!yytrial) 1476 #line 131 "btyacc_calc1.y" 1477 { 1478 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi; 1479 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo; 1480 } 1481 break; 1482 case 21: 1483 if (!yytrial) 1484 #line 136 "btyacc_calc1.y" 1485 { 1486 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo; 1487 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi; 1488 } 1489 break; 1490 case 22: 1491 if (!yytrial) 1492 #line 141 "btyacc_calc1.y" 1493 { 1494 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo; 1495 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi; 1496 } 1497 break; 1498 case 23: 1499 if (!yytrial) 1500 #line 146 "btyacc_calc1.y" 1501 { 1502 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval ); 1503 } 1504 break; 1505 case 24: 1506 if (!yytrial) 1507 #line 150 "btyacc_calc1.y" 1508 { 1509 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval ); 1510 } 1511 break; 1512 case 25: 1513 if (!yytrial) 1514 #line 154 "btyacc_calc1.y" 1515 { 1516 if (dcheck(yystack.l_mark[0].vval)) YYERROR; 1517 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval ); 1518 } 1519 break; 1520 case 26: 1521 if (!yytrial) 1522 #line 159 "btyacc_calc1.y" 1523 { 1524 if (dcheck ( yystack.l_mark[0].vval )) YYERROR; 1525 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval ); 1526 } 1527 break; 1528 case 27: 1529 if (!yytrial) 1530 #line 164 "btyacc_calc1.y" 1531 { 1532 yyval.vval.hi = -yystack.l_mark[0].vval.lo; 1533 yyval.vval.lo = -yystack.l_mark[0].vval.hi; 1534 } 1535 break; 1536 case 28: 1537 if (!yytrial) 1538 #line 169 "btyacc_calc1.y" 1539 { 1540 yyval.vval = yystack.l_mark[-1].vval; 1541 } 1542 break; 1543 #line 1544 "btyacc_calc1.tab.c" 1544 default: 1545 break; 1546 } 1547 yystack.s_mark -= yym; 1548 yystate = *yystack.s_mark; 1549 yystack.l_mark -= yym; 1550 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1551 yystack.p_mark -= yym; 1552 #endif 1553 yym = yylhs[yyn]; 1554 if (yystate == 0 && yym == 0) 1555 { 1556 #if YYDEBUG 1557 if (yydebug) 1558 { 1559 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1560 #ifdef YYSTYPE_TOSTRING 1561 #if YYBTYACC 1562 if (!yytrial) 1563 #endif /* YYBTYACC */ 1564 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1565 #endif 1566 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1567 } 1568 #endif 1569 yystate = YYFINAL; 1570 *++yystack.s_mark = YYFINAL; 1571 *++yystack.l_mark = yyval; 1572 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1573 *++yystack.p_mark = yyloc; 1574 #endif 1575 if (yychar < 0) 1576 { 1577 #if YYBTYACC 1578 do { 1579 if (yylvp < yylve) 1580 { 1581 /* we're currently re-reading tokens */ 1582 yylval = *yylvp++; 1583 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1584 yylloc = *yylpp++; 1585 #endif 1586 yychar = *yylexp++; 1587 break; 1588 } 1589 if (yyps->save) 1590 { 1591 /* in trial mode; save scanner results for future parse attempts */ 1592 if (yylvp == yylvlim) 1593 { /* Enlarge lexical value queue */ 1594 size_t p = (size_t) (yylvp - yylvals); 1595 size_t s = (size_t) (yylvlim - yylvals); 1596 1597 s += YYLVQUEUEGROWTH; 1598 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1599 goto yyenomem; 1600 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1601 goto yyenomem; 1602 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1603 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1604 goto yyenomem; 1605 #endif 1606 yylvp = yylve = yylvals + p; 1607 yylvlim = yylvals + s; 1608 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1609 yylpp = yylpe = yylpsns + p; 1610 yylplim = yylpsns + s; 1611 #endif 1612 yylexp = yylexemes + p; 1613 } 1614 *yylexp = (YYINT) YYLEX; 1615 *yylvp++ = yylval; 1616 yylve++; 1617 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1618 *yylpp++ = yylloc; 1619 yylpe++; 1620 #endif 1621 yychar = *yylexp++; 1622 break; 1623 } 1624 /* normal operation, no conflict encountered */ 1625 #endif /* YYBTYACC */ 1626 yychar = YYLEX; 1627 #if YYBTYACC 1628 } while (0); 1629 #endif /* YYBTYACC */ 1630 if (yychar < 0) yychar = YYEOF; 1631 #if YYDEBUG 1632 if (yydebug) 1633 { 1634 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1635 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1636 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1637 } 1638 #endif 1639 } 1640 if (yychar == YYEOF) goto yyaccept; 1641 goto yyloop; 1642 } 1643 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1644 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1645 yystate = yytable[yyn]; 1646 else 1647 yystate = yydgoto[yym]; 1648 #if YYDEBUG 1649 if (yydebug) 1650 { 1651 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1652 #ifdef YYSTYPE_TOSTRING 1653 #if YYBTYACC 1654 if (!yytrial) 1655 #endif /* YYBTYACC */ 1656 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1657 #endif 1658 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1659 } 1660 #endif 1661 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1662 *++yystack.s_mark = (YYINT) yystate; 1663 *++yystack.l_mark = yyval; 1664 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1665 *++yystack.p_mark = yyloc; 1666 #endif 1667 goto yyloop; 1668 #if YYBTYACC 1669 1670 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1671 yyvalid: 1672 if (yypath) YYABORT; 1673 while (yyps->save) 1674 { 1675 YYParseState *save = yyps->save; 1676 yyps->save = save->save; 1677 save->save = yypath; 1678 yypath = save; 1679 } 1680 #if YYDEBUG 1681 if (yydebug) 1682 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1683 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1684 #endif 1685 if (yyerrctx) 1686 { 1687 yyFreeState(yyerrctx); 1688 yyerrctx = NULL; 1689 } 1690 yylvp = yylvals + yypath->lexeme; 1691 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1692 yylpp = yylpsns + yypath->lexeme; 1693 #endif 1694 yylexp = yylexemes + yypath->lexeme; 1695 yychar = YYEMPTY; 1696 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1697 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1698 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1699 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1700 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1701 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1702 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1703 #endif 1704 yystate = yypath->state; 1705 goto yyloop; 1706 #endif /* YYBTYACC */ 1707 1708 yyoverflow: 1709 YYERROR_CALL("yacc stack overflow"); 1710 #if YYBTYACC 1711 goto yyabort_nomem; 1712 yyenomem: 1713 YYERROR_CALL("memory exhausted"); 1714 yyabort_nomem: 1715 #endif /* YYBTYACC */ 1716 yyresult = 2; 1717 goto yyreturn; 1718 1719 yyabort: 1720 yyresult = 1; 1721 goto yyreturn; 1722 1723 yyaccept: 1724 #if YYBTYACC 1725 if (yyps->save) goto yyvalid; 1726 #endif /* YYBTYACC */ 1727 yyresult = 0; 1728 1729 yyreturn: 1730 #if defined(YYDESTRUCT_CALL) 1731 if (yychar != YYEOF && yychar != YYEMPTY) 1732 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1733 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1734 #else 1735 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1736 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1737 1738 { 1739 YYSTYPE *pv; 1740 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1741 YYLTYPE *pp; 1742 1743 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1744 YYDESTRUCT_CALL("cleanup: discarding state", 1745 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1746 #else 1747 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1748 YYDESTRUCT_CALL("cleanup: discarding state", 1749 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1750 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1751 } 1752 #endif /* defined(YYDESTRUCT_CALL) */ 1753 1754 #if YYBTYACC 1755 if (yyerrctx) 1756 { 1757 yyFreeState(yyerrctx); 1758 yyerrctx = NULL; 1759 } 1760 while (yyps) 1761 { 1762 YYParseState *save = yyps; 1763 yyps = save->save; 1764 save->save = NULL; 1765 yyFreeState(save); 1766 } 1767 while (yypath) 1768 { 1769 YYParseState *save = yypath; 1770 yypath = save->save; 1771 save->save = NULL; 1772 yyFreeState(save); 1773 } 1774 #endif /* YYBTYACC */ 1775 yyfreestack(&yystack); 1776 return (yyresult); 1777 } 1778