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