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