1264790Sbapt/* original parser id follows */ 2264790Sbapt/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3264790Sbapt/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 4264790Sbapt 5264790Sbapt#define YYBYACC 1 6264790Sbapt#define YYMAJOR 1 7264790Sbapt#define YYMINOR 9 8264790Sbapt#define YYCHECK "yyyymmdd" 9264790Sbapt 10264790Sbapt#define YYEMPTY (-1) 11264790Sbapt#define yyclearin (yychar = YYEMPTY) 12264790Sbapt#define yyerrok (yyerrflag = 0) 13264790Sbapt#define YYRECOVERING() (yyerrflag != 0) 14264790Sbapt#define YYENOMEM (-2) 15264790Sbapt#define YYEOF 0 16264790Sbapt#undef YYBTYACC 17264790Sbapt#define YYBTYACC 1 18264790Sbapt#define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug") 19264790Sbapt 20264790Sbapt#ifndef yyparse 21264790Sbapt#define yyparse calc1_parse 22264790Sbapt#endif /* yyparse */ 23264790Sbapt 24264790Sbapt#ifndef yylex 25264790Sbapt#define yylex calc1_lex 26264790Sbapt#endif /* yylex */ 27264790Sbapt 28264790Sbapt#ifndef yyerror 29264790Sbapt#define yyerror calc1_error 30264790Sbapt#endif /* yyerror */ 31264790Sbapt 32264790Sbapt#ifndef yychar 33264790Sbapt#define yychar calc1_char 34264790Sbapt#endif /* yychar */ 35264790Sbapt 36264790Sbapt#ifndef yyval 37264790Sbapt#define yyval calc1_val 38264790Sbapt#endif /* yyval */ 39264790Sbapt 40264790Sbapt#ifndef yylval 41264790Sbapt#define yylval calc1_lval 42264790Sbapt#endif /* yylval */ 43264790Sbapt 44264790Sbapt#ifndef yydebug 45264790Sbapt#define yydebug calc1_debug 46264790Sbapt#endif /* yydebug */ 47264790Sbapt 48264790Sbapt#ifndef yynerrs 49264790Sbapt#define yynerrs calc1_nerrs 50264790Sbapt#endif /* yynerrs */ 51264790Sbapt 52264790Sbapt#ifndef yyerrflag 53264790Sbapt#define yyerrflag calc1_errflag 54264790Sbapt#endif /* yyerrflag */ 55264790Sbapt 56264790Sbapt#ifndef yylhs 57264790Sbapt#define yylhs calc1_lhs 58264790Sbapt#endif /* yylhs */ 59264790Sbapt 60264790Sbapt#ifndef yylen 61264790Sbapt#define yylen calc1_len 62264790Sbapt#endif /* yylen */ 63264790Sbapt 64264790Sbapt#ifndef yydefred 65264790Sbapt#define yydefred calc1_defred 66264790Sbapt#endif /* yydefred */ 67264790Sbapt 68264790Sbapt#ifndef yystos 69264790Sbapt#define yystos calc1_stos 70264790Sbapt#endif /* yystos */ 71264790Sbapt 72264790Sbapt#ifndef yydgoto 73264790Sbapt#define yydgoto calc1_dgoto 74264790Sbapt#endif /* yydgoto */ 75264790Sbapt 76264790Sbapt#ifndef yysindex 77264790Sbapt#define yysindex calc1_sindex 78264790Sbapt#endif /* yysindex */ 79264790Sbapt 80264790Sbapt#ifndef yyrindex 81264790Sbapt#define yyrindex calc1_rindex 82264790Sbapt#endif /* yyrindex */ 83264790Sbapt 84264790Sbapt#ifndef yygindex 85264790Sbapt#define yygindex calc1_gindex 86264790Sbapt#endif /* yygindex */ 87264790Sbapt 88264790Sbapt#ifndef yytable 89264790Sbapt#define yytable calc1_table 90264790Sbapt#endif /* yytable */ 91264790Sbapt 92264790Sbapt#ifndef yycheck 93264790Sbapt#define yycheck calc1_check 94264790Sbapt#endif /* yycheck */ 95264790Sbapt 96264790Sbapt#ifndef yyname 97264790Sbapt#define yyname calc1_name 98264790Sbapt#endif /* yyname */ 99264790Sbapt 100264790Sbapt#ifndef yyrule 101264790Sbapt#define yyrule calc1_rule 102264790Sbapt#endif /* yyrule */ 103264790Sbapt 104264790Sbapt#if YYBTYACC 105264790Sbapt 106264790Sbapt#ifndef yycindex 107264790Sbapt#define yycindex calc1_cindex 108264790Sbapt#endif /* yycindex */ 109264790Sbapt 110264790Sbapt#ifndef yyctable 111264790Sbapt#define yyctable calc1_ctable 112264790Sbapt#endif /* yyctable */ 113264790Sbapt 114264790Sbapt#endif /* YYBTYACC */ 115264790Sbapt 116264790Sbapt#define YYPREFIX "calc1_" 117264790Sbapt 118264790Sbapt#define YYPURE 1 119264790Sbapt 120264790Sbapt#line 3 "btyacc_calc1.y" 121264790Sbapt 122264790Sbapt/* http://dinosaur.compilertools.net/yacc/index.html */ 123264790Sbapt 124264790Sbapt#include <stdlib.h> 125264790Sbapt#include <stdio.h> 126264790Sbapt#include <ctype.h> 127264790Sbapt#include <math.h> 128264790Sbapt 129264790Sbapttypedef struct interval 130264790Sbapt{ 131264790Sbapt double lo, hi; 132264790Sbapt} 133264790SbaptINTERVAL; 134264790Sbapt 135264790SbaptINTERVAL vmul(double, double, INTERVAL); 136264790SbaptINTERVAL vdiv(double, double, INTERVAL); 137264790Sbapt 138264790Sbaptint dcheck(INTERVAL); 139264790Sbapt 140264790Sbaptdouble dreg[26]; 141264790SbaptINTERVAL vreg[26]; 142264790Sbapt 143264790Sbapt#line 29 "btyacc_calc1.y" 144264790Sbapt#ifdef YYSTYPE 145264790Sbapt#undef YYSTYPE_IS_DECLARED 146264790Sbapt#define YYSTYPE_IS_DECLARED 1 147264790Sbapt#endif 148264790Sbapt#ifndef YYSTYPE_IS_DECLARED 149264790Sbapt#define YYSTYPE_IS_DECLARED 1 150264790Sbapttypedef union 151264790Sbapt{ 152264790Sbapt int ival; 153264790Sbapt double dval; 154264790Sbapt INTERVAL vval; 155264790Sbapt} YYSTYPE; 156264790Sbapt#endif /* !YYSTYPE_IS_DECLARED */ 157264790Sbapt#line 158 "btyacc_calc1.tab.c" 158264790Sbapt 159264790Sbapt/* compatibility with bison */ 160264790Sbapt#ifdef YYPARSE_PARAM 161264790Sbapt/* compatibility with FreeBSD */ 162264790Sbapt# ifdef YYPARSE_PARAM_TYPE 163264790Sbapt# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 164264790Sbapt# else 165264790Sbapt# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 166264790Sbapt# endif 167264790Sbapt#else 168264790Sbapt# define YYPARSE_DECL() yyparse(void) 169264790Sbapt#endif 170264790Sbapt 171264790Sbapt/* Parameters sent to lex. */ 172264790Sbapt#ifdef YYLEX_PARAM 173264790Sbapt# ifdef YYLEX_PARAM_TYPE 174264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM) 175264790Sbapt# else 176264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM) 177264790Sbapt# endif 178264790Sbapt# define YYLEX yylex(&yylval, YYLEX_PARAM) 179264790Sbapt#else 180264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval) 181264790Sbapt# define YYLEX yylex(&yylval) 182264790Sbapt#endif 183264790Sbapt 184264790Sbapt/* Parameters sent to yyerror. */ 185264790Sbapt#ifndef YYERROR_DECL 186264790Sbapt#define YYERROR_DECL() yyerror(const char *s) 187264790Sbapt#endif 188264790Sbapt#ifndef YYERROR_CALL 189264790Sbapt#define YYERROR_CALL(msg) yyerror(msg) 190264790Sbapt#endif 191264790Sbapt 192264790Sbaptextern int YYPARSE_DECL(); 193264790Sbapt 194264790Sbapt#define DREG 257 195264790Sbapt#define VREG 258 196264790Sbapt#define CONST 259 197264790Sbapt#define UMINUS 260 198264790Sbapt#define YYERRCODE 256 199264790Sbapttypedef short YYINT; 200264790Sbaptstatic const YYINT calc1_lhs[] = { -1, 201264790Sbapt 0, 0, 0, 3, 3, 3, 3, 1, 1, 1, 202264790Sbapt 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 203264790Sbapt 2, 2, 2, 2, 2, 2, 2, 2, 204264790Sbapt}; 205264790Sbaptstatic const YYINT calc1_len[] = { 2, 206264790Sbapt 0, 3, 3, 1, 1, 3, 3, 1, 1, 3, 207264790Sbapt 3, 3, 3, 2, 3, 1, 5, 1, 3, 3, 208264790Sbapt 3, 3, 3, 3, 3, 3, 2, 3, 209264790Sbapt}; 210264790Sbaptstatic const YYINT calc1_defred[] = { 1, 211264790Sbapt 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 212264790Sbapt 3, 0, 0, 9, 18, 0, 27, 0, 0, 0, 213264790Sbapt 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 214264790Sbapt 0, 0, 0, 15, 0, 28, 0, 0, 0, 0, 215264790Sbapt 0, 24, 0, 26, 0, 0, 23, 25, 14, 0, 216264790Sbapt 0, 0, 0, 0, 0, 0, 0, 12, 13, 17, 217264790Sbapt}; 218264790Sbaptstatic const YYINT calc1_stos[] = { 0, 219264790Sbapt 262, 256, 257, 258, 259, 45, 40, 263, 264, 265, 220264790Sbapt 10, 61, 61, 257, 258, 263, 264, 263, 264, 43, 221264790Sbapt 45, 42, 47, 43, 45, 42, 47, 10, 45, 40, 222264790Sbapt 263, 263, 264, 41, 44, 41, 263, 264, 263, 264, 223264790Sbapt 263, 264, 263, 264, 264, 264, 264, 264, 263, 263, 224264790Sbapt 43, 45, 42, 47, 263, 263, 263, 263, 263, 41, 225264790Sbapt}; 226264790Sbaptstatic const YYINT calc1_dgoto[] = { 1, 227264790Sbapt 32, 9, 10, 228264790Sbapt}; 229264790Sbaptstatic const YYINT calc1_sindex[] = { 0, 230264790Sbapt -40, -9, -59, -54, 0, -37, -37, 0, 82, 4, 231264790Sbapt 0, -34, -37, 0, 0, 0, 0, -31, -25, -37, 232264790Sbapt -37, -37, -37, -37, -37, -37, -37, 0, -34, -34, 233264790Sbapt 132, 0, 82, 0, -34, 0, 0, -12, 0, -12, 234264790Sbapt 0, 0, 0, 0, -12, -12, 0, 0, 0, 112, 235264790Sbapt -34, -34, -34, -34, 119, -11, -11, 0, 0, 0, 236264790Sbapt}; 237264790Sbaptstatic const YYINT calc1_rindex[] = { 0, 238264790Sbapt 0, 0, 51, 58, 0, 0, 0, 0, 11, 0, 239264790Sbapt 0, 0, 0, 0, 0, -16, 0, 0, 0, 0, 240264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241264790Sbapt 19, 9, 27, 0, 0, 0, -5, 41, -4, 77, 242264790Sbapt -2, 0, 8, 0, 78, 85, 0, 0, 0, 0, 243264790Sbapt 0, 0, 0, 0, 0, 92, 99, 0, 0, 0, 244264790Sbapt}; 245264790Sbapt#if YYBTYACC 246264790Sbaptstatic const YYINT calc1_cindex[] = { 0, 247264790Sbapt 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 248264790Sbapt 0, 0, 0, 0, 0, 2, 0, 126, 0, 0, 249264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 250264790Sbapt 0, 138, 0, 0, 0, 0, 17, 0, 24, 0, 251264790Sbapt 31, 0, 38, 0, 0, 0, 0, 0, 0, 0, 252264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253264790Sbapt}; 254264790Sbapt#endif 255264790Sbaptstatic const YYINT calc1_gindex[] = { 0, 256264790Sbapt 3, 125, 0, 257264790Sbapt}; 258264790Sbapt#define YYTABLESIZE 225 259264790Sbaptstatic const YYINT calc1_table[] = { 7, 260264790Sbapt 11, 12, 7, 8, 6, 30, 13, 6, 16, 18, 261264790Sbapt 29, 14, 35, 28, 31, 36, 26, 24, 16, 25, 262264790Sbapt 5, 27, 37, 39, 41, 43, 20, 14, 6, 26, 263264790Sbapt 53, 49, 50, 23, 27, 54, 7, 55, 10, 11, 264264790Sbapt 26, 12, 14, 14, 14, 0, 14, 29, 14, 16, 265264790Sbapt 20, 13, 0, 56, 57, 58, 59, 20, 6, 20, 266264790Sbapt 9, 20, 0, 9, 23, 6, 23, 18, 23, 0, 267264790Sbapt 9, 26, 26, 26, 11, 26, 0, 26, 29, 29, 268264790Sbapt 29, 20, 29, 20, 29, 20, 22, 19, 0, 0, 269264790Sbapt 0, 0, 9, 9, 21, 9, 0, 9, 0, 18, 270264790Sbapt 18, 10, 18, 0, 18, 0, 6, 0, 11, 3, 271264790Sbapt 0, 9, 0, 0, 0, 0, 0, 22, 19, 22, 272264790Sbapt 19, 22, 19, 26, 24, 21, 25, 21, 27, 21, 273264790Sbapt 17, 19, 10, 0, 10, 0, 10, 33, 0, 11, 274264790Sbapt 0, 11, 0, 11, 38, 40, 42, 44, 45, 46, 275264790Sbapt 47, 48, 34, 53, 51, 0, 52, 0, 54, 60, 276264790Sbapt 53, 51, 0, 52, 0, 54, 18, 6, 0, 0, 277264790Sbapt 3, 0, 9, 53, 51, 0, 52, 0, 54, 6, 278264790Sbapt 0, 0, 3, 0, 9, 0, 0, 0, 0, 0, 279264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 280264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 281264790Sbapt 0, 0, 0, 0, 0, 2, 3, 4, 5, 14, 282264790Sbapt 15, 5, 14, 0, 5, 283264790Sbapt}; 284264790Sbaptstatic const YYINT calc1_check[] = { 40, 285264790Sbapt 10, 61, 40, 1, 45, 40, 61, 45, 6, 7, 286264790Sbapt 45, 10, 44, 10, 12, 41, 42, 43, 10, 45, 287264790Sbapt 10, 47, 20, 21, 22, 23, 10, 44, 10, 42, 288264790Sbapt 42, 29, 30, 10, 47, 47, 10, 35, 44, 44, 289264790Sbapt 10, 44, 41, 42, 43, -1, 45, 10, 47, 41, 290264790Sbapt 10, 44, -1, 51, 52, 53, 54, 41, 42, 43, 291264790Sbapt 10, 45, -1, 47, 41, 42, 43, 10, 45, -1, 292264790Sbapt 47, 41, 42, 43, 10, 45, -1, 47, 41, 42, 293264790Sbapt 43, 41, 45, 43, 47, 45, 10, 10, -1, -1, 294264790Sbapt -1, -1, 42, 43, 10, 45, -1, 47, -1, 42, 295264790Sbapt 43, 10, 45, -1, 47, -1, 42, 43, 10, 45, 296264790Sbapt -1, 47, -1, -1, -1, -1, -1, 41, 41, 43, 297264790Sbapt 43, 45, 45, 42, 43, 41, 45, 43, 47, 45, 298264790Sbapt 6, 7, 41, -1, 43, -1, 45, 13, -1, 41, 299264790Sbapt -1, 43, -1, 45, 20, 21, 22, 23, 24, 25, 300264790Sbapt 26, 27, 41, 42, 43, -1, 45, -1, 47, 41, 301264790Sbapt 42, 43, -1, 45, -1, 47, 41, 42, 43, -1, 302264790Sbapt 45, -1, 47, 42, 43, -1, 45, -1, 47, 42, 303264790Sbapt 43, -1, 45, -1, 47, -1, -1, -1, -1, -1, 304264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 305264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 306264790Sbapt -1, -1, -1, -1, -1, 256, 257, 258, 259, 257, 307264790Sbapt 258, 259, 257, -1, 259, 308264790Sbapt}; 309264790Sbapt#if YYBTYACC 310264790Sbaptstatic const YYINT calc1_ctable[] = { 20, 311264790Sbapt 16, -1, 21, 16, -1, 22, 16, -1, 23, 16, 312264790Sbapt -1, 4, 16, -1, 14, 16, -1, 34, 16, -1, 313264790Sbapt 10, 16, -1, 11, 16, -1, 12, 16, -1, 13, 314264790Sbapt 16, -1, 315264790Sbapt}; 316264790Sbapt#endif 317264790Sbapt#define YYFINAL 1 318264790Sbapt#ifndef YYDEBUG 319264790Sbapt#define YYDEBUG 0 320264790Sbapt#endif 321264790Sbapt#define YYMAXTOKEN 260 322264790Sbapt#define YYUNDFTOKEN 266 323264790Sbapt#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 324264790Sbapt#if YYDEBUG 325264790Sbaptstatic const char *const calc1_name[] = { 326264790Sbapt 327264790Sbapt"$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, 328264790Sbapt0,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0, 329264790Sbapt0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 330264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 331264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 332264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 333264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 334264790Sbapt"error","DREG","VREG","CONST","UMINUS","$accept","lines","dexp","vexp","line", 335264790Sbapt"illegal-symbol", 336264790Sbapt}; 337264790Sbaptstatic const char *const calc1_rule[] = { 338264790Sbapt"$accept : lines", 339264790Sbapt"lines :", 340264790Sbapt"lines : lines line '\\n'", 341264790Sbapt"lines : lines error '\\n'", 342264790Sbapt"line : dexp", 343264790Sbapt"line : vexp", 344264790Sbapt"line : DREG '=' dexp", 345264790Sbapt"line : VREG '=' vexp", 346264790Sbapt"dexp : CONST", 347264790Sbapt"dexp : DREG", 348264790Sbapt"dexp : dexp '+' dexp", 349264790Sbapt"dexp : dexp '-' dexp", 350264790Sbapt"dexp : dexp '*' dexp", 351264790Sbapt"dexp : dexp '/' dexp", 352264790Sbapt"dexp : '-' dexp", 353264790Sbapt"dexp : '(' dexp ')'", 354264790Sbapt"vexp : dexp", 355264790Sbapt"vexp : '(' dexp ',' dexp ')'", 356264790Sbapt"vexp : VREG", 357264790Sbapt"vexp : vexp '+' vexp", 358264790Sbapt"vexp : dexp '+' vexp", 359264790Sbapt"vexp : vexp '-' vexp", 360264790Sbapt"vexp : dexp '-' vexp", 361264790Sbapt"vexp : vexp '*' vexp", 362264790Sbapt"vexp : dexp '*' vexp", 363264790Sbapt"vexp : vexp '/' vexp", 364264790Sbapt"vexp : dexp '/' vexp", 365264790Sbapt"vexp : '-' vexp", 366264790Sbapt"vexp : '(' vexp ')'", 367264790Sbapt 368264790Sbapt}; 369264790Sbapt#endif 370264790Sbapt 371264790Sbaptint yydebug; 372264790Sbaptint yynerrs; 373264790Sbapt 374264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 375264790Sbapt#ifndef YYLLOC_DEFAULT 376264790Sbapt#define YYLLOC_DEFAULT(loc, rhs, n) \ 377264790Sbaptdo \ 378264790Sbapt{ \ 379264790Sbapt if (n == 0) \ 380264790Sbapt { \ 381264790Sbapt (loc).first_line = ((rhs)[-1]).last_line; \ 382264790Sbapt (loc).first_column = ((rhs)[-1]).last_column; \ 383264790Sbapt (loc).last_line = ((rhs)[-1]).last_line; \ 384264790Sbapt (loc).last_column = ((rhs)[-1]).last_column; \ 385264790Sbapt } \ 386264790Sbapt else \ 387264790Sbapt { \ 388264790Sbapt (loc).first_line = ((rhs)[ 0 ]).first_line; \ 389264790Sbapt (loc).first_column = ((rhs)[ 0 ]).first_column; \ 390264790Sbapt (loc).last_line = ((rhs)[n-1]).last_line; \ 391264790Sbapt (loc).last_column = ((rhs)[n-1]).last_column; \ 392264790Sbapt } \ 393264790Sbapt} while (0) 394264790Sbapt#endif /* YYLLOC_DEFAULT */ 395264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 396264790Sbapt#if YYBTYACC 397264790Sbapt 398264790Sbapt#ifndef YYLVQUEUEGROWTH 399264790Sbapt#define YYLVQUEUEGROWTH 32 400264790Sbapt#endif 401264790Sbapt#endif /* YYBTYACC */ 402264790Sbapt 403264790Sbapt/* define the initial stack-sizes */ 404264790Sbapt#ifdef YYSTACKSIZE 405264790Sbapt#undef YYMAXDEPTH 406264790Sbapt#define YYMAXDEPTH YYSTACKSIZE 407264790Sbapt#else 408264790Sbapt#ifdef YYMAXDEPTH 409264790Sbapt#define YYSTACKSIZE YYMAXDEPTH 410264790Sbapt#else 411264790Sbapt#define YYSTACKSIZE 10000 412264790Sbapt#define YYMAXDEPTH 10000 413264790Sbapt#endif 414264790Sbapt#endif 415264790Sbapt 416264790Sbapt#ifndef YYINITSTACKSIZE 417264790Sbapt#define YYINITSTACKSIZE 200 418264790Sbapt#endif 419264790Sbapt 420264790Sbapttypedef struct { 421264790Sbapt unsigned stacksize; 422264790Sbapt short *s_base; 423264790Sbapt short *s_mark; 424264790Sbapt short *s_last; 425264790Sbapt YYSTYPE *l_base; 426264790Sbapt YYSTYPE *l_mark; 427264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 428264790Sbapt YYLTYPE *p_base; 429264790Sbapt YYLTYPE *p_mark; 430264790Sbapt#endif 431264790Sbapt} YYSTACKDATA; 432264790Sbapt#if YYBTYACC 433264790Sbapt 434264790Sbaptstruct YYParseState_s 435264790Sbapt{ 436264790Sbapt struct YYParseState_s *save; /* Previously saved parser state */ 437264790Sbapt YYSTACKDATA yystack; /* saved parser stack */ 438264790Sbapt int state; /* saved parser state */ 439264790Sbapt int errflag; /* saved error recovery status */ 440264790Sbapt int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 441264790Sbapt YYINT ctry; /* saved index in yyctable[] for this conflict */ 442264790Sbapt}; 443264790Sbapttypedef struct YYParseState_s YYParseState; 444264790Sbapt#endif /* YYBTYACC */ 445264790Sbapt#line 174 "btyacc_calc1.y" 446264790Sbapt /* beginning of subroutines section */ 447264790Sbapt 448264790Sbaptint 449264790Sbaptmain (void) 450264790Sbapt{ 451264790Sbapt while(!feof(stdin)) { 452264790Sbapt yyparse(); 453264790Sbapt } 454264790Sbapt return 0; 455264790Sbapt} 456264790Sbapt 457264790Sbapt#define BSZ 50 /* buffer size for floating point numbers */ 458264790Sbapt 459264790Sbaptstatic void 460264790SbaptYYERROR_DECL() 461264790Sbapt{ 462264790Sbapt fprintf(stderr, "%s\n", s); 463264790Sbapt} 464264790Sbapt 465264790Sbapt /* lexical analysis */ 466264790Sbapt 467264790Sbaptstatic int 468264790SbaptYYLEX_DECL() 469264790Sbapt{ 470264790Sbapt int c; 471264790Sbapt 472264790Sbapt while ((c = getchar()) == ' ') 473264790Sbapt { /* skip over blanks */ 474264790Sbapt } 475264790Sbapt 476264790Sbapt if (isupper(c)) 477264790Sbapt { 478264790Sbapt#if YYPURE 479264790Sbapt (*yylval).ival = c - 'A'; 480264790Sbapt#else 481264790Sbapt yylval.ival = c - 'A'; 482264790Sbapt#endif 483264790Sbapt return (VREG); 484264790Sbapt } 485264790Sbapt if (islower(c)) 486264790Sbapt { 487264790Sbapt#if YYPURE 488264790Sbapt (*yylval).ival = c - 'a'; 489264790Sbapt#else 490264790Sbapt yylval.ival = c - 'a'; 491264790Sbapt#endif 492264790Sbapt return (DREG); 493264790Sbapt } 494264790Sbapt 495264790Sbapt if (isdigit(c) || c == '.') 496264790Sbapt { 497264790Sbapt /* gobble up digits, points, exponents */ 498264790Sbapt char buf[BSZ + 1], *cp = buf; 499264790Sbapt int dot = 0, expr = 0; 500264790Sbapt 501264790Sbapt for (; (cp - buf) < BSZ; ++cp, c = getchar()) 502264790Sbapt { 503264790Sbapt 504264790Sbapt *cp = (char) c; 505264790Sbapt if (isdigit(c)) 506264790Sbapt continue; 507264790Sbapt if (c == '.') 508264790Sbapt { 509264790Sbapt if (dot++ || expr) 510264790Sbapt return ('.'); /* will cause syntax error */ 511264790Sbapt continue; 512264790Sbapt } 513264790Sbapt 514264790Sbapt if (c == 'e') 515264790Sbapt { 516264790Sbapt if (expr++) 517264790Sbapt return ('e'); /* will cause syntax error */ 518264790Sbapt continue; 519264790Sbapt } 520264790Sbapt 521264790Sbapt /* end of number */ 522264790Sbapt break; 523264790Sbapt } 524264790Sbapt *cp = '\0'; 525264790Sbapt 526264790Sbapt if ((cp - buf) >= BSZ) 527264790Sbapt printf("constant too long: truncated\n"); 528264790Sbapt else 529264790Sbapt ungetc(c, stdin); /* push back last char read */ 530264790Sbapt#if YYPURE 531264790Sbapt (*yylval).dval = atof(buf); 532264790Sbapt#else 533264790Sbapt yylval.dval = atof(buf); 534264790Sbapt#endif 535264790Sbapt return (CONST); 536264790Sbapt } 537264790Sbapt return (c); 538264790Sbapt} 539264790Sbapt 540264790Sbaptstatic INTERVAL 541264790Sbapthilo(double a, double b, double c, double d) 542264790Sbapt{ 543264790Sbapt /* returns the smallest interval containing a, b, c, and d */ 544264790Sbapt /* used by *, / routines */ 545264790Sbapt INTERVAL v; 546264790Sbapt 547264790Sbapt if (a > b) 548264790Sbapt { 549264790Sbapt v.hi = a; 550264790Sbapt v.lo = b; 551264790Sbapt } 552264790Sbapt else 553264790Sbapt { 554264790Sbapt v.hi = b; 555264790Sbapt v.lo = a; 556264790Sbapt } 557264790Sbapt 558264790Sbapt if (c > d) 559264790Sbapt { 560264790Sbapt if (c > v.hi) 561264790Sbapt v.hi = c; 562264790Sbapt if (d < v.lo) 563264790Sbapt v.lo = d; 564264790Sbapt } 565264790Sbapt else 566264790Sbapt { 567264790Sbapt if (d > v.hi) 568264790Sbapt v.hi = d; 569264790Sbapt if (c < v.lo) 570264790Sbapt v.lo = c; 571264790Sbapt } 572264790Sbapt return (v); 573264790Sbapt} 574264790Sbapt 575264790SbaptINTERVAL 576264790Sbaptvmul(double a, double b, INTERVAL v) 577264790Sbapt{ 578264790Sbapt return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo)); 579264790Sbapt} 580264790Sbapt 581264790Sbaptint 582264790Sbaptdcheck(INTERVAL v) 583264790Sbapt{ 584264790Sbapt if (v.hi >= 0. && v.lo <= 0.) 585264790Sbapt { 586264790Sbapt printf("divisor interval contains 0.\n"); 587264790Sbapt return (1); 588264790Sbapt } 589264790Sbapt return (0); 590264790Sbapt} 591264790Sbapt 592264790SbaptINTERVAL 593264790Sbaptvdiv(double a, double b, INTERVAL v) 594264790Sbapt{ 595264790Sbapt return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo)); 596264790Sbapt} 597264790Sbapt#line 598 "btyacc_calc1.tab.c" 598264790Sbapt 599264790Sbapt/* For use in generated program */ 600264790Sbapt#define yydepth (int)(yystack.s_mark - yystack.s_base) 601264790Sbapt#if YYBTYACC 602264790Sbapt#define yytrial (yyps->save) 603264790Sbapt#endif /* YYBTYACC */ 604264790Sbapt 605264790Sbapt#if YYDEBUG 606264790Sbapt#include <stdio.h> /* needed for printf */ 607264790Sbapt#endif 608264790Sbapt 609264790Sbapt#include <stdlib.h> /* needed for malloc, etc */ 610264790Sbapt#include <string.h> /* needed for memset */ 611264790Sbapt 612264790Sbapt/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 613264790Sbaptstatic int yygrowstack(YYSTACKDATA *data) 614264790Sbapt{ 615264790Sbapt int i; 616264790Sbapt unsigned newsize; 617264790Sbapt short *newss; 618264790Sbapt YYSTYPE *newvs; 619264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 620264790Sbapt YYLTYPE *newps; 621264790Sbapt#endif 622264790Sbapt 623264790Sbapt if ((newsize = data->stacksize) == 0) 624264790Sbapt newsize = YYINITSTACKSIZE; 625264790Sbapt else if (newsize >= YYMAXDEPTH) 626264790Sbapt return YYENOMEM; 627264790Sbapt else if ((newsize *= 2) > YYMAXDEPTH) 628264790Sbapt newsize = YYMAXDEPTH; 629264790Sbapt 630264790Sbapt i = (int) (data->s_mark - data->s_base); 631264790Sbapt newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 632264790Sbapt if (newss == 0) 633264790Sbapt return YYENOMEM; 634264790Sbapt 635264790Sbapt data->s_base = newss; 636264790Sbapt data->s_mark = newss + i; 637264790Sbapt 638264790Sbapt newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 639264790Sbapt if (newvs == 0) 640264790Sbapt return YYENOMEM; 641264790Sbapt 642264790Sbapt data->l_base = newvs; 643264790Sbapt data->l_mark = newvs + i; 644264790Sbapt 645264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 646264790Sbapt newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 647264790Sbapt if (newps == 0) 648264790Sbapt return YYENOMEM; 649264790Sbapt 650264790Sbapt data->p_base = newps; 651264790Sbapt data->p_mark = newps + i; 652264790Sbapt#endif 653264790Sbapt 654264790Sbapt data->stacksize = newsize; 655264790Sbapt data->s_last = data->s_base + newsize - 1; 656264790Sbapt 657264790Sbapt#if YYDEBUG 658264790Sbapt if (yydebug) 659264790Sbapt fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 660264790Sbapt#endif 661264790Sbapt return 0; 662264790Sbapt} 663264790Sbapt 664264790Sbapt#if YYPURE || defined(YY_NO_LEAKS) 665264790Sbaptstatic void yyfreestack(YYSTACKDATA *data) 666264790Sbapt{ 667264790Sbapt free(data->s_base); 668264790Sbapt free(data->l_base); 669264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 670264790Sbapt free(data->p_base); 671264790Sbapt#endif 672264790Sbapt memset(data, 0, sizeof(*data)); 673264790Sbapt} 674264790Sbapt#else 675264790Sbapt#define yyfreestack(data) /* nothing */ 676264790Sbapt#endif /* YYPURE || defined(YY_NO_LEAKS) */ 677264790Sbapt#if YYBTYACC 678264790Sbapt 679264790Sbaptstatic YYParseState * 680264790SbaptyyNewState(unsigned size) 681264790Sbapt{ 682264790Sbapt YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 683264790Sbapt if (p == NULL) return NULL; 684264790Sbapt 685264790Sbapt p->yystack.stacksize = size; 686264790Sbapt if (size == 0) 687264790Sbapt { 688264790Sbapt p->yystack.s_base = NULL; 689264790Sbapt p->yystack.l_base = NULL; 690264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 691264790Sbapt p->yystack.p_base = NULL; 692264790Sbapt#endif 693264790Sbapt return p; 694264790Sbapt } 695264790Sbapt p->yystack.s_base = (short *) malloc(size * sizeof(short)); 696264790Sbapt if (p->yystack.s_base == NULL) return NULL; 697264790Sbapt p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 698264790Sbapt if (p->yystack.l_base == NULL) return NULL; 699264790Sbapt memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 700264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 701264790Sbapt p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 702264790Sbapt if (p->yystack.p_base == NULL) return NULL; 703264790Sbapt memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 704264790Sbapt#endif 705264790Sbapt 706264790Sbapt return p; 707264790Sbapt} 708264790Sbapt 709264790Sbaptstatic void 710264790SbaptyyFreeState(YYParseState *p) 711264790Sbapt{ 712264790Sbapt yyfreestack(&p->yystack); 713264790Sbapt free(p); 714264790Sbapt} 715264790Sbapt#endif /* YYBTYACC */ 716264790Sbapt 717264790Sbapt#define YYABORT goto yyabort 718264790Sbapt#define YYREJECT goto yyabort 719264790Sbapt#define YYACCEPT goto yyaccept 720264790Sbapt#define YYERROR goto yyerrlab 721264790Sbapt#if YYBTYACC 722264790Sbapt#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 723264790Sbapt#define YYVALID_NESTED do { if (yyps->save && \ 724264790Sbapt yyps->save->save == 0) goto yyvalid; } while(0) 725264790Sbapt#endif /* YYBTYACC */ 726264790Sbapt 727264790Sbaptint 728264790SbaptYYPARSE_DECL() 729264790Sbapt{ 730264790Sbapt int yyerrflag; 731264790Sbapt int yychar; 732264790Sbapt YYSTYPE yyval; 733264790Sbapt YYSTYPE yylval; 734264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 735264790Sbapt YYLTYPE yyloc; /* position returned by actions */ 736264790Sbapt YYLTYPE yylloc; /* position from the lexer */ 737264790Sbapt#endif 738264790Sbapt 739264790Sbapt /* variables for the parser stack */ 740264790Sbapt YYSTACKDATA yystack; 741264790Sbapt#if YYBTYACC 742264790Sbapt 743264790Sbapt /* Current parser state */ 744264790Sbapt static YYParseState *yyps = 0; 745264790Sbapt 746264790Sbapt /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 747264790Sbapt static YYParseState *yypath = 0; 748264790Sbapt 749264790Sbapt /* Base of the lexical value queue */ 750264790Sbapt static YYSTYPE *yylvals = 0; 751264790Sbapt 752264790Sbapt /* Current position at lexical value queue */ 753264790Sbapt static YYSTYPE *yylvp = 0; 754264790Sbapt 755264790Sbapt /* End position of lexical value queue */ 756264790Sbapt static YYSTYPE *yylve = 0; 757264790Sbapt 758264790Sbapt /* The last allocated position at the lexical value queue */ 759264790Sbapt static YYSTYPE *yylvlim = 0; 760264790Sbapt 761264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 762264790Sbapt /* Base of the lexical position queue */ 763264790Sbapt static YYLTYPE *yylpsns = 0; 764264790Sbapt 765264790Sbapt /* Current position at lexical position queue */ 766264790Sbapt static YYLTYPE *yylpp = 0; 767264790Sbapt 768264790Sbapt /* End position of lexical position queue */ 769264790Sbapt static YYLTYPE *yylpe = 0; 770264790Sbapt 771264790Sbapt /* The last allocated position at the lexical position queue */ 772264790Sbapt static YYLTYPE *yylplim = 0; 773264790Sbapt#endif 774264790Sbapt 775264790Sbapt /* Current position at lexical token queue */ 776264790Sbapt static short *yylexp = 0; 777264790Sbapt 778264790Sbapt static short *yylexemes = 0; 779264790Sbapt#endif /* YYBTYACC */ 780264790Sbapt int yym, yyn, yystate, yyresult; 781264790Sbapt#if YYBTYACC 782264790Sbapt int yynewerrflag; 783264790Sbapt YYParseState *yyerrctx = NULL; 784264790Sbapt#endif /* YYBTYACC */ 785264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 786264790Sbapt YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 787264790Sbapt#endif 788264790Sbapt#if YYDEBUG 789264790Sbapt const char *yys; 790264790Sbapt 791264790Sbapt if ((yys = getenv("YYDEBUG")) != 0) 792264790Sbapt { 793264790Sbapt yyn = *yys; 794264790Sbapt if (yyn >= '0' && yyn <= '9') 795264790Sbapt yydebug = yyn - '0'; 796264790Sbapt } 797264790Sbapt if (yydebug) 798264790Sbapt fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 799264790Sbapt#endif 800264790Sbapt 801264790Sbapt#if YYBTYACC 802264790Sbapt yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 803264790Sbapt yyps->save = 0; 804264790Sbapt#endif /* YYBTYACC */ 805264790Sbapt yynerrs = 0; 806264790Sbapt yyerrflag = 0; 807264790Sbapt yychar = YYEMPTY; 808264790Sbapt yystate = 0; 809264790Sbapt 810264790Sbapt#if YYPURE 811264790Sbapt memset(&yystack, 0, sizeof(yystack)); 812264790Sbapt#endif 813264790Sbapt 814264790Sbapt if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 815264790Sbapt yystack.s_mark = yystack.s_base; 816264790Sbapt yystack.l_mark = yystack.l_base; 817264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 818264790Sbapt yystack.p_mark = yystack.p_base; 819264790Sbapt#endif 820264790Sbapt yystate = 0; 821264790Sbapt *yystack.s_mark = 0; 822264790Sbapt 823264790Sbaptyyloop: 824264790Sbapt if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 825264790Sbapt if (yychar < 0) 826264790Sbapt { 827264790Sbapt#if YYBTYACC 828264790Sbapt do { 829264790Sbapt if (yylvp < yylve) 830264790Sbapt { 831264790Sbapt /* we're currently re-reading tokens */ 832264790Sbapt yylval = *yylvp++; 833264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 834264790Sbapt yylloc = *yylpp++; 835264790Sbapt#endif 836264790Sbapt yychar = *yylexp++; 837264790Sbapt break; 838264790Sbapt } 839264790Sbapt if (yyps->save) 840264790Sbapt { 841264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 842264790Sbapt if (yylvp == yylvlim) 843264790Sbapt { /* Enlarge lexical value queue */ 844264790Sbapt int p = yylvp - yylvals; 845264790Sbapt int s = yylvlim - yylvals; 846264790Sbapt 847264790Sbapt s += YYLVQUEUEGROWTH; 848264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 849264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 850264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 851264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 852264790Sbapt#endif 853264790Sbapt yylvp = yylve = yylvals + p; 854264790Sbapt yylvlim = yylvals + s; 855264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 856264790Sbapt yylpp = yylpe = yylpsns + p; 857264790Sbapt yylplim = yylpsns + s; 858264790Sbapt#endif 859264790Sbapt yylexp = yylexemes + p; 860264790Sbapt } 861264790Sbapt *yylexp = (short) YYLEX; 862264790Sbapt *yylvp++ = yylval; 863264790Sbapt yylve++; 864264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 865264790Sbapt *yylpp++ = yylloc; 866264790Sbapt yylpe++; 867264790Sbapt#endif 868264790Sbapt yychar = *yylexp++; 869264790Sbapt break; 870264790Sbapt } 871264790Sbapt /* normal operation, no conflict encountered */ 872264790Sbapt#endif /* YYBTYACC */ 873264790Sbapt yychar = YYLEX; 874264790Sbapt#if YYBTYACC 875264790Sbapt } while (0); 876264790Sbapt#endif /* YYBTYACC */ 877264790Sbapt if (yychar < 0) yychar = YYEOF; 878264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 879264790Sbapt#if YYDEBUG 880264790Sbapt if (yydebug) 881264790Sbapt { 882264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 883264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 884264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 885264790Sbapt#ifdef YYSTYPE_TOSTRING 886264790Sbapt#if YYBTYACC 887264790Sbapt if (!yytrial) 888264790Sbapt#endif /* YYBTYACC */ 889264790Sbapt fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 890264790Sbapt#endif 891264790Sbapt fputc('\n', stderr); 892264790Sbapt } 893264790Sbapt#endif 894264790Sbapt } 895264790Sbapt#if YYBTYACC 896264790Sbapt 897264790Sbapt /* Do we have a conflict? */ 898264790Sbapt if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 899264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 900264790Sbapt { 901264790Sbapt YYINT ctry; 902264790Sbapt 903264790Sbapt if (yypath) 904264790Sbapt { 905264790Sbapt YYParseState *save; 906264790Sbapt#if YYDEBUG 907264790Sbapt if (yydebug) 908264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 909264790Sbapt YYDEBUGSTR, yydepth, yystate); 910264790Sbapt#endif 911264790Sbapt /* Switch to the next conflict context */ 912264790Sbapt save = yypath; 913264790Sbapt yypath = save->save; 914264790Sbapt save->save = NULL; 915264790Sbapt ctry = save->ctry; 916264790Sbapt if (save->state != yystate) YYABORT; 917264790Sbapt yyFreeState(save); 918264790Sbapt 919264790Sbapt } 920264790Sbapt else 921264790Sbapt { 922264790Sbapt 923264790Sbapt /* Unresolved conflict - start/continue trial parse */ 924264790Sbapt YYParseState *save; 925264790Sbapt#if YYDEBUG 926264790Sbapt if (yydebug) 927264790Sbapt { 928264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 929264790Sbapt if (yyps->save) 930264790Sbapt fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 931264790Sbapt else 932264790Sbapt fputs("Starting trial parse.\n", stderr); 933264790Sbapt } 934264790Sbapt#endif 935264790Sbapt save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 936264790Sbapt if (save == NULL) goto yyenomem; 937264790Sbapt save->save = yyps->save; 938264790Sbapt save->state = yystate; 939264790Sbapt save->errflag = yyerrflag; 940264790Sbapt save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 941264790Sbapt memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 942264790Sbapt save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 943264790Sbapt memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 944264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 945264790Sbapt save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 946264790Sbapt memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 947264790Sbapt#endif 948264790Sbapt ctry = yytable[yyn]; 949264790Sbapt if (yyctable[ctry] == -1) 950264790Sbapt { 951264790Sbapt#if YYDEBUG 952264790Sbapt if (yydebug && yychar >= YYEOF) 953264790Sbapt fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 954264790Sbapt#endif 955264790Sbapt ctry++; 956264790Sbapt } 957264790Sbapt save->ctry = ctry; 958264790Sbapt if (yyps->save == NULL) 959264790Sbapt { 960264790Sbapt /* If this is a first conflict in the stack, start saving lexemes */ 961264790Sbapt if (!yylexemes) 962264790Sbapt { 963264790Sbapt yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 964264790Sbapt if (yylexemes == NULL) goto yyenomem; 965264790Sbapt yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 966264790Sbapt if (yylvals == NULL) goto yyenomem; 967264790Sbapt yylvlim = yylvals + YYLVQUEUEGROWTH; 968264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 969264790Sbapt yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 970264790Sbapt if (yylpsns == NULL) goto yyenomem; 971264790Sbapt yylplim = yylpsns + YYLVQUEUEGROWTH; 972264790Sbapt#endif 973264790Sbapt } 974264790Sbapt if (yylvp == yylve) 975264790Sbapt { 976264790Sbapt yylvp = yylve = yylvals; 977264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 978264790Sbapt yylpp = yylpe = yylpsns; 979264790Sbapt#endif 980264790Sbapt yylexp = yylexemes; 981264790Sbapt if (yychar >= YYEOF) 982264790Sbapt { 983264790Sbapt *yylve++ = yylval; 984264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 985264790Sbapt *yylpe++ = yylloc; 986264790Sbapt#endif 987264790Sbapt *yylexp = (short) yychar; 988264790Sbapt yychar = YYEMPTY; 989264790Sbapt } 990264790Sbapt } 991264790Sbapt } 992264790Sbapt if (yychar >= YYEOF) 993264790Sbapt { 994264790Sbapt yylvp--; 995264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 996264790Sbapt yylpp--; 997264790Sbapt#endif 998264790Sbapt yylexp--; 999264790Sbapt yychar = YYEMPTY; 1000264790Sbapt } 1001264790Sbapt save->lexeme = yylvp - yylvals; 1002264790Sbapt yyps->save = save; 1003264790Sbapt } 1004264790Sbapt if (yytable[yyn] == ctry) 1005264790Sbapt { 1006264790Sbapt#if YYDEBUG 1007264790Sbapt if (yydebug) 1008264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1009264790Sbapt YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 1010264790Sbapt#endif 1011264790Sbapt if (yychar < 0) 1012264790Sbapt { 1013264790Sbapt yylvp++; 1014264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1015264790Sbapt yylpp++; 1016264790Sbapt#endif 1017264790Sbapt yylexp++; 1018264790Sbapt } 1019264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 1020264790Sbapt goto yyoverflow; 1021264790Sbapt yystate = yyctable[ctry]; 1022264790Sbapt *++yystack.s_mark = (short) yystate; 1023264790Sbapt *++yystack.l_mark = yylval; 1024264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1025264790Sbapt *++yystack.p_mark = yylloc; 1026264790Sbapt#endif 1027264790Sbapt yychar = YYEMPTY; 1028264790Sbapt if (yyerrflag > 0) --yyerrflag; 1029264790Sbapt goto yyloop; 1030264790Sbapt } 1031264790Sbapt else 1032264790Sbapt { 1033264790Sbapt yyn = yyctable[ctry]; 1034264790Sbapt goto yyreduce; 1035264790Sbapt } 1036264790Sbapt } /* End of code dealing with conflicts */ 1037264790Sbapt#endif /* YYBTYACC */ 1038264790Sbapt if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1039264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1040264790Sbapt { 1041264790Sbapt#if YYDEBUG 1042264790Sbapt if (yydebug) 1043264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 1044264790Sbapt YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 1045264790Sbapt#endif 1046264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1047264790Sbapt yystate = yytable[yyn]; 1048264790Sbapt *++yystack.s_mark = yytable[yyn]; 1049264790Sbapt *++yystack.l_mark = yylval; 1050264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1051264790Sbapt *++yystack.p_mark = yylloc; 1052264790Sbapt#endif 1053264790Sbapt yychar = YYEMPTY; 1054264790Sbapt if (yyerrflag > 0) --yyerrflag; 1055264790Sbapt goto yyloop; 1056264790Sbapt } 1057264790Sbapt if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 1058264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 1059264790Sbapt { 1060264790Sbapt yyn = yytable[yyn]; 1061264790Sbapt goto yyreduce; 1062264790Sbapt } 1063264790Sbapt if (yyerrflag != 0) goto yyinrecovery; 1064264790Sbapt#if YYBTYACC 1065264790Sbapt 1066264790Sbapt yynewerrflag = 1; 1067264790Sbapt goto yyerrhandler; 1068264790Sbapt goto yyerrlab; 1069264790Sbapt 1070264790Sbaptyyerrlab: 1071264790Sbapt yynewerrflag = 0; 1072264790Sbaptyyerrhandler: 1073264790Sbapt while (yyps->save) 1074264790Sbapt { 1075264790Sbapt int ctry; 1076264790Sbapt YYParseState *save = yyps->save; 1077264790Sbapt#if YYDEBUG 1078264790Sbapt if (yydebug) 1079264790Sbapt fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 1080264790Sbapt YYDEBUGSTR, yydepth, yystate, yyps->save->state, 1081264790Sbapt (int)(yylvp - yylvals - yyps->save->lexeme)); 1082264790Sbapt#endif 1083264790Sbapt /* Memorize most forward-looking error state in case it's really an error. */ 1084264790Sbapt if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 1085264790Sbapt { 1086264790Sbapt /* Free old saved error context state */ 1087264790Sbapt if (yyerrctx) yyFreeState(yyerrctx); 1088264790Sbapt /* Create and fill out new saved error context state */ 1089264790Sbapt yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 1090264790Sbapt if (yyerrctx == NULL) goto yyenomem; 1091264790Sbapt yyerrctx->save = yyps->save; 1092264790Sbapt yyerrctx->state = yystate; 1093264790Sbapt yyerrctx->errflag = yyerrflag; 1094264790Sbapt yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 1095264790Sbapt memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1096264790Sbapt yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 1097264790Sbapt memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1098264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1099264790Sbapt yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 1100264790Sbapt memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1101264790Sbapt#endif 1102264790Sbapt yyerrctx->lexeme = yylvp - yylvals; 1103264790Sbapt } 1104264790Sbapt yylvp = yylvals + save->lexeme; 1105264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1106264790Sbapt yylpp = yylpsns + save->lexeme; 1107264790Sbapt#endif 1108264790Sbapt yylexp = yylexemes + save->lexeme; 1109264790Sbapt yychar = YYEMPTY; 1110264790Sbapt yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1111264790Sbapt memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1112264790Sbapt yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1113264790Sbapt memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1114264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1115264790Sbapt yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1116264790Sbapt memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1117264790Sbapt#endif 1118264790Sbapt ctry = ++save->ctry; 1119264790Sbapt yystate = save->state; 1120264790Sbapt /* We tried shift, try reduce now */ 1121264790Sbapt if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1122264790Sbapt yyps->save = save->save; 1123264790Sbapt save->save = NULL; 1124264790Sbapt yyFreeState(save); 1125264790Sbapt 1126264790Sbapt /* Nothing left on the stack -- error */ 1127264790Sbapt if (!yyps->save) 1128264790Sbapt { 1129264790Sbapt#if YYDEBUG 1130264790Sbapt if (yydebug) 1131264790Sbapt fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1132264790Sbapt YYPREFIX, yydepth); 1133264790Sbapt#endif 1134264790Sbapt /* Restore state as it was in the most forward-advanced error */ 1135264790Sbapt yylvp = yylvals + yyerrctx->lexeme; 1136264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1137264790Sbapt yylpp = yylpsns + yyerrctx->lexeme; 1138264790Sbapt#endif 1139264790Sbapt yylexp = yylexemes + yyerrctx->lexeme; 1140264790Sbapt yychar = yylexp[-1]; 1141264790Sbapt yylval = yylvp[-1]; 1142264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1143264790Sbapt yylloc = yylpp[-1]; 1144264790Sbapt#endif 1145264790Sbapt yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1146264790Sbapt memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1147264790Sbapt yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1148264790Sbapt memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1149264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1150264790Sbapt yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1151264790Sbapt memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1152264790Sbapt#endif 1153264790Sbapt yystate = yyerrctx->state; 1154264790Sbapt yyFreeState(yyerrctx); 1155264790Sbapt yyerrctx = NULL; 1156264790Sbapt } 1157264790Sbapt yynewerrflag = 1; 1158264790Sbapt } 1159264790Sbapt if (yynewerrflag == 0) goto yyinrecovery; 1160264790Sbapt#endif /* YYBTYACC */ 1161264790Sbapt 1162264790Sbapt YYERROR_CALL("syntax error"); 1163264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1164264790Sbapt yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1165264790Sbapt#endif 1166264790Sbapt 1167264790Sbapt#if !YYBTYACC 1168264790Sbapt goto yyerrlab; 1169264790Sbaptyyerrlab: 1170264790Sbapt#endif 1171264790Sbapt ++yynerrs; 1172264790Sbapt 1173264790Sbaptyyinrecovery: 1174264790Sbapt if (yyerrflag < 3) 1175264790Sbapt { 1176264790Sbapt yyerrflag = 3; 1177264790Sbapt for (;;) 1178264790Sbapt { 1179264790Sbapt if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1180264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1181264790Sbapt { 1182264790Sbapt#if YYDEBUG 1183264790Sbapt if (yydebug) 1184264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1185264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1186264790Sbapt#endif 1187264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1188264790Sbapt yystate = yytable[yyn]; 1189264790Sbapt *++yystack.s_mark = yytable[yyn]; 1190264790Sbapt *++yystack.l_mark = yylval; 1191264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1192264790Sbapt /* lookahead position is error end position */ 1193264790Sbapt yyerror_loc_range[1] = yylloc; 1194264790Sbapt YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1195264790Sbapt *++yystack.p_mark = yyloc; 1196264790Sbapt#endif 1197264790Sbapt goto yyloop; 1198264790Sbapt } 1199264790Sbapt else 1200264790Sbapt { 1201264790Sbapt#if YYDEBUG 1202264790Sbapt if (yydebug) 1203264790Sbapt fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1204264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark); 1205264790Sbapt#endif 1206264790Sbapt if (yystack.s_mark <= yystack.s_base) goto yyabort; 1207264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1208264790Sbapt /* the current TOS position is the error start position */ 1209264790Sbapt yyerror_loc_range[0] = *yystack.p_mark; 1210264790Sbapt#endif 1211264790Sbapt#if defined(YYDESTRUCT_CALL) 1212264790Sbapt#if YYBTYACC 1213264790Sbapt if (!yytrial) 1214264790Sbapt#endif /* YYBTYACC */ 1215264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1216264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1217264790Sbapt yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1218264790Sbapt#else 1219264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1220264790Sbapt yystos[*yystack.s_mark], yystack.l_mark); 1221264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1222264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1223264790Sbapt --yystack.s_mark; 1224264790Sbapt --yystack.l_mark; 1225264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1226264790Sbapt --yystack.p_mark; 1227264790Sbapt#endif 1228264790Sbapt } 1229264790Sbapt } 1230264790Sbapt } 1231264790Sbapt else 1232264790Sbapt { 1233264790Sbapt if (yychar == YYEOF) goto yyabort; 1234264790Sbapt#if YYDEBUG 1235264790Sbapt if (yydebug) 1236264790Sbapt { 1237264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1238264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1239264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 1240264790Sbapt } 1241264790Sbapt#endif 1242264790Sbapt#if defined(YYDESTRUCT_CALL) 1243264790Sbapt#if YYBTYACC 1244264790Sbapt if (!yytrial) 1245264790Sbapt#endif /* YYBTYACC */ 1246264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1247264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1248264790Sbapt#else 1249264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1250264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1251264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1252264790Sbapt yychar = YYEMPTY; 1253264790Sbapt goto yyloop; 1254264790Sbapt } 1255264790Sbapt 1256264790Sbaptyyreduce: 1257264790Sbapt yym = yylen[yyn]; 1258264790Sbapt#if YYDEBUG 1259264790Sbapt if (yydebug) 1260264790Sbapt { 1261264790Sbapt fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1262264790Sbapt YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1263264790Sbapt#ifdef YYSTYPE_TOSTRING 1264264790Sbapt#if YYBTYACC 1265264790Sbapt if (!yytrial) 1266264790Sbapt#endif /* YYBTYACC */ 1267264790Sbapt if (yym > 0) 1268264790Sbapt { 1269264790Sbapt int i; 1270264790Sbapt fputc('<', stderr); 1271264790Sbapt for (i = yym; i > 0; i--) 1272264790Sbapt { 1273264790Sbapt if (i != yym) fputs(", ", stderr); 1274264790Sbapt fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1275264790Sbapt yystack.l_mark[1-i]), stderr); 1276264790Sbapt } 1277264790Sbapt fputc('>', stderr); 1278264790Sbapt } 1279264790Sbapt#endif 1280264790Sbapt fputc('\n', stderr); 1281264790Sbapt } 1282264790Sbapt#endif 1283264790Sbapt if (yym > 0) 1284264790Sbapt yyval = yystack.l_mark[1-yym]; 1285264790Sbapt else 1286264790Sbapt memset(&yyval, 0, sizeof yyval); 1287264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1288264790Sbapt 1289264790Sbapt /* Perform position reduction */ 1290264790Sbapt memset(&yyloc, 0, sizeof(yyloc)); 1291264790Sbapt#if YYBTYACC 1292264790Sbapt if (!yytrial) 1293264790Sbapt#endif /* YYBTYACC */ 1294264790Sbapt { 1295264790Sbapt YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1296264790Sbapt /* just in case YYERROR is invoked within the action, save 1297264790Sbapt the start of the rhs as the error start position */ 1298264790Sbapt yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1299264790Sbapt } 1300264790Sbapt#endif 1301264790Sbapt 1302264790Sbapt switch (yyn) 1303264790Sbapt { 1304264790Sbaptcase 2: 1305264790Sbapt#line 51 "btyacc_calc1.y" 1306264790Sbapt{YYVALID;} 1307264790Sbaptbreak; 1308264790Sbaptcase 3: 1309264790Sbapt#line 52 "btyacc_calc1.y" 1310264790Sbapt{YYVALID;} if (!yytrial) 1311264790Sbapt#line 53 "btyacc_calc1.y" 1312264790Sbapt{ 1313264790Sbapt yyerrok; 1314264790Sbapt } 1315264790Sbaptbreak; 1316264790Sbaptcase 4: 1317264790Sbapt if (!yytrial) 1318264790Sbapt#line 59 "btyacc_calc1.y" 1319264790Sbapt { 1320264790Sbapt (void) printf("%15.8f\n", yystack.l_mark[0].dval); 1321264790Sbapt } 1322264790Sbaptbreak; 1323264790Sbaptcase 5: 1324264790Sbapt if (!yytrial) 1325264790Sbapt#line 63 "btyacc_calc1.y" 1326264790Sbapt { 1327264790Sbapt (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[0].vval.lo, yystack.l_mark[0].vval.hi); 1328264790Sbapt } 1329264790Sbaptbreak; 1330264790Sbaptcase 6: 1331264790Sbapt if (!yytrial) 1332264790Sbapt#line 67 "btyacc_calc1.y" 1333264790Sbapt { 1334264790Sbapt dreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].dval; 1335264790Sbapt } 1336264790Sbaptbreak; 1337264790Sbaptcase 7: 1338264790Sbapt if (!yytrial) 1339264790Sbapt#line 71 "btyacc_calc1.y" 1340264790Sbapt { 1341264790Sbapt vreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].vval; 1342264790Sbapt } 1343264790Sbaptbreak; 1344264790Sbaptcase 9: 1345264790Sbapt if (!yytrial) 1346264790Sbapt#line 78 "btyacc_calc1.y" 1347264790Sbapt { 1348264790Sbapt yyval.dval = dreg[yystack.l_mark[0].ival]; 1349264790Sbapt } 1350264790Sbaptbreak; 1351264790Sbaptcase 10: 1352264790Sbapt if (!yytrial) 1353264790Sbapt#line 82 "btyacc_calc1.y" 1354264790Sbapt { 1355264790Sbapt yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval; 1356264790Sbapt } 1357264790Sbaptbreak; 1358264790Sbaptcase 11: 1359264790Sbapt if (!yytrial) 1360264790Sbapt#line 86 "btyacc_calc1.y" 1361264790Sbapt { 1362264790Sbapt yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval; 1363264790Sbapt } 1364264790Sbaptbreak; 1365264790Sbaptcase 12: 1366264790Sbapt if (!yytrial) 1367264790Sbapt#line 90 "btyacc_calc1.y" 1368264790Sbapt { 1369264790Sbapt yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval; 1370264790Sbapt } 1371264790Sbaptbreak; 1372264790Sbaptcase 13: 1373264790Sbapt if (!yytrial) 1374264790Sbapt#line 94 "btyacc_calc1.y" 1375264790Sbapt { 1376264790Sbapt yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval; 1377264790Sbapt } 1378264790Sbaptbreak; 1379264790Sbaptcase 14: 1380264790Sbapt if (!yytrial) 1381264790Sbapt#line 98 "btyacc_calc1.y" 1382264790Sbapt { 1383264790Sbapt yyval.dval = -yystack.l_mark[0].dval; 1384264790Sbapt } 1385264790Sbaptbreak; 1386264790Sbaptcase 15: 1387264790Sbapt if (!yytrial) 1388264790Sbapt#line 102 "btyacc_calc1.y" 1389264790Sbapt { 1390264790Sbapt yyval.dval = yystack.l_mark[-1].dval; 1391264790Sbapt } 1392264790Sbaptbreak; 1393264790Sbaptcase 16: 1394264790Sbapt if (!yytrial) 1395264790Sbapt#line 108 "btyacc_calc1.y" 1396264790Sbapt { 1397264790Sbapt yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval; 1398264790Sbapt } 1399264790Sbaptbreak; 1400264790Sbaptcase 17: 1401264790Sbapt if (!yytrial) 1402264790Sbapt#line 112 "btyacc_calc1.y" 1403264790Sbapt { 1404264790Sbapt yyval.vval.lo = yystack.l_mark[-3].dval; 1405264790Sbapt yyval.vval.hi = yystack.l_mark[-1].dval; 1406264790Sbapt if ( yyval.vval.lo > yyval.vval.hi ) 1407264790Sbapt { 1408264790Sbapt (void) printf("interval out of order\n"); 1409264790Sbapt YYERROR; 1410264790Sbapt } 1411264790Sbapt } 1412264790Sbaptbreak; 1413264790Sbaptcase 18: 1414264790Sbapt if (!yytrial) 1415264790Sbapt#line 122 "btyacc_calc1.y" 1416264790Sbapt { 1417264790Sbapt yyval.vval = vreg[yystack.l_mark[0].ival]; 1418264790Sbapt } 1419264790Sbaptbreak; 1420264790Sbaptcase 19: 1421264790Sbapt if (!yytrial) 1422264790Sbapt#line 126 "btyacc_calc1.y" 1423264790Sbapt { 1424264790Sbapt yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi; 1425264790Sbapt yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo; 1426264790Sbapt } 1427264790Sbaptbreak; 1428264790Sbaptcase 20: 1429264790Sbapt if (!yytrial) 1430264790Sbapt#line 131 "btyacc_calc1.y" 1431264790Sbapt { 1432264790Sbapt yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi; 1433264790Sbapt yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo; 1434264790Sbapt } 1435264790Sbaptbreak; 1436264790Sbaptcase 21: 1437264790Sbapt if (!yytrial) 1438264790Sbapt#line 136 "btyacc_calc1.y" 1439264790Sbapt { 1440264790Sbapt yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo; 1441264790Sbapt yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi; 1442264790Sbapt } 1443264790Sbaptbreak; 1444264790Sbaptcase 22: 1445264790Sbapt if (!yytrial) 1446264790Sbapt#line 141 "btyacc_calc1.y" 1447264790Sbapt { 1448264790Sbapt yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo; 1449264790Sbapt yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi; 1450264790Sbapt } 1451264790Sbaptbreak; 1452264790Sbaptcase 23: 1453264790Sbapt if (!yytrial) 1454264790Sbapt#line 146 "btyacc_calc1.y" 1455264790Sbapt { 1456264790Sbapt yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval ); 1457264790Sbapt } 1458264790Sbaptbreak; 1459264790Sbaptcase 24: 1460264790Sbapt if (!yytrial) 1461264790Sbapt#line 150 "btyacc_calc1.y" 1462264790Sbapt { 1463264790Sbapt yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval ); 1464264790Sbapt } 1465264790Sbaptbreak; 1466264790Sbaptcase 25: 1467264790Sbapt if (!yytrial) 1468264790Sbapt#line 154 "btyacc_calc1.y" 1469264790Sbapt { 1470264790Sbapt if (dcheck(yystack.l_mark[0].vval)) YYERROR; 1471264790Sbapt yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval ); 1472264790Sbapt } 1473264790Sbaptbreak; 1474264790Sbaptcase 26: 1475264790Sbapt if (!yytrial) 1476264790Sbapt#line 159 "btyacc_calc1.y" 1477264790Sbapt { 1478264790Sbapt if (dcheck ( yystack.l_mark[0].vval )) YYERROR; 1479264790Sbapt yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval ); 1480264790Sbapt } 1481264790Sbaptbreak; 1482264790Sbaptcase 27: 1483264790Sbapt if (!yytrial) 1484264790Sbapt#line 164 "btyacc_calc1.y" 1485264790Sbapt { 1486264790Sbapt yyval.vval.hi = -yystack.l_mark[0].vval.lo; 1487264790Sbapt yyval.vval.lo = -yystack.l_mark[0].vval.hi; 1488264790Sbapt } 1489264790Sbaptbreak; 1490264790Sbaptcase 28: 1491264790Sbapt if (!yytrial) 1492264790Sbapt#line 169 "btyacc_calc1.y" 1493264790Sbapt { 1494264790Sbapt yyval.vval = yystack.l_mark[-1].vval; 1495264790Sbapt } 1496264790Sbaptbreak; 1497264790Sbapt#line 1498 "btyacc_calc1.tab.c" 1498264790Sbapt default: 1499264790Sbapt break; 1500264790Sbapt } 1501264790Sbapt yystack.s_mark -= yym; 1502264790Sbapt yystate = *yystack.s_mark; 1503264790Sbapt yystack.l_mark -= yym; 1504264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1505264790Sbapt yystack.p_mark -= yym; 1506264790Sbapt#endif 1507264790Sbapt yym = yylhs[yyn]; 1508264790Sbapt if (yystate == 0 && yym == 0) 1509264790Sbapt { 1510264790Sbapt#if YYDEBUG 1511264790Sbapt if (yydebug) 1512264790Sbapt { 1513264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1514264790Sbapt#ifdef YYSTYPE_TOSTRING 1515264790Sbapt#if YYBTYACC 1516264790Sbapt if (!yytrial) 1517264790Sbapt#endif /* YYBTYACC */ 1518264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1519264790Sbapt#endif 1520264790Sbapt fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1521264790Sbapt } 1522264790Sbapt#endif 1523264790Sbapt yystate = YYFINAL; 1524264790Sbapt *++yystack.s_mark = YYFINAL; 1525264790Sbapt *++yystack.l_mark = yyval; 1526264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1527264790Sbapt *++yystack.p_mark = yyloc; 1528264790Sbapt#endif 1529264790Sbapt if (yychar < 0) 1530264790Sbapt { 1531264790Sbapt#if YYBTYACC 1532264790Sbapt do { 1533264790Sbapt if (yylvp < yylve) 1534264790Sbapt { 1535264790Sbapt /* we're currently re-reading tokens */ 1536264790Sbapt yylval = *yylvp++; 1537264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1538264790Sbapt yylloc = *yylpp++; 1539264790Sbapt#endif 1540264790Sbapt yychar = *yylexp++; 1541264790Sbapt break; 1542264790Sbapt } 1543264790Sbapt if (yyps->save) 1544264790Sbapt { 1545264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 1546264790Sbapt if (yylvp == yylvlim) 1547264790Sbapt { /* Enlarge lexical value queue */ 1548264790Sbapt int p = yylvp - yylvals; 1549264790Sbapt int s = yylvlim - yylvals; 1550264790Sbapt 1551264790Sbapt s += YYLVQUEUEGROWTH; 1552264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1553264790Sbapt goto yyenomem; 1554264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1555264790Sbapt goto yyenomem; 1556264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1557264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1558264790Sbapt goto yyenomem; 1559264790Sbapt#endif 1560264790Sbapt yylvp = yylve = yylvals + p; 1561264790Sbapt yylvlim = yylvals + s; 1562264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1563264790Sbapt yylpp = yylpe = yylpsns + p; 1564264790Sbapt yylplim = yylpsns + s; 1565264790Sbapt#endif 1566264790Sbapt yylexp = yylexemes + p; 1567264790Sbapt } 1568264790Sbapt *yylexp = (short) YYLEX; 1569264790Sbapt *yylvp++ = yylval; 1570264790Sbapt yylve++; 1571264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1572264790Sbapt *yylpp++ = yylloc; 1573264790Sbapt yylpe++; 1574264790Sbapt#endif 1575264790Sbapt yychar = *yylexp++; 1576264790Sbapt break; 1577264790Sbapt } 1578264790Sbapt /* normal operation, no conflict encountered */ 1579264790Sbapt#endif /* YYBTYACC */ 1580264790Sbapt yychar = YYLEX; 1581264790Sbapt#if YYBTYACC 1582264790Sbapt } while (0); 1583264790Sbapt#endif /* YYBTYACC */ 1584264790Sbapt if (yychar < 0) yychar = YYEOF; 1585264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1586264790Sbapt#if YYDEBUG 1587264790Sbapt if (yydebug) 1588264790Sbapt { 1589264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1590264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1591264790Sbapt YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1592264790Sbapt } 1593264790Sbapt#endif 1594264790Sbapt } 1595264790Sbapt if (yychar == YYEOF) goto yyaccept; 1596264790Sbapt goto yyloop; 1597264790Sbapt } 1598264790Sbapt if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1599264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1600264790Sbapt yystate = yytable[yyn]; 1601264790Sbapt else 1602264790Sbapt yystate = yydgoto[yym]; 1603264790Sbapt#if YYDEBUG 1604264790Sbapt if (yydebug) 1605264790Sbapt { 1606264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1607264790Sbapt#ifdef YYSTYPE_TOSTRING 1608264790Sbapt#if YYBTYACC 1609264790Sbapt if (!yytrial) 1610264790Sbapt#endif /* YYBTYACC */ 1611264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1612264790Sbapt#endif 1613264790Sbapt fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1614264790Sbapt } 1615264790Sbapt#endif 1616264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1617264790Sbapt *++yystack.s_mark = (short) yystate; 1618264790Sbapt *++yystack.l_mark = yyval; 1619264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1620264790Sbapt *++yystack.p_mark = yyloc; 1621264790Sbapt#endif 1622264790Sbapt goto yyloop; 1623264790Sbapt#if YYBTYACC 1624264790Sbapt 1625264790Sbapt /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1626264790Sbaptyyvalid: 1627264790Sbapt if (yypath) YYABORT; 1628264790Sbapt while (yyps->save) 1629264790Sbapt { 1630264790Sbapt YYParseState *save = yyps->save; 1631264790Sbapt yyps->save = save->save; 1632264790Sbapt save->save = yypath; 1633264790Sbapt yypath = save; 1634264790Sbapt } 1635264790Sbapt#if YYDEBUG 1636264790Sbapt if (yydebug) 1637264790Sbapt fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1638264790Sbapt YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1639264790Sbapt#endif 1640264790Sbapt if (yyerrctx) 1641264790Sbapt { 1642264790Sbapt yyFreeState(yyerrctx); 1643264790Sbapt yyerrctx = NULL; 1644264790Sbapt } 1645264790Sbapt yylvp = yylvals + yypath->lexeme; 1646264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1647264790Sbapt yylpp = yylpsns + yypath->lexeme; 1648264790Sbapt#endif 1649264790Sbapt yylexp = yylexemes + yypath->lexeme; 1650264790Sbapt yychar = YYEMPTY; 1651264790Sbapt yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1652264790Sbapt memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1653264790Sbapt yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1654264790Sbapt memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1655264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1656264790Sbapt yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1657264790Sbapt memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1658264790Sbapt#endif 1659264790Sbapt yystate = yypath->state; 1660264790Sbapt goto yyloop; 1661264790Sbapt#endif /* YYBTYACC */ 1662264790Sbapt 1663264790Sbaptyyoverflow: 1664264790Sbapt YYERROR_CALL("yacc stack overflow"); 1665264790Sbapt#if YYBTYACC 1666264790Sbapt goto yyabort_nomem; 1667264790Sbaptyyenomem: 1668264790Sbapt YYERROR_CALL("memory exhausted"); 1669264790Sbaptyyabort_nomem: 1670264790Sbapt#endif /* YYBTYACC */ 1671264790Sbapt yyresult = 2; 1672264790Sbapt goto yyreturn; 1673264790Sbapt 1674264790Sbaptyyabort: 1675264790Sbapt yyresult = 1; 1676264790Sbapt goto yyreturn; 1677264790Sbapt 1678264790Sbaptyyaccept: 1679264790Sbapt#if YYBTYACC 1680264790Sbapt if (yyps->save) goto yyvalid; 1681264790Sbapt#endif /* YYBTYACC */ 1682264790Sbapt yyresult = 0; 1683264790Sbapt 1684264790Sbaptyyreturn: 1685264790Sbapt#if defined(YYDESTRUCT_CALL) 1686264790Sbapt if (yychar != YYEOF && yychar != YYEMPTY) 1687264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1688264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1689264790Sbapt#else 1690264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1691264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1692264790Sbapt 1693264790Sbapt { 1694264790Sbapt YYSTYPE *pv; 1695264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1696264790Sbapt YYLTYPE *pp; 1697264790Sbapt 1698264790Sbapt for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1699264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1700264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1701264790Sbapt#else 1702264790Sbapt for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1703264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1704264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1705264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1706264790Sbapt } 1707264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1708264790Sbapt 1709264790Sbapt#if YYBTYACC 1710264790Sbapt if (yyerrctx) 1711264790Sbapt { 1712264790Sbapt yyFreeState(yyerrctx); 1713264790Sbapt yyerrctx = NULL; 1714264790Sbapt } 1715264790Sbapt while (yyps) 1716264790Sbapt { 1717264790Sbapt YYParseState *save = yyps; 1718264790Sbapt yyps = save->save; 1719264790Sbapt save->save = NULL; 1720264790Sbapt yyFreeState(save); 1721264790Sbapt } 1722264790Sbapt while (yypath) 1723264790Sbapt { 1724264790Sbapt YYParseState *save = yypath; 1725264790Sbapt yypath = save->save; 1726264790Sbapt save->save = NULL; 1727264790Sbapt yyFreeState(save); 1728264790Sbapt } 1729264790Sbapt#endif /* YYBTYACC */ 1730264790Sbapt yyfreestack(&yystack); 1731264790Sbapt return (yyresult); 1732264790Sbapt} 1733