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