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 ok_syntax1_parse 22264790Sbapt#endif /* yyparse */ 23264790Sbapt 24264790Sbapt#ifndef yylex 25264790Sbapt#define yylex ok_syntax1_lex 26264790Sbapt#endif /* yylex */ 27264790Sbapt 28264790Sbapt#ifndef yyerror 29264790Sbapt#define yyerror ok_syntax1_error 30264790Sbapt#endif /* yyerror */ 31264790Sbapt 32264790Sbapt#ifndef yychar 33264790Sbapt#define yychar ok_syntax1_char 34264790Sbapt#endif /* yychar */ 35264790Sbapt 36264790Sbapt#ifndef yyval 37264790Sbapt#define yyval ok_syntax1_val 38264790Sbapt#endif /* yyval */ 39264790Sbapt 40264790Sbapt#ifndef yylval 41264790Sbapt#define yylval ok_syntax1_lval 42264790Sbapt#endif /* yylval */ 43264790Sbapt 44264790Sbapt#ifndef yydebug 45264790Sbapt#define yydebug ok_syntax1_debug 46264790Sbapt#endif /* yydebug */ 47264790Sbapt 48264790Sbapt#ifndef yynerrs 49264790Sbapt#define yynerrs ok_syntax1_nerrs 50264790Sbapt#endif /* yynerrs */ 51264790Sbapt 52264790Sbapt#ifndef yyerrflag 53264790Sbapt#define yyerrflag ok_syntax1_errflag 54264790Sbapt#endif /* yyerrflag */ 55264790Sbapt 56264790Sbapt#ifndef yylhs 57264790Sbapt#define yylhs ok_syntax1_lhs 58264790Sbapt#endif /* yylhs */ 59264790Sbapt 60264790Sbapt#ifndef yylen 61264790Sbapt#define yylen ok_syntax1_len 62264790Sbapt#endif /* yylen */ 63264790Sbapt 64264790Sbapt#ifndef yydefred 65264790Sbapt#define yydefred ok_syntax1_defred 66264790Sbapt#endif /* yydefred */ 67264790Sbapt 68264790Sbapt#ifndef yystos 69264790Sbapt#define yystos ok_syntax1_stos 70264790Sbapt#endif /* yystos */ 71264790Sbapt 72264790Sbapt#ifndef yydgoto 73264790Sbapt#define yydgoto ok_syntax1_dgoto 74264790Sbapt#endif /* yydgoto */ 75264790Sbapt 76264790Sbapt#ifndef yysindex 77264790Sbapt#define yysindex ok_syntax1_sindex 78264790Sbapt#endif /* yysindex */ 79264790Sbapt 80264790Sbapt#ifndef yyrindex 81264790Sbapt#define yyrindex ok_syntax1_rindex 82264790Sbapt#endif /* yyrindex */ 83264790Sbapt 84264790Sbapt#ifndef yygindex 85264790Sbapt#define yygindex ok_syntax1_gindex 86264790Sbapt#endif /* yygindex */ 87264790Sbapt 88264790Sbapt#ifndef yytable 89264790Sbapt#define yytable ok_syntax1_table 90264790Sbapt#endif /* yytable */ 91264790Sbapt 92264790Sbapt#ifndef yycheck 93264790Sbapt#define yycheck ok_syntax1_check 94264790Sbapt#endif /* yycheck */ 95264790Sbapt 96264790Sbapt#ifndef yyname 97264790Sbapt#define yyname ok_syntax1_name 98264790Sbapt#endif /* yyname */ 99264790Sbapt 100264790Sbapt#ifndef yyrule 101264790Sbapt#define yyrule ok_syntax1_rule 102264790Sbapt#endif /* yyrule */ 103264790Sbapt 104264790Sbapt#if YYBTYACC 105264790Sbapt 106264790Sbapt#ifndef yycindex 107264790Sbapt#define yycindex ok_syntax1_cindex 108264790Sbapt#endif /* yycindex */ 109264790Sbapt 110264790Sbapt#ifndef yyctable 111264790Sbapt#define yyctable ok_syntax1_ctable 112264790Sbapt#endif /* yyctable */ 113264790Sbapt 114264790Sbapt#endif /* YYBTYACC */ 115264790Sbapt 116264790Sbapt#define YYPREFIX "ok_syntax1_" 117264790Sbapt 118264790Sbapt#define YYPURE 1 119264790Sbapt 120264790Sbapt#line 9 "ok_syntax1.y" 121264790Sbapt# include <stdio.h> 122264790Sbapt# include <ctype.h> 123264790Sbapt 124264790Sbapt#ifdef YYBISON 125264790Sbapt#define YYSTYPE int 126264790Sbapt#define YYLEX_PARAM base 127264790Sbapt#define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM) 128264790Sbapt#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s) 129264790Sbaptint YYLEX_DECL(); 130264790Sbaptstatic void YYERROR_DECL(); 131264790Sbapt#endif 132264790Sbapt 133264790Sbapt#line 43 "ok_syntax1.y" 134264790Sbapt#ifdef YYSTYPE 135264790Sbapt#undef YYSTYPE_IS_DECLARED 136264790Sbapt#define YYSTYPE_IS_DECLARED 1 137264790Sbapt#endif 138264790Sbapt#ifndef YYSTYPE_IS_DECLARED 139264790Sbapt#define YYSTYPE_IS_DECLARED 1 140264790Sbapttypedef union 141264790Sbapt{ 142264790Sbapt char * cval; 143264790Sbapt int ival; 144264790Sbapt double dval; 145264790Sbapt} YYSTYPE; 146264790Sbapt#endif /* !YYSTYPE_IS_DECLARED */ 147264790Sbapt#line 148 "ok_syntax1.tab.c" 148264790Sbapt 149264790Sbapt/* compatibility with bison */ 150264790Sbapt#ifdef YYPARSE_PARAM 151264790Sbapt/* compatibility with FreeBSD */ 152264790Sbapt# ifdef YYPARSE_PARAM_TYPE 153264790Sbapt# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 154264790Sbapt# else 155264790Sbapt# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 156264790Sbapt# endif 157264790Sbapt#else 158264790Sbapt# define YYPARSE_DECL() yyparse(int regs[26], int * base) 159264790Sbapt#endif 160264790Sbapt 161264790Sbapt/* Parameters sent to lex. */ 162264790Sbapt#ifdef YYLEX_PARAM 163264790Sbapt# ifdef YYLEX_PARAM_TYPE 164264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM) 165264790Sbapt# else 166264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM) 167264790Sbapt# endif 168264790Sbapt# define YYLEX yylex(&yylval, YYLEX_PARAM) 169264790Sbapt#else 170264790Sbapt# define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base) 171264790Sbapt# define YYLEX yylex(&yylval, base) 172264790Sbapt#endif 173264790Sbapt 174264790Sbapt/* Parameters sent to yyerror. */ 175264790Sbapt#ifndef YYERROR_DECL 176264790Sbapt#define YYERROR_DECL() yyerror(int regs[26], int * base, const char *s) 177264790Sbapt#endif 178264790Sbapt#ifndef YYERROR_CALL 179264790Sbapt#define YYERROR_CALL(msg) yyerror(regs, base, msg) 180264790Sbapt#endif 181264790Sbapt 182264790Sbaptextern int YYPARSE_DECL(); 183264790Sbapt 184264790Sbapt#define DIGIT 257 185264790Sbapt#define LETTER 258 186264790Sbapt#define OCT1 259 187264790Sbapt#define HEX1 260 188264790Sbapt#define HEX2 261 189264790Sbapt#define HEX3 262 190264790Sbapt#define STR1 263 191264790Sbapt#define STR2 265 192264790Sbapt#define BELL 266 193264790Sbapt#define BS 267 194264790Sbapt#define NL 268 195264790Sbapt#define LF 269 196264790Sbapt#define CR 270 197264790Sbapt#define TAB 271 198264790Sbapt#define VT 272 199264790Sbapt#define UMINUS 273 200264790Sbapt#define YYERRCODE 256 201264790Sbapttypedef short YYINT; 202264790Sbaptstatic const YYINT ok_syntax1_lhs[] = { -1, 203264790Sbapt 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 204264790Sbapt 2, 2, 2, 2, 2, 2, 3, 3, 205264790Sbapt}; 206264790Sbaptstatic const YYINT ok_syntax1_len[] = { 2, 207264790Sbapt 0, 3, 3, 1, 3, 3, 3, 3, 3, 3, 208264790Sbapt 3, 3, 3, 2, 1, 1, 1, 2, 209264790Sbapt}; 210264790Sbaptstatic const YYINT ok_syntax1_defred[] = { 1, 211264790Sbapt 0, 0, 17, 0, 0, 0, 0, 0, 0, 3, 212264790Sbapt 0, 15, 14, 0, 2, 0, 0, 0, 0, 0, 213264790Sbapt 0, 0, 18, 0, 6, 0, 0, 0, 0, 9, 214264790Sbapt 10, 11, 215264790Sbapt}; 216264790Sbaptstatic const YYINT ok_syntax1_stos[] = { 0, 217264790Sbapt 275, 256, 257, 258, 45, 40, 276, 277, 278, 10, 218264790Sbapt 61, 258, 277, 277, 10, 124, 38, 43, 45, 42, 219264790Sbapt 47, 37, 257, 277, 41, 277, 277, 277, 277, 277, 220264790Sbapt 277, 277, 221264790Sbapt}; 222264790Sbaptstatic const YYINT ok_syntax1_dgoto[] = { 1, 223264790Sbapt 7, 8, 9, 224264790Sbapt}; 225264790Sbaptstatic const YYINT ok_syntax1_sindex[] = { 0, 226264790Sbapt -40, -7, 0, -55, -38, -38, 1, -29, -247, 0, 227264790Sbapt -38, 0, 0, 22, 0, -38, -38, -38, -38, -38, 228264790Sbapt -38, -38, 0, -29, 0, 51, 60, -20, -20, 0, 229264790Sbapt 0, 0, 230264790Sbapt}; 231264790Sbaptstatic const YYINT ok_syntax1_rindex[] = { 0, 232264790Sbapt 0, 0, 0, 2, 0, 0, 0, 9, -9, 0, 233264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 234264790Sbapt 0, 0, 0, 10, 0, -6, 14, 5, 13, 0, 235264790Sbapt 0, 0, 236264790Sbapt}; 237264790Sbapt#if YYBTYACC 238264790Sbaptstatic const YYINT ok_syntax1_cindex[] = { 0, 239264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 242264790Sbapt 0, 0, 243264790Sbapt}; 244264790Sbapt#endif 245264790Sbaptstatic const YYINT ok_syntax1_gindex[] = { 0, 246264790Sbapt 0, 65, 0, 247264790Sbapt}; 248264790Sbapt#define YYTABLESIZE 220 249264790Sbaptstatic const YYINT ok_syntax1_table[] = { 6, 250264790Sbapt 16, 6, 10, 13, 5, 11, 5, 22, 17, 23, 251264790Sbapt 15, 15, 20, 18, 7, 19, 22, 21, 4, 5, 252264790Sbapt 0, 20, 8, 12, 0, 0, 21, 16, 16, 0, 253264790Sbapt 0, 16, 16, 16, 13, 16, 0, 16, 15, 15, 254264790Sbapt 0, 0, 7, 15, 15, 7, 15, 7, 15, 7, 255264790Sbapt 8, 12, 0, 8, 12, 8, 0, 8, 22, 17, 256264790Sbapt 0, 0, 25, 20, 18, 0, 19, 0, 21, 13, 257264790Sbapt 14, 0, 0, 0, 0, 24, 0, 0, 0, 0, 258264790Sbapt 26, 27, 28, 29, 30, 31, 32, 22, 17, 0, 259264790Sbapt 0, 0, 20, 18, 16, 19, 22, 21, 0, 0, 260264790Sbapt 0, 20, 18, 0, 19, 0, 21, 0, 0, 0, 261264790Sbapt 0, 0, 0, 0, 16, 0, 0, 13, 0, 0, 262264790Sbapt 0, 0, 0, 0, 0, 15, 0, 0, 7, 0, 263264790Sbapt 0, 0, 0, 0, 0, 0, 8, 12, 0, 0, 264264790Sbapt 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 265264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 266264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 267264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 268264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 269264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 270264790Sbapt 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 271264790Sbapt 0, 0, 0, 0, 0, 2, 3, 4, 3, 12, 272264790Sbapt}; 273264790Sbaptstatic const YYINT ok_syntax1_check[] = { 40, 274264790Sbapt 10, 40, 10, 10, 45, 61, 45, 37, 38, 257, 275264790Sbapt 10, 10, 42, 43, 10, 45, 37, 47, 10, 10, 276264790Sbapt -1, 42, 10, 10, -1, -1, 47, 37, 38, -1, 277264790Sbapt -1, 41, 42, 43, 41, 45, -1, 47, 37, 38, 278264790Sbapt -1, -1, 38, 42, 43, 41, 45, 43, 47, 45, 279264790Sbapt 38, 38, -1, 41, 41, 43, -1, 45, 37, 38, 280264790Sbapt -1, -1, 41, 42, 43, -1, 45, -1, 47, 5, 281264790Sbapt 6, -1, -1, -1, -1, 11, -1, -1, -1, -1, 282264790Sbapt 16, 17, 18, 19, 20, 21, 22, 37, 38, -1, 283264790Sbapt -1, -1, 42, 43, 124, 45, 37, 47, -1, -1, 284264790Sbapt -1, 42, 43, -1, 45, -1, 47, -1, -1, -1, 285264790Sbapt -1, -1, -1, -1, 124, -1, -1, 124, -1, -1, 286264790Sbapt -1, -1, -1, -1, -1, 124, -1, -1, 124, -1, 287264790Sbapt -1, -1, -1, -1, -1, -1, 124, 124, -1, -1, 288264790Sbapt -1, -1, -1, -1, -1, 124, -1, -1, -1, -1, 289264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 290264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 291264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 292264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 293264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 294264790Sbapt -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 295264790Sbapt -1, -1, -1, -1, -1, 256, 257, 258, 257, 258, 296264790Sbapt}; 297264790Sbapt#define YYFINAL 1 298264790Sbapt#ifndef YYDEBUG 299264790Sbapt#define YYDEBUG 0 300264790Sbapt#endif 301264790Sbapt#define YYMAXTOKEN 273 302264790Sbapt#define YYUNDFTOKEN 279 303264790Sbapt#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 304264790Sbapt#if YYDEBUG 305264790Sbaptstatic const char *const ok_syntax1_name[] = { 306264790Sbapt 307264790Sbapt"$end",0,0,0,0,0,0,"'\\a'","'\\b'","'\\t'","'\\n'","'\\v'","'\\f'","'\\r'",0,0, 308264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'#'",0,"'%'","'&'",0,"'('","')'","'*'", 309264790Sbapt"'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,0,"'='",0,0,"'@'",0,0,0,0,0,0,0,0, 310264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 311264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,"'~'","'\\177'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 312264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 313264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 314264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'\\377'", 315264790Sbapt"error","DIGIT","LETTER","OCT1","HEX1","HEX2","HEX3","STR1", 316264790Sbapt"\"\\177\\177\\\\\\n\"","STR2","BELL","BS","NL","LF","CR","TAB","VT","UMINUS", 317264790Sbapt"$accept","list","stat","expr","number","illegal-symbol", 318264790Sbapt}; 319264790Sbaptstatic const char *const ok_syntax1_rule[] = { 320264790Sbapt"$accept : list", 321264790Sbapt"list :", 322264790Sbapt"list : list stat '\\n'", 323264790Sbapt"list : list error '\\n'", 324264790Sbapt"stat : expr", 325264790Sbapt"stat : LETTER '=' expr", 326264790Sbapt"expr : '(' expr ')'", 327264790Sbapt"expr : expr '+' expr", 328264790Sbapt"expr : expr '-' expr", 329264790Sbapt"expr : expr '*' expr", 330264790Sbapt"expr : expr '/' expr", 331264790Sbapt"expr : expr '%' expr", 332264790Sbapt"expr : expr '&' expr", 333264790Sbapt"expr : expr '|' expr", 334264790Sbapt"expr : '-' expr", 335264790Sbapt"expr : LETTER", 336264790Sbapt"expr : number", 337264790Sbapt"number : DIGIT", 338264790Sbapt"number : number DIGIT", 339264790Sbapt 340264790Sbapt}; 341264790Sbapt#endif 342264790Sbapt 343264790Sbaptint yydebug; 344264790Sbaptint yynerrs; 345264790Sbapt 346264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 347264790Sbapt#ifndef YYLLOC_DEFAULT 348264790Sbapt#define YYLLOC_DEFAULT(loc, rhs, n) \ 349264790Sbaptdo \ 350264790Sbapt{ \ 351264790Sbapt if (n == 0) \ 352264790Sbapt { \ 353264790Sbapt (loc).first_line = ((rhs)[-1]).last_line; \ 354264790Sbapt (loc).first_column = ((rhs)[-1]).last_column; \ 355264790Sbapt (loc).last_line = ((rhs)[-1]).last_line; \ 356264790Sbapt (loc).last_column = ((rhs)[-1]).last_column; \ 357264790Sbapt } \ 358264790Sbapt else \ 359264790Sbapt { \ 360264790Sbapt (loc).first_line = ((rhs)[ 0 ]).first_line; \ 361264790Sbapt (loc).first_column = ((rhs)[ 0 ]).first_column; \ 362264790Sbapt (loc).last_line = ((rhs)[n-1]).last_line; \ 363264790Sbapt (loc).last_column = ((rhs)[n-1]).last_column; \ 364264790Sbapt } \ 365264790Sbapt} while (0) 366264790Sbapt#endif /* YYLLOC_DEFAULT */ 367264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 368264790Sbapt#if YYBTYACC 369264790Sbapt 370264790Sbapt#ifndef YYLVQUEUEGROWTH 371264790Sbapt#define YYLVQUEUEGROWTH 32 372264790Sbapt#endif 373264790Sbapt#endif /* YYBTYACC */ 374264790Sbapt 375264790Sbapt/* define the initial stack-sizes */ 376264790Sbapt#ifdef YYSTACKSIZE 377264790Sbapt#undef YYMAXDEPTH 378264790Sbapt#define YYMAXDEPTH YYSTACKSIZE 379264790Sbapt#else 380264790Sbapt#ifdef YYMAXDEPTH 381264790Sbapt#define YYSTACKSIZE YYMAXDEPTH 382264790Sbapt#else 383264790Sbapt#define YYSTACKSIZE 10000 384264790Sbapt#define YYMAXDEPTH 10000 385264790Sbapt#endif 386264790Sbapt#endif 387264790Sbapt 388264790Sbapt#ifndef YYINITSTACKSIZE 389264790Sbapt#define YYINITSTACKSIZE 200 390264790Sbapt#endif 391264790Sbapt 392264790Sbapttypedef struct { 393264790Sbapt unsigned stacksize; 394264790Sbapt short *s_base; 395264790Sbapt short *s_mark; 396264790Sbapt short *s_last; 397264790Sbapt YYSTYPE *l_base; 398264790Sbapt YYSTYPE *l_mark; 399264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 400264790Sbapt YYLTYPE *p_base; 401264790Sbapt YYLTYPE *p_mark; 402264790Sbapt#endif 403264790Sbapt} YYSTACKDATA; 404264790Sbapt#if YYBTYACC 405264790Sbapt 406264790Sbaptstruct YYParseState_s 407264790Sbapt{ 408264790Sbapt struct YYParseState_s *save; /* Previously saved parser state */ 409264790Sbapt YYSTACKDATA yystack; /* saved parser stack */ 410264790Sbapt int state; /* saved parser state */ 411264790Sbapt int errflag; /* saved error recovery status */ 412264790Sbapt int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 413264790Sbapt YYINT ctry; /* saved index in yyctable[] for this conflict */ 414264790Sbapt}; 415264790Sbapttypedef struct YYParseState_s YYParseState; 416264790Sbapt#endif /* YYBTYACC */ 417264790Sbapt#line 104 "ok_syntax1.y" 418264790Sbapt /* start of programs */ 419264790Sbapt 420264790Sbapt#ifdef YYBYACC 421264790Sbaptextern int YYLEX_DECL(); 422264790Sbapt#endif 423264790Sbapt 424264790Sbaptint 425264790Sbaptmain (void) 426264790Sbapt{ 427264790Sbapt int regs[26]; 428264790Sbapt int base = 10; 429264790Sbapt 430264790Sbapt while(!feof(stdin)) { 431264790Sbapt yyparse(regs, &base); 432264790Sbapt } 433264790Sbapt return 0; 434264790Sbapt} 435264790Sbapt 436264790Sbapt#define UNUSED(x) ((void)(x)) 437264790Sbapt 438264790Sbaptstatic void 439264790SbaptYYERROR_DECL() 440264790Sbapt{ 441264790Sbapt UNUSED(regs); /* %parse-param regs is not actually used here */ 442264790Sbapt UNUSED(base); /* %parse-param base is not actually used here */ 443264790Sbapt fprintf(stderr, "%s\n", s); 444264790Sbapt} 445264790Sbapt 446264790Sbaptint 447264790SbaptYYLEX_DECL() 448264790Sbapt{ 449264790Sbapt /* lexical analysis routine */ 450264790Sbapt /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 451264790Sbapt /* return DIGIT for a digit, yylval = 0 through 9 */ 452264790Sbapt /* all other characters are returned immediately */ 453264790Sbapt 454264790Sbapt int c; 455264790Sbapt 456264790Sbapt while( (c=getchar()) == ' ' ) { /* skip blanks */ } 457264790Sbapt 458264790Sbapt /* c is now nonblank */ 459264790Sbapt 460264790Sbapt if( islower( c )) { 461264790Sbapt yylval->ival = (c - 'a'); 462264790Sbapt return ( LETTER ); 463264790Sbapt } 464264790Sbapt if( isdigit( c )) { 465264790Sbapt yylval->ival = (c - '0') % (*base); 466264790Sbapt return ( DIGIT ); 467264790Sbapt } 468264790Sbapt return( c ); 469264790Sbapt} 470264790Sbapt#line 471 "ok_syntax1.tab.c" 471264790Sbapt 472264790Sbapt/* For use in generated program */ 473264790Sbapt#define yydepth (int)(yystack.s_mark - yystack.s_base) 474264790Sbapt#if YYBTYACC 475264790Sbapt#define yytrial (yyps->save) 476264790Sbapt#endif /* YYBTYACC */ 477264790Sbapt 478264790Sbapt#if YYDEBUG 479264790Sbapt#include <stdio.h> /* needed for printf */ 480264790Sbapt#endif 481264790Sbapt 482264790Sbapt#include <stdlib.h> /* needed for malloc, etc */ 483264790Sbapt#include <string.h> /* needed for memset */ 484264790Sbapt 485264790Sbapt/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 486264790Sbaptstatic int yygrowstack(YYSTACKDATA *data) 487264790Sbapt{ 488264790Sbapt int i; 489264790Sbapt unsigned newsize; 490264790Sbapt short *newss; 491264790Sbapt YYSTYPE *newvs; 492264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 493264790Sbapt YYLTYPE *newps; 494264790Sbapt#endif 495264790Sbapt 496264790Sbapt if ((newsize = data->stacksize) == 0) 497264790Sbapt newsize = YYINITSTACKSIZE; 498264790Sbapt else if (newsize >= YYMAXDEPTH) 499264790Sbapt return YYENOMEM; 500264790Sbapt else if ((newsize *= 2) > YYMAXDEPTH) 501264790Sbapt newsize = YYMAXDEPTH; 502264790Sbapt 503264790Sbapt i = (int) (data->s_mark - data->s_base); 504264790Sbapt newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 505264790Sbapt if (newss == 0) 506264790Sbapt return YYENOMEM; 507264790Sbapt 508264790Sbapt data->s_base = newss; 509264790Sbapt data->s_mark = newss + i; 510264790Sbapt 511264790Sbapt newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 512264790Sbapt if (newvs == 0) 513264790Sbapt return YYENOMEM; 514264790Sbapt 515264790Sbapt data->l_base = newvs; 516264790Sbapt data->l_mark = newvs + i; 517264790Sbapt 518264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 519264790Sbapt newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 520264790Sbapt if (newps == 0) 521264790Sbapt return YYENOMEM; 522264790Sbapt 523264790Sbapt data->p_base = newps; 524264790Sbapt data->p_mark = newps + i; 525264790Sbapt#endif 526264790Sbapt 527264790Sbapt data->stacksize = newsize; 528264790Sbapt data->s_last = data->s_base + newsize - 1; 529264790Sbapt 530264790Sbapt#if YYDEBUG 531264790Sbapt if (yydebug) 532264790Sbapt fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 533264790Sbapt#endif 534264790Sbapt return 0; 535264790Sbapt} 536264790Sbapt 537264790Sbapt#if YYPURE || defined(YY_NO_LEAKS) 538264790Sbaptstatic void yyfreestack(YYSTACKDATA *data) 539264790Sbapt{ 540264790Sbapt free(data->s_base); 541264790Sbapt free(data->l_base); 542264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 543264790Sbapt free(data->p_base); 544264790Sbapt#endif 545264790Sbapt memset(data, 0, sizeof(*data)); 546264790Sbapt} 547264790Sbapt#else 548264790Sbapt#define yyfreestack(data) /* nothing */ 549264790Sbapt#endif /* YYPURE || defined(YY_NO_LEAKS) */ 550264790Sbapt#if YYBTYACC 551264790Sbapt 552264790Sbaptstatic YYParseState * 553264790SbaptyyNewState(unsigned size) 554264790Sbapt{ 555264790Sbapt YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 556264790Sbapt if (p == NULL) return NULL; 557264790Sbapt 558264790Sbapt p->yystack.stacksize = size; 559264790Sbapt if (size == 0) 560264790Sbapt { 561264790Sbapt p->yystack.s_base = NULL; 562264790Sbapt p->yystack.l_base = NULL; 563264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 564264790Sbapt p->yystack.p_base = NULL; 565264790Sbapt#endif 566264790Sbapt return p; 567264790Sbapt } 568264790Sbapt p->yystack.s_base = (short *) malloc(size * sizeof(short)); 569264790Sbapt if (p->yystack.s_base == NULL) return NULL; 570264790Sbapt p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 571264790Sbapt if (p->yystack.l_base == NULL) return NULL; 572264790Sbapt memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 573264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 574264790Sbapt p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 575264790Sbapt if (p->yystack.p_base == NULL) return NULL; 576264790Sbapt memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 577264790Sbapt#endif 578264790Sbapt 579264790Sbapt return p; 580264790Sbapt} 581264790Sbapt 582264790Sbaptstatic void 583264790SbaptyyFreeState(YYParseState *p) 584264790Sbapt{ 585264790Sbapt yyfreestack(&p->yystack); 586264790Sbapt free(p); 587264790Sbapt} 588264790Sbapt#endif /* YYBTYACC */ 589264790Sbapt 590264790Sbapt#define YYABORT goto yyabort 591264790Sbapt#define YYREJECT goto yyabort 592264790Sbapt#define YYACCEPT goto yyaccept 593264790Sbapt#define YYERROR goto yyerrlab 594264790Sbapt#if YYBTYACC 595264790Sbapt#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 596264790Sbapt#define YYVALID_NESTED do { if (yyps->save && \ 597264790Sbapt yyps->save->save == 0) goto yyvalid; } while(0) 598264790Sbapt#endif /* YYBTYACC */ 599264790Sbapt 600264790Sbaptint 601264790SbaptYYPARSE_DECL() 602264790Sbapt{ 603264790Sbapt int yyerrflag; 604264790Sbapt int yychar; 605264790Sbapt YYSTYPE yyval; 606264790Sbapt YYSTYPE yylval; 607264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 608264790Sbapt YYLTYPE yyloc; /* position returned by actions */ 609264790Sbapt YYLTYPE yylloc; /* position from the lexer */ 610264790Sbapt#endif 611264790Sbapt 612264790Sbapt /* variables for the parser stack */ 613264790Sbapt YYSTACKDATA yystack; 614264790Sbapt#if YYBTYACC 615264790Sbapt 616264790Sbapt /* Current parser state */ 617264790Sbapt static YYParseState *yyps = 0; 618264790Sbapt 619264790Sbapt /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 620264790Sbapt static YYParseState *yypath = 0; 621264790Sbapt 622264790Sbapt /* Base of the lexical value queue */ 623264790Sbapt static YYSTYPE *yylvals = 0; 624264790Sbapt 625264790Sbapt /* Current position at lexical value queue */ 626264790Sbapt static YYSTYPE *yylvp = 0; 627264790Sbapt 628264790Sbapt /* End position of lexical value queue */ 629264790Sbapt static YYSTYPE *yylve = 0; 630264790Sbapt 631264790Sbapt /* The last allocated position at the lexical value queue */ 632264790Sbapt static YYSTYPE *yylvlim = 0; 633264790Sbapt 634264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 635264790Sbapt /* Base of the lexical position queue */ 636264790Sbapt static YYLTYPE *yylpsns = 0; 637264790Sbapt 638264790Sbapt /* Current position at lexical position queue */ 639264790Sbapt static YYLTYPE *yylpp = 0; 640264790Sbapt 641264790Sbapt /* End position of lexical position queue */ 642264790Sbapt static YYLTYPE *yylpe = 0; 643264790Sbapt 644264790Sbapt /* The last allocated position at the lexical position queue */ 645264790Sbapt static YYLTYPE *yylplim = 0; 646264790Sbapt#endif 647264790Sbapt 648264790Sbapt /* Current position at lexical token queue */ 649264790Sbapt static short *yylexp = 0; 650264790Sbapt 651264790Sbapt static short *yylexemes = 0; 652264790Sbapt#endif /* YYBTYACC */ 653264790Sbapt int yym, yyn, yystate, yyresult; 654264790Sbapt#if YYBTYACC 655264790Sbapt int yynewerrflag; 656264790Sbapt YYParseState *yyerrctx = NULL; 657264790Sbapt#endif /* YYBTYACC */ 658264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 659264790Sbapt YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 660264790Sbapt#endif 661264790Sbapt#if YYDEBUG 662264790Sbapt const char *yys; 663264790Sbapt 664264790Sbapt if ((yys = getenv("YYDEBUG")) != 0) 665264790Sbapt { 666264790Sbapt yyn = *yys; 667264790Sbapt if (yyn >= '0' && yyn <= '9') 668264790Sbapt yydebug = yyn - '0'; 669264790Sbapt } 670264790Sbapt if (yydebug) 671264790Sbapt fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 672264790Sbapt#endif 673264790Sbapt 674264790Sbapt#if YYBTYACC 675264790Sbapt yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 676264790Sbapt yyps->save = 0; 677264790Sbapt#endif /* YYBTYACC */ 678264790Sbapt yynerrs = 0; 679264790Sbapt yyerrflag = 0; 680264790Sbapt yychar = YYEMPTY; 681264790Sbapt yystate = 0; 682264790Sbapt 683264790Sbapt#if YYPURE 684264790Sbapt memset(&yystack, 0, sizeof(yystack)); 685264790Sbapt#endif 686264790Sbapt 687264790Sbapt if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 688264790Sbapt yystack.s_mark = yystack.s_base; 689264790Sbapt yystack.l_mark = yystack.l_base; 690264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 691264790Sbapt yystack.p_mark = yystack.p_base; 692264790Sbapt#endif 693264790Sbapt yystate = 0; 694264790Sbapt *yystack.s_mark = 0; 695264790Sbapt 696264790Sbaptyyloop: 697264790Sbapt if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 698264790Sbapt if (yychar < 0) 699264790Sbapt { 700264790Sbapt#if YYBTYACC 701264790Sbapt do { 702264790Sbapt if (yylvp < yylve) 703264790Sbapt { 704264790Sbapt /* we're currently re-reading tokens */ 705264790Sbapt yylval = *yylvp++; 706264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 707264790Sbapt yylloc = *yylpp++; 708264790Sbapt#endif 709264790Sbapt yychar = *yylexp++; 710264790Sbapt break; 711264790Sbapt } 712264790Sbapt if (yyps->save) 713264790Sbapt { 714264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 715264790Sbapt if (yylvp == yylvlim) 716264790Sbapt { /* Enlarge lexical value queue */ 717264790Sbapt int p = yylvp - yylvals; 718264790Sbapt int s = yylvlim - yylvals; 719264790Sbapt 720264790Sbapt s += YYLVQUEUEGROWTH; 721264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 722264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 723264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 724264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 725264790Sbapt#endif 726264790Sbapt yylvp = yylve = yylvals + p; 727264790Sbapt yylvlim = yylvals + s; 728264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 729264790Sbapt yylpp = yylpe = yylpsns + p; 730264790Sbapt yylplim = yylpsns + s; 731264790Sbapt#endif 732264790Sbapt yylexp = yylexemes + p; 733264790Sbapt } 734264790Sbapt *yylexp = (short) YYLEX; 735264790Sbapt *yylvp++ = yylval; 736264790Sbapt yylve++; 737264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 738264790Sbapt *yylpp++ = yylloc; 739264790Sbapt yylpe++; 740264790Sbapt#endif 741264790Sbapt yychar = *yylexp++; 742264790Sbapt break; 743264790Sbapt } 744264790Sbapt /* normal operation, no conflict encountered */ 745264790Sbapt#endif /* YYBTYACC */ 746264790Sbapt yychar = YYLEX; 747264790Sbapt#if YYBTYACC 748264790Sbapt } while (0); 749264790Sbapt#endif /* YYBTYACC */ 750264790Sbapt if (yychar < 0) yychar = YYEOF; 751264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 752264790Sbapt#if YYDEBUG 753264790Sbapt if (yydebug) 754264790Sbapt { 755264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 756264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 757264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 758264790Sbapt#ifdef YYSTYPE_TOSTRING 759264790Sbapt#if YYBTYACC 760264790Sbapt if (!yytrial) 761264790Sbapt#endif /* YYBTYACC */ 762264790Sbapt fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 763264790Sbapt#endif 764264790Sbapt fputc('\n', stderr); 765264790Sbapt } 766264790Sbapt#endif 767264790Sbapt } 768264790Sbapt#if YYBTYACC 769264790Sbapt 770264790Sbapt /* Do we have a conflict? */ 771264790Sbapt if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 772264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 773264790Sbapt { 774264790Sbapt YYINT ctry; 775264790Sbapt 776264790Sbapt if (yypath) 777264790Sbapt { 778264790Sbapt YYParseState *save; 779264790Sbapt#if YYDEBUG 780264790Sbapt if (yydebug) 781264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 782264790Sbapt YYDEBUGSTR, yydepth, yystate); 783264790Sbapt#endif 784264790Sbapt /* Switch to the next conflict context */ 785264790Sbapt save = yypath; 786264790Sbapt yypath = save->save; 787264790Sbapt save->save = NULL; 788264790Sbapt ctry = save->ctry; 789264790Sbapt if (save->state != yystate) YYABORT; 790264790Sbapt yyFreeState(save); 791264790Sbapt 792264790Sbapt } 793264790Sbapt else 794264790Sbapt { 795264790Sbapt 796264790Sbapt /* Unresolved conflict - start/continue trial parse */ 797264790Sbapt YYParseState *save; 798264790Sbapt#if YYDEBUG 799264790Sbapt if (yydebug) 800264790Sbapt { 801264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 802264790Sbapt if (yyps->save) 803264790Sbapt fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 804264790Sbapt else 805264790Sbapt fputs("Starting trial parse.\n", stderr); 806264790Sbapt } 807264790Sbapt#endif 808264790Sbapt save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 809264790Sbapt if (save == NULL) goto yyenomem; 810264790Sbapt save->save = yyps->save; 811264790Sbapt save->state = yystate; 812264790Sbapt save->errflag = yyerrflag; 813264790Sbapt save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 814264790Sbapt memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 815264790Sbapt save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 816264790Sbapt memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 817264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 818264790Sbapt save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 819264790Sbapt memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 820264790Sbapt#endif 821264790Sbapt ctry = yytable[yyn]; 822264790Sbapt if (yyctable[ctry] == -1) 823264790Sbapt { 824264790Sbapt#if YYDEBUG 825264790Sbapt if (yydebug && yychar >= YYEOF) 826264790Sbapt fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 827264790Sbapt#endif 828264790Sbapt ctry++; 829264790Sbapt } 830264790Sbapt save->ctry = ctry; 831264790Sbapt if (yyps->save == NULL) 832264790Sbapt { 833264790Sbapt /* If this is a first conflict in the stack, start saving lexemes */ 834264790Sbapt if (!yylexemes) 835264790Sbapt { 836264790Sbapt yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 837264790Sbapt if (yylexemes == NULL) goto yyenomem; 838264790Sbapt yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 839264790Sbapt if (yylvals == NULL) goto yyenomem; 840264790Sbapt yylvlim = yylvals + YYLVQUEUEGROWTH; 841264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 842264790Sbapt yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 843264790Sbapt if (yylpsns == NULL) goto yyenomem; 844264790Sbapt yylplim = yylpsns + YYLVQUEUEGROWTH; 845264790Sbapt#endif 846264790Sbapt } 847264790Sbapt if (yylvp == yylve) 848264790Sbapt { 849264790Sbapt yylvp = yylve = yylvals; 850264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 851264790Sbapt yylpp = yylpe = yylpsns; 852264790Sbapt#endif 853264790Sbapt yylexp = yylexemes; 854264790Sbapt if (yychar >= YYEOF) 855264790Sbapt { 856264790Sbapt *yylve++ = yylval; 857264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 858264790Sbapt *yylpe++ = yylloc; 859264790Sbapt#endif 860264790Sbapt *yylexp = (short) yychar; 861264790Sbapt yychar = YYEMPTY; 862264790Sbapt } 863264790Sbapt } 864264790Sbapt } 865264790Sbapt if (yychar >= YYEOF) 866264790Sbapt { 867264790Sbapt yylvp--; 868264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 869264790Sbapt yylpp--; 870264790Sbapt#endif 871264790Sbapt yylexp--; 872264790Sbapt yychar = YYEMPTY; 873264790Sbapt } 874264790Sbapt save->lexeme = yylvp - yylvals; 875264790Sbapt yyps->save = save; 876264790Sbapt } 877264790Sbapt if (yytable[yyn] == ctry) 878264790Sbapt { 879264790Sbapt#if YYDEBUG 880264790Sbapt if (yydebug) 881264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 882264790Sbapt YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 883264790Sbapt#endif 884264790Sbapt if (yychar < 0) 885264790Sbapt { 886264790Sbapt yylvp++; 887264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 888264790Sbapt yylpp++; 889264790Sbapt#endif 890264790Sbapt yylexp++; 891264790Sbapt } 892264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 893264790Sbapt goto yyoverflow; 894264790Sbapt yystate = yyctable[ctry]; 895264790Sbapt *++yystack.s_mark = (short) yystate; 896264790Sbapt *++yystack.l_mark = yylval; 897264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 898264790Sbapt *++yystack.p_mark = yylloc; 899264790Sbapt#endif 900264790Sbapt yychar = YYEMPTY; 901264790Sbapt if (yyerrflag > 0) --yyerrflag; 902264790Sbapt goto yyloop; 903264790Sbapt } 904264790Sbapt else 905264790Sbapt { 906264790Sbapt yyn = yyctable[ctry]; 907264790Sbapt goto yyreduce; 908264790Sbapt } 909264790Sbapt } /* End of code dealing with conflicts */ 910264790Sbapt#endif /* YYBTYACC */ 911264790Sbapt if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 912264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 913264790Sbapt { 914264790Sbapt#if YYDEBUG 915264790Sbapt if (yydebug) 916264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 917264790Sbapt YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 918264790Sbapt#endif 919264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 920264790Sbapt yystate = yytable[yyn]; 921264790Sbapt *++yystack.s_mark = yytable[yyn]; 922264790Sbapt *++yystack.l_mark = yylval; 923264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 924264790Sbapt *++yystack.p_mark = yylloc; 925264790Sbapt#endif 926264790Sbapt yychar = YYEMPTY; 927264790Sbapt if (yyerrflag > 0) --yyerrflag; 928264790Sbapt goto yyloop; 929264790Sbapt } 930264790Sbapt if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 931264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 932264790Sbapt { 933264790Sbapt yyn = yytable[yyn]; 934264790Sbapt goto yyreduce; 935264790Sbapt } 936264790Sbapt if (yyerrflag != 0) goto yyinrecovery; 937264790Sbapt#if YYBTYACC 938264790Sbapt 939264790Sbapt yynewerrflag = 1; 940264790Sbapt goto yyerrhandler; 941264790Sbapt goto yyerrlab; 942264790Sbapt 943264790Sbaptyyerrlab: 944264790Sbapt yynewerrflag = 0; 945264790Sbaptyyerrhandler: 946264790Sbapt while (yyps->save) 947264790Sbapt { 948264790Sbapt int ctry; 949264790Sbapt YYParseState *save = yyps->save; 950264790Sbapt#if YYDEBUG 951264790Sbapt if (yydebug) 952264790Sbapt fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 953264790Sbapt YYDEBUGSTR, yydepth, yystate, yyps->save->state, 954264790Sbapt (int)(yylvp - yylvals - yyps->save->lexeme)); 955264790Sbapt#endif 956264790Sbapt /* Memorize most forward-looking error state in case it's really an error. */ 957264790Sbapt if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 958264790Sbapt { 959264790Sbapt /* Free old saved error context state */ 960264790Sbapt if (yyerrctx) yyFreeState(yyerrctx); 961264790Sbapt /* Create and fill out new saved error context state */ 962264790Sbapt yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 963264790Sbapt if (yyerrctx == NULL) goto yyenomem; 964264790Sbapt yyerrctx->save = yyps->save; 965264790Sbapt yyerrctx->state = yystate; 966264790Sbapt yyerrctx->errflag = yyerrflag; 967264790Sbapt yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 968264790Sbapt memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 969264790Sbapt yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 970264790Sbapt memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 971264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 972264790Sbapt yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 973264790Sbapt memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 974264790Sbapt#endif 975264790Sbapt yyerrctx->lexeme = yylvp - yylvals; 976264790Sbapt } 977264790Sbapt yylvp = yylvals + save->lexeme; 978264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 979264790Sbapt yylpp = yylpsns + save->lexeme; 980264790Sbapt#endif 981264790Sbapt yylexp = yylexemes + save->lexeme; 982264790Sbapt yychar = YYEMPTY; 983264790Sbapt yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 984264790Sbapt memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 985264790Sbapt yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 986264790Sbapt memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 987264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 988264790Sbapt yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 989264790Sbapt memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 990264790Sbapt#endif 991264790Sbapt ctry = ++save->ctry; 992264790Sbapt yystate = save->state; 993264790Sbapt /* We tried shift, try reduce now */ 994264790Sbapt if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 995264790Sbapt yyps->save = save->save; 996264790Sbapt save->save = NULL; 997264790Sbapt yyFreeState(save); 998264790Sbapt 999264790Sbapt /* Nothing left on the stack -- error */ 1000264790Sbapt if (!yyps->save) 1001264790Sbapt { 1002264790Sbapt#if YYDEBUG 1003264790Sbapt if (yydebug) 1004264790Sbapt fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1005264790Sbapt YYPREFIX, yydepth); 1006264790Sbapt#endif 1007264790Sbapt /* Restore state as it was in the most forward-advanced error */ 1008264790Sbapt yylvp = yylvals + yyerrctx->lexeme; 1009264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1010264790Sbapt yylpp = yylpsns + yyerrctx->lexeme; 1011264790Sbapt#endif 1012264790Sbapt yylexp = yylexemes + yyerrctx->lexeme; 1013264790Sbapt yychar = yylexp[-1]; 1014264790Sbapt yylval = yylvp[-1]; 1015264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1016264790Sbapt yylloc = yylpp[-1]; 1017264790Sbapt#endif 1018264790Sbapt yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1019264790Sbapt memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1020264790Sbapt yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1021264790Sbapt memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1022264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1023264790Sbapt yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1024264790Sbapt memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1025264790Sbapt#endif 1026264790Sbapt yystate = yyerrctx->state; 1027264790Sbapt yyFreeState(yyerrctx); 1028264790Sbapt yyerrctx = NULL; 1029264790Sbapt } 1030264790Sbapt yynewerrflag = 1; 1031264790Sbapt } 1032264790Sbapt if (yynewerrflag == 0) goto yyinrecovery; 1033264790Sbapt#endif /* YYBTYACC */ 1034264790Sbapt 1035264790Sbapt YYERROR_CALL("syntax error"); 1036264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1037264790Sbapt yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1038264790Sbapt#endif 1039264790Sbapt 1040264790Sbapt#if !YYBTYACC 1041264790Sbapt goto yyerrlab; 1042264790Sbaptyyerrlab: 1043264790Sbapt#endif 1044264790Sbapt ++yynerrs; 1045264790Sbapt 1046264790Sbaptyyinrecovery: 1047264790Sbapt if (yyerrflag < 3) 1048264790Sbapt { 1049264790Sbapt yyerrflag = 3; 1050264790Sbapt for (;;) 1051264790Sbapt { 1052264790Sbapt if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1053264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1054264790Sbapt { 1055264790Sbapt#if YYDEBUG 1056264790Sbapt if (yydebug) 1057264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1058264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1059264790Sbapt#endif 1060264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1061264790Sbapt yystate = yytable[yyn]; 1062264790Sbapt *++yystack.s_mark = yytable[yyn]; 1063264790Sbapt *++yystack.l_mark = yylval; 1064264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1065264790Sbapt /* lookahead position is error end position */ 1066264790Sbapt yyerror_loc_range[1] = yylloc; 1067264790Sbapt YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1068264790Sbapt *++yystack.p_mark = yyloc; 1069264790Sbapt#endif 1070264790Sbapt goto yyloop; 1071264790Sbapt } 1072264790Sbapt else 1073264790Sbapt { 1074264790Sbapt#if YYDEBUG 1075264790Sbapt if (yydebug) 1076264790Sbapt fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1077264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark); 1078264790Sbapt#endif 1079264790Sbapt if (yystack.s_mark <= yystack.s_base) goto yyabort; 1080264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1081264790Sbapt /* the current TOS position is the error start position */ 1082264790Sbapt yyerror_loc_range[0] = *yystack.p_mark; 1083264790Sbapt#endif 1084264790Sbapt#if defined(YYDESTRUCT_CALL) 1085264790Sbapt#if YYBTYACC 1086264790Sbapt if (!yytrial) 1087264790Sbapt#endif /* YYBTYACC */ 1088264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1089264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1090264790Sbapt yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1091264790Sbapt#else 1092264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1093264790Sbapt yystos[*yystack.s_mark], yystack.l_mark); 1094264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1095264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1096264790Sbapt --yystack.s_mark; 1097264790Sbapt --yystack.l_mark; 1098264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1099264790Sbapt --yystack.p_mark; 1100264790Sbapt#endif 1101264790Sbapt } 1102264790Sbapt } 1103264790Sbapt } 1104264790Sbapt else 1105264790Sbapt { 1106264790Sbapt if (yychar == YYEOF) goto yyabort; 1107264790Sbapt#if YYDEBUG 1108264790Sbapt if (yydebug) 1109264790Sbapt { 1110264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1111264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1112264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 1113264790Sbapt } 1114264790Sbapt#endif 1115264790Sbapt#if defined(YYDESTRUCT_CALL) 1116264790Sbapt#if YYBTYACC 1117264790Sbapt if (!yytrial) 1118264790Sbapt#endif /* YYBTYACC */ 1119264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1120264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1121264790Sbapt#else 1122264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1123264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1124264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1125264790Sbapt yychar = YYEMPTY; 1126264790Sbapt goto yyloop; 1127264790Sbapt } 1128264790Sbapt 1129264790Sbaptyyreduce: 1130264790Sbapt yym = yylen[yyn]; 1131264790Sbapt#if YYDEBUG 1132264790Sbapt if (yydebug) 1133264790Sbapt { 1134264790Sbapt fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1135264790Sbapt YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1136264790Sbapt#ifdef YYSTYPE_TOSTRING 1137264790Sbapt#if YYBTYACC 1138264790Sbapt if (!yytrial) 1139264790Sbapt#endif /* YYBTYACC */ 1140264790Sbapt if (yym > 0) 1141264790Sbapt { 1142264790Sbapt int i; 1143264790Sbapt fputc('<', stderr); 1144264790Sbapt for (i = yym; i > 0; i--) 1145264790Sbapt { 1146264790Sbapt if (i != yym) fputs(", ", stderr); 1147264790Sbapt fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1148264790Sbapt yystack.l_mark[1-i]), stderr); 1149264790Sbapt } 1150264790Sbapt fputc('>', stderr); 1151264790Sbapt } 1152264790Sbapt#endif 1153264790Sbapt fputc('\n', stderr); 1154264790Sbapt } 1155264790Sbapt#endif 1156264790Sbapt if (yym > 0) 1157264790Sbapt yyval = yystack.l_mark[1-yym]; 1158264790Sbapt else 1159264790Sbapt memset(&yyval, 0, sizeof yyval); 1160264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1161264790Sbapt 1162264790Sbapt /* Perform position reduction */ 1163264790Sbapt memset(&yyloc, 0, sizeof(yyloc)); 1164264790Sbapt#if YYBTYACC 1165264790Sbapt if (!yytrial) 1166264790Sbapt#endif /* YYBTYACC */ 1167264790Sbapt { 1168264790Sbapt YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1169264790Sbapt /* just in case YYERROR is invoked within the action, save 1170264790Sbapt the start of the rhs as the error start position */ 1171264790Sbapt yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1172264790Sbapt } 1173264790Sbapt#endif 1174264790Sbapt 1175264790Sbapt switch (yyn) 1176264790Sbapt { 1177264790Sbaptcase 3: 1178264790Sbapt#line 66 "ok_syntax1.y" 1179264790Sbapt { yyerrok ; } 1180264790Sbaptbreak; 1181264790Sbaptcase 4: 1182264790Sbapt#line 70 "ok_syntax1.y" 1183264790Sbapt { printf("%d\n",yystack.l_mark[0].ival);} 1184264790Sbaptbreak; 1185264790Sbaptcase 5: 1186264790Sbapt#line 72 "ok_syntax1.y" 1187264790Sbapt { regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; } 1188264790Sbaptbreak; 1189264790Sbaptcase 6: 1190264790Sbapt#line 76 "ok_syntax1.y" 1191264790Sbapt { yyval.ival = yystack.l_mark[-1].ival; } 1192264790Sbaptbreak; 1193264790Sbaptcase 7: 1194264790Sbapt#line 78 "ok_syntax1.y" 1195264790Sbapt { yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; } 1196264790Sbaptbreak; 1197264790Sbaptcase 8: 1198264790Sbapt#line 80 "ok_syntax1.y" 1199264790Sbapt { yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; } 1200264790Sbaptbreak; 1201264790Sbaptcase 9: 1202264790Sbapt#line 82 "ok_syntax1.y" 1203264790Sbapt { yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; } 1204264790Sbaptbreak; 1205264790Sbaptcase 10: 1206264790Sbapt#line 84 "ok_syntax1.y" 1207264790Sbapt { yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; } 1208264790Sbaptbreak; 1209264790Sbaptcase 11: 1210264790Sbapt#line 86 "ok_syntax1.y" 1211264790Sbapt { yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; } 1212264790Sbaptbreak; 1213264790Sbaptcase 12: 1214264790Sbapt#line 88 "ok_syntax1.y" 1215264790Sbapt { yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; } 1216264790Sbaptbreak; 1217264790Sbaptcase 13: 1218264790Sbapt#line 90 "ok_syntax1.y" 1219264790Sbapt { yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; } 1220264790Sbaptbreak; 1221264790Sbaptcase 14: 1222264790Sbapt#line 92 "ok_syntax1.y" 1223264790Sbapt { yyval.ival = - yystack.l_mark[0].ival; } 1224264790Sbaptbreak; 1225264790Sbaptcase 15: 1226264790Sbapt#line 94 "ok_syntax1.y" 1227264790Sbapt { yyval.ival = regs[yystack.l_mark[0].ival]; } 1228264790Sbaptbreak; 1229264790Sbaptcase 17: 1230264790Sbapt#line 99 "ok_syntax1.y" 1231264790Sbapt { yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; } 1232264790Sbaptbreak; 1233264790Sbaptcase 18: 1234264790Sbapt#line 101 "ok_syntax1.y" 1235264790Sbapt { yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; } 1236264790Sbaptbreak; 1237264790Sbapt#line 1238 "ok_syntax1.tab.c" 1238264790Sbapt default: 1239264790Sbapt break; 1240264790Sbapt } 1241264790Sbapt yystack.s_mark -= yym; 1242264790Sbapt yystate = *yystack.s_mark; 1243264790Sbapt yystack.l_mark -= yym; 1244264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1245264790Sbapt yystack.p_mark -= yym; 1246264790Sbapt#endif 1247264790Sbapt yym = yylhs[yyn]; 1248264790Sbapt if (yystate == 0 && yym == 0) 1249264790Sbapt { 1250264790Sbapt#if YYDEBUG 1251264790Sbapt if (yydebug) 1252264790Sbapt { 1253264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1254264790Sbapt#ifdef YYSTYPE_TOSTRING 1255264790Sbapt#if YYBTYACC 1256264790Sbapt if (!yytrial) 1257264790Sbapt#endif /* YYBTYACC */ 1258264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1259264790Sbapt#endif 1260264790Sbapt fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1261264790Sbapt } 1262264790Sbapt#endif 1263264790Sbapt yystate = YYFINAL; 1264264790Sbapt *++yystack.s_mark = YYFINAL; 1265264790Sbapt *++yystack.l_mark = yyval; 1266264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1267264790Sbapt *++yystack.p_mark = yyloc; 1268264790Sbapt#endif 1269264790Sbapt if (yychar < 0) 1270264790Sbapt { 1271264790Sbapt#if YYBTYACC 1272264790Sbapt do { 1273264790Sbapt if (yylvp < yylve) 1274264790Sbapt { 1275264790Sbapt /* we're currently re-reading tokens */ 1276264790Sbapt yylval = *yylvp++; 1277264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1278264790Sbapt yylloc = *yylpp++; 1279264790Sbapt#endif 1280264790Sbapt yychar = *yylexp++; 1281264790Sbapt break; 1282264790Sbapt } 1283264790Sbapt if (yyps->save) 1284264790Sbapt { 1285264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 1286264790Sbapt if (yylvp == yylvlim) 1287264790Sbapt { /* Enlarge lexical value queue */ 1288264790Sbapt int p = yylvp - yylvals; 1289264790Sbapt int s = yylvlim - yylvals; 1290264790Sbapt 1291264790Sbapt s += YYLVQUEUEGROWTH; 1292264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1293264790Sbapt goto yyenomem; 1294264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1295264790Sbapt goto yyenomem; 1296264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1297264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1298264790Sbapt goto yyenomem; 1299264790Sbapt#endif 1300264790Sbapt yylvp = yylve = yylvals + p; 1301264790Sbapt yylvlim = yylvals + s; 1302264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1303264790Sbapt yylpp = yylpe = yylpsns + p; 1304264790Sbapt yylplim = yylpsns + s; 1305264790Sbapt#endif 1306264790Sbapt yylexp = yylexemes + p; 1307264790Sbapt } 1308264790Sbapt *yylexp = (short) YYLEX; 1309264790Sbapt *yylvp++ = yylval; 1310264790Sbapt yylve++; 1311264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1312264790Sbapt *yylpp++ = yylloc; 1313264790Sbapt yylpe++; 1314264790Sbapt#endif 1315264790Sbapt yychar = *yylexp++; 1316264790Sbapt break; 1317264790Sbapt } 1318264790Sbapt /* normal operation, no conflict encountered */ 1319264790Sbapt#endif /* YYBTYACC */ 1320264790Sbapt yychar = YYLEX; 1321264790Sbapt#if YYBTYACC 1322264790Sbapt } while (0); 1323264790Sbapt#endif /* YYBTYACC */ 1324264790Sbapt if (yychar < 0) yychar = YYEOF; 1325264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1326264790Sbapt#if YYDEBUG 1327264790Sbapt if (yydebug) 1328264790Sbapt { 1329264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1330264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1331264790Sbapt YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1332264790Sbapt } 1333264790Sbapt#endif 1334264790Sbapt } 1335264790Sbapt if (yychar == YYEOF) goto yyaccept; 1336264790Sbapt goto yyloop; 1337264790Sbapt } 1338264790Sbapt if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1339264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1340264790Sbapt yystate = yytable[yyn]; 1341264790Sbapt else 1342264790Sbapt yystate = yydgoto[yym]; 1343264790Sbapt#if YYDEBUG 1344264790Sbapt if (yydebug) 1345264790Sbapt { 1346264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1347264790Sbapt#ifdef YYSTYPE_TOSTRING 1348264790Sbapt#if YYBTYACC 1349264790Sbapt if (!yytrial) 1350264790Sbapt#endif /* YYBTYACC */ 1351264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1352264790Sbapt#endif 1353264790Sbapt fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1354264790Sbapt } 1355264790Sbapt#endif 1356264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1357264790Sbapt *++yystack.s_mark = (short) yystate; 1358264790Sbapt *++yystack.l_mark = yyval; 1359264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1360264790Sbapt *++yystack.p_mark = yyloc; 1361264790Sbapt#endif 1362264790Sbapt goto yyloop; 1363264790Sbapt#if YYBTYACC 1364264790Sbapt 1365264790Sbapt /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1366264790Sbaptyyvalid: 1367264790Sbapt if (yypath) YYABORT; 1368264790Sbapt while (yyps->save) 1369264790Sbapt { 1370264790Sbapt YYParseState *save = yyps->save; 1371264790Sbapt yyps->save = save->save; 1372264790Sbapt save->save = yypath; 1373264790Sbapt yypath = save; 1374264790Sbapt } 1375264790Sbapt#if YYDEBUG 1376264790Sbapt if (yydebug) 1377264790Sbapt fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1378264790Sbapt YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1379264790Sbapt#endif 1380264790Sbapt if (yyerrctx) 1381264790Sbapt { 1382264790Sbapt yyFreeState(yyerrctx); 1383264790Sbapt yyerrctx = NULL; 1384264790Sbapt } 1385264790Sbapt yylvp = yylvals + yypath->lexeme; 1386264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1387264790Sbapt yylpp = yylpsns + yypath->lexeme; 1388264790Sbapt#endif 1389264790Sbapt yylexp = yylexemes + yypath->lexeme; 1390264790Sbapt yychar = YYEMPTY; 1391264790Sbapt yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1392264790Sbapt memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1393264790Sbapt yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1394264790Sbapt memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1395264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1396264790Sbapt yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1397264790Sbapt memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1398264790Sbapt#endif 1399264790Sbapt yystate = yypath->state; 1400264790Sbapt goto yyloop; 1401264790Sbapt#endif /* YYBTYACC */ 1402264790Sbapt 1403264790Sbaptyyoverflow: 1404264790Sbapt YYERROR_CALL("yacc stack overflow"); 1405264790Sbapt#if YYBTYACC 1406264790Sbapt goto yyabort_nomem; 1407264790Sbaptyyenomem: 1408264790Sbapt YYERROR_CALL("memory exhausted"); 1409264790Sbaptyyabort_nomem: 1410264790Sbapt#endif /* YYBTYACC */ 1411264790Sbapt yyresult = 2; 1412264790Sbapt goto yyreturn; 1413264790Sbapt 1414264790Sbaptyyabort: 1415264790Sbapt yyresult = 1; 1416264790Sbapt goto yyreturn; 1417264790Sbapt 1418264790Sbaptyyaccept: 1419264790Sbapt#if YYBTYACC 1420264790Sbapt if (yyps->save) goto yyvalid; 1421264790Sbapt#endif /* YYBTYACC */ 1422264790Sbapt yyresult = 0; 1423264790Sbapt 1424264790Sbaptyyreturn: 1425264790Sbapt#if defined(YYDESTRUCT_CALL) 1426264790Sbapt if (yychar != YYEOF && yychar != YYEMPTY) 1427264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1428264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1429264790Sbapt#else 1430264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1431264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1432264790Sbapt 1433264790Sbapt { 1434264790Sbapt YYSTYPE *pv; 1435264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1436264790Sbapt YYLTYPE *pp; 1437264790Sbapt 1438264790Sbapt for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1439264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1440264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1441264790Sbapt#else 1442264790Sbapt for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1443264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1444264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1445264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1446264790Sbapt } 1447264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1448264790Sbapt 1449264790Sbapt#if YYBTYACC 1450264790Sbapt if (yyerrctx) 1451264790Sbapt { 1452264790Sbapt yyFreeState(yyerrctx); 1453264790Sbapt yyerrctx = NULL; 1454264790Sbapt } 1455264790Sbapt while (yyps) 1456264790Sbapt { 1457264790Sbapt YYParseState *save = yyps; 1458264790Sbapt yyps = save->save; 1459264790Sbapt save->save = NULL; 1460264790Sbapt yyFreeState(save); 1461264790Sbapt } 1462264790Sbapt while (yypath) 1463264790Sbapt { 1464264790Sbapt YYParseState *save = yypath; 1465264790Sbapt yypath = save->save; 1466264790Sbapt save->save = NULL; 1467264790Sbapt yyFreeState(save); 1468264790Sbapt } 1469264790Sbapt#endif /* YYBTYACC */ 1470264790Sbapt yyfreestack(&yystack); 1471264790Sbapt return (yyresult); 1472264790Sbapt} 1473