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