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