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 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 158272955Srodrigc# 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 170272955Srodrigc# 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 176272955Srodrigc#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}; 297272955Srodrigc#if YYBTYACC 298272955Srodrigcstatic const YYINT ok_syntax1_ctable[] = { -1, 299272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 300272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 301272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 302272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 303272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 304272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 305272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 306272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 307272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 308272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 309272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 310272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 311272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 312272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 313272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 314272955Srodrigc -1, -1, -1, -1, -1, -1, -1, -1, -1, -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, 321272955Srodrigc}; 322272955Srodrigc#endif 323264790Sbapt#define YYFINAL 1 324264790Sbapt#ifndef YYDEBUG 325264790Sbapt#define YYDEBUG 0 326264790Sbapt#endif 327264790Sbapt#define YYMAXTOKEN 273 328264790Sbapt#define YYUNDFTOKEN 279 329264790Sbapt#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 330264790Sbapt#if YYDEBUG 331264790Sbaptstatic const char *const ok_syntax1_name[] = { 332264790Sbapt 333264790Sbapt"$end",0,0,0,0,0,0,"'\\a'","'\\b'","'\\t'","'\\n'","'\\v'","'\\f'","'\\r'",0,0, 334264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'#'",0,"'%'","'&'",0,"'('","')'","'*'", 335264790Sbapt"'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,0,"'='",0,0,"'@'",0,0,0,0,0,0,0,0, 336264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 337264790Sbapt0,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, 338264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 339264790Sbapt0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 340264790Sbapt0,0,0,0,0,0,0,0,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'", 341264790Sbapt"error","DIGIT","LETTER","OCT1","HEX1","HEX2","HEX3","STR1", 342264790Sbapt"\"\\177\\177\\\\\\n\"","STR2","BELL","BS","NL","LF","CR","TAB","VT","UMINUS", 343264790Sbapt"$accept","list","stat","expr","number","illegal-symbol", 344264790Sbapt}; 345264790Sbaptstatic const char *const ok_syntax1_rule[] = { 346264790Sbapt"$accept : list", 347264790Sbapt"list :", 348264790Sbapt"list : list stat '\\n'", 349264790Sbapt"list : list error '\\n'", 350264790Sbapt"stat : expr", 351264790Sbapt"stat : LETTER '=' expr", 352264790Sbapt"expr : '(' expr ')'", 353264790Sbapt"expr : expr '+' expr", 354264790Sbapt"expr : expr '-' expr", 355264790Sbapt"expr : expr '*' expr", 356264790Sbapt"expr : expr '/' expr", 357264790Sbapt"expr : expr '%' expr", 358264790Sbapt"expr : expr '&' expr", 359264790Sbapt"expr : expr '|' expr", 360264790Sbapt"expr : '-' expr", 361264790Sbapt"expr : LETTER", 362264790Sbapt"expr : number", 363264790Sbapt"number : DIGIT", 364264790Sbapt"number : number DIGIT", 365264790Sbapt 366264790Sbapt}; 367264790Sbapt#endif 368264790Sbapt 369264790Sbaptint yydebug; 370264790Sbaptint yynerrs; 371264790Sbapt 372264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 373264790Sbapt#ifndef YYLLOC_DEFAULT 374264790Sbapt#define YYLLOC_DEFAULT(loc, rhs, n) \ 375264790Sbaptdo \ 376264790Sbapt{ \ 377264790Sbapt if (n == 0) \ 378264790Sbapt { \ 379264790Sbapt (loc).first_line = ((rhs)[-1]).last_line; \ 380264790Sbapt (loc).first_column = ((rhs)[-1]).last_column; \ 381264790Sbapt (loc).last_line = ((rhs)[-1]).last_line; \ 382264790Sbapt (loc).last_column = ((rhs)[-1]).last_column; \ 383264790Sbapt } \ 384264790Sbapt else \ 385264790Sbapt { \ 386264790Sbapt (loc).first_line = ((rhs)[ 0 ]).first_line; \ 387264790Sbapt (loc).first_column = ((rhs)[ 0 ]).first_column; \ 388264790Sbapt (loc).last_line = ((rhs)[n-1]).last_line; \ 389264790Sbapt (loc).last_column = ((rhs)[n-1]).last_column; \ 390264790Sbapt } \ 391264790Sbapt} while (0) 392264790Sbapt#endif /* YYLLOC_DEFAULT */ 393264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 394264790Sbapt#if YYBTYACC 395264790Sbapt 396264790Sbapt#ifndef YYLVQUEUEGROWTH 397264790Sbapt#define YYLVQUEUEGROWTH 32 398264790Sbapt#endif 399264790Sbapt#endif /* YYBTYACC */ 400264790Sbapt 401264790Sbapt/* define the initial stack-sizes */ 402264790Sbapt#ifdef YYSTACKSIZE 403264790Sbapt#undef YYMAXDEPTH 404264790Sbapt#define YYMAXDEPTH YYSTACKSIZE 405264790Sbapt#else 406264790Sbapt#ifdef YYMAXDEPTH 407264790Sbapt#define YYSTACKSIZE YYMAXDEPTH 408264790Sbapt#else 409264790Sbapt#define YYSTACKSIZE 10000 410264790Sbapt#define YYMAXDEPTH 10000 411264790Sbapt#endif 412264790Sbapt#endif 413264790Sbapt 414264790Sbapt#ifndef YYINITSTACKSIZE 415264790Sbapt#define YYINITSTACKSIZE 200 416264790Sbapt#endif 417264790Sbapt 418264790Sbapttypedef struct { 419264790Sbapt unsigned stacksize; 420264790Sbapt short *s_base; 421264790Sbapt short *s_mark; 422264790Sbapt short *s_last; 423264790Sbapt YYSTYPE *l_base; 424264790Sbapt YYSTYPE *l_mark; 425264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 426264790Sbapt YYLTYPE *p_base; 427264790Sbapt YYLTYPE *p_mark; 428264790Sbapt#endif 429264790Sbapt} YYSTACKDATA; 430264790Sbapt#if YYBTYACC 431264790Sbapt 432264790Sbaptstruct YYParseState_s 433264790Sbapt{ 434264790Sbapt struct YYParseState_s *save; /* Previously saved parser state */ 435264790Sbapt YYSTACKDATA yystack; /* saved parser stack */ 436264790Sbapt int state; /* saved parser state */ 437264790Sbapt int errflag; /* saved error recovery status */ 438264790Sbapt int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 439264790Sbapt YYINT ctry; /* saved index in yyctable[] for this conflict */ 440264790Sbapt}; 441264790Sbapttypedef struct YYParseState_s YYParseState; 442264790Sbapt#endif /* YYBTYACC */ 443264790Sbapt#line 104 "ok_syntax1.y" 444264790Sbapt /* start of programs */ 445264790Sbapt 446264790Sbapt#ifdef YYBYACC 447264790Sbaptextern int YYLEX_DECL(); 448264790Sbapt#endif 449264790Sbapt 450264790Sbaptint 451264790Sbaptmain (void) 452264790Sbapt{ 453264790Sbapt int regs[26]; 454264790Sbapt int base = 10; 455264790Sbapt 456264790Sbapt while(!feof(stdin)) { 457264790Sbapt yyparse(regs, &base); 458264790Sbapt } 459264790Sbapt return 0; 460264790Sbapt} 461264790Sbapt 462264790Sbapt#define UNUSED(x) ((void)(x)) 463264790Sbapt 464264790Sbaptstatic void 465264790SbaptYYERROR_DECL() 466264790Sbapt{ 467264790Sbapt UNUSED(regs); /* %parse-param regs is not actually used here */ 468264790Sbapt UNUSED(base); /* %parse-param base is not actually used here */ 469264790Sbapt fprintf(stderr, "%s\n", s); 470264790Sbapt} 471264790Sbapt 472264790Sbaptint 473264790SbaptYYLEX_DECL() 474264790Sbapt{ 475264790Sbapt /* lexical analysis routine */ 476264790Sbapt /* returns LETTER for a lower case letter, yylval = 0 through 25 */ 477264790Sbapt /* return DIGIT for a digit, yylval = 0 through 9 */ 478264790Sbapt /* all other characters are returned immediately */ 479264790Sbapt 480264790Sbapt int c; 481264790Sbapt 482264790Sbapt while( (c=getchar()) == ' ' ) { /* skip blanks */ } 483264790Sbapt 484264790Sbapt /* c is now nonblank */ 485264790Sbapt 486264790Sbapt if( islower( c )) { 487264790Sbapt yylval->ival = (c - 'a'); 488264790Sbapt return ( LETTER ); 489264790Sbapt } 490264790Sbapt if( isdigit( c )) { 491264790Sbapt yylval->ival = (c - '0') % (*base); 492264790Sbapt return ( DIGIT ); 493264790Sbapt } 494264790Sbapt return( c ); 495264790Sbapt} 496272955Srodrigc#line 497 "ok_syntax1.tab.c" 497264790Sbapt 498264790Sbapt/* For use in generated program */ 499264790Sbapt#define yydepth (int)(yystack.s_mark - yystack.s_base) 500264790Sbapt#if YYBTYACC 501264790Sbapt#define yytrial (yyps->save) 502264790Sbapt#endif /* YYBTYACC */ 503264790Sbapt 504264790Sbapt#if YYDEBUG 505272955Srodrigc#include <stdio.h> /* needed for printf */ 506264790Sbapt#endif 507264790Sbapt 508272955Srodrigc#include <stdlib.h> /* needed for malloc, etc */ 509272955Srodrigc#include <string.h> /* needed for memset */ 510264790Sbapt 511264790Sbapt/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 512264790Sbaptstatic int yygrowstack(YYSTACKDATA *data) 513264790Sbapt{ 514264790Sbapt int i; 515264790Sbapt unsigned newsize; 516264790Sbapt short *newss; 517264790Sbapt YYSTYPE *newvs; 518264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 519264790Sbapt YYLTYPE *newps; 520264790Sbapt#endif 521264790Sbapt 522264790Sbapt if ((newsize = data->stacksize) == 0) 523264790Sbapt newsize = YYINITSTACKSIZE; 524264790Sbapt else if (newsize >= YYMAXDEPTH) 525264790Sbapt return YYENOMEM; 526264790Sbapt else if ((newsize *= 2) > YYMAXDEPTH) 527264790Sbapt newsize = YYMAXDEPTH; 528264790Sbapt 529264790Sbapt i = (int) (data->s_mark - data->s_base); 530264790Sbapt newss = (short *)realloc(data->s_base, newsize * sizeof(*newss)); 531264790Sbapt if (newss == 0) 532264790Sbapt return YYENOMEM; 533264790Sbapt 534264790Sbapt data->s_base = newss; 535264790Sbapt data->s_mark = newss + i; 536264790Sbapt 537264790Sbapt newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 538264790Sbapt if (newvs == 0) 539264790Sbapt return YYENOMEM; 540264790Sbapt 541264790Sbapt data->l_base = newvs; 542264790Sbapt data->l_mark = newvs + i; 543264790Sbapt 544264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 545264790Sbapt newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 546264790Sbapt if (newps == 0) 547264790Sbapt return YYENOMEM; 548264790Sbapt 549264790Sbapt data->p_base = newps; 550264790Sbapt data->p_mark = newps + i; 551264790Sbapt#endif 552264790Sbapt 553264790Sbapt data->stacksize = newsize; 554264790Sbapt data->s_last = data->s_base + newsize - 1; 555264790Sbapt 556264790Sbapt#if YYDEBUG 557264790Sbapt if (yydebug) 558264790Sbapt fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 559264790Sbapt#endif 560264790Sbapt return 0; 561264790Sbapt} 562264790Sbapt 563264790Sbapt#if YYPURE || defined(YY_NO_LEAKS) 564264790Sbaptstatic void yyfreestack(YYSTACKDATA *data) 565264790Sbapt{ 566264790Sbapt free(data->s_base); 567264790Sbapt free(data->l_base); 568264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 569264790Sbapt free(data->p_base); 570264790Sbapt#endif 571264790Sbapt memset(data, 0, sizeof(*data)); 572264790Sbapt} 573264790Sbapt#else 574264790Sbapt#define yyfreestack(data) /* nothing */ 575264790Sbapt#endif /* YYPURE || defined(YY_NO_LEAKS) */ 576264790Sbapt#if YYBTYACC 577264790Sbapt 578264790Sbaptstatic YYParseState * 579264790SbaptyyNewState(unsigned size) 580264790Sbapt{ 581264790Sbapt YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 582264790Sbapt if (p == NULL) return NULL; 583264790Sbapt 584264790Sbapt p->yystack.stacksize = size; 585264790Sbapt if (size == 0) 586264790Sbapt { 587264790Sbapt p->yystack.s_base = NULL; 588264790Sbapt p->yystack.l_base = NULL; 589264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 590264790Sbapt p->yystack.p_base = NULL; 591264790Sbapt#endif 592264790Sbapt return p; 593264790Sbapt } 594264790Sbapt p->yystack.s_base = (short *) malloc(size * sizeof(short)); 595264790Sbapt if (p->yystack.s_base == NULL) return NULL; 596264790Sbapt p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 597264790Sbapt if (p->yystack.l_base == NULL) return NULL; 598264790Sbapt memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 599264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 600264790Sbapt p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 601264790Sbapt if (p->yystack.p_base == NULL) return NULL; 602264790Sbapt memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 603264790Sbapt#endif 604264790Sbapt 605264790Sbapt return p; 606264790Sbapt} 607264790Sbapt 608264790Sbaptstatic void 609264790SbaptyyFreeState(YYParseState *p) 610264790Sbapt{ 611264790Sbapt yyfreestack(&p->yystack); 612264790Sbapt free(p); 613264790Sbapt} 614264790Sbapt#endif /* YYBTYACC */ 615264790Sbapt 616264790Sbapt#define YYABORT goto yyabort 617264790Sbapt#define YYREJECT goto yyabort 618264790Sbapt#define YYACCEPT goto yyaccept 619264790Sbapt#define YYERROR goto yyerrlab 620264790Sbapt#if YYBTYACC 621264790Sbapt#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 622264790Sbapt#define YYVALID_NESTED do { if (yyps->save && \ 623264790Sbapt yyps->save->save == 0) goto yyvalid; } while(0) 624264790Sbapt#endif /* YYBTYACC */ 625264790Sbapt 626264790Sbaptint 627264790SbaptYYPARSE_DECL() 628264790Sbapt{ 629264790Sbapt int yyerrflag; 630264790Sbapt int yychar; 631264790Sbapt YYSTYPE yyval; 632264790Sbapt YYSTYPE yylval; 633264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 634264790Sbapt YYLTYPE yyloc; /* position returned by actions */ 635264790Sbapt YYLTYPE yylloc; /* position from the lexer */ 636264790Sbapt#endif 637264790Sbapt 638264790Sbapt /* variables for the parser stack */ 639264790Sbapt YYSTACKDATA yystack; 640264790Sbapt#if YYBTYACC 641264790Sbapt 642264790Sbapt /* Current parser state */ 643264790Sbapt static YYParseState *yyps = 0; 644264790Sbapt 645264790Sbapt /* yypath != NULL: do the full parse, starting at *yypath parser state. */ 646264790Sbapt static YYParseState *yypath = 0; 647264790Sbapt 648264790Sbapt /* Base of the lexical value queue */ 649264790Sbapt static YYSTYPE *yylvals = 0; 650264790Sbapt 651264790Sbapt /* Current position at lexical value queue */ 652264790Sbapt static YYSTYPE *yylvp = 0; 653264790Sbapt 654264790Sbapt /* End position of lexical value queue */ 655264790Sbapt static YYSTYPE *yylve = 0; 656264790Sbapt 657264790Sbapt /* The last allocated position at the lexical value queue */ 658264790Sbapt static YYSTYPE *yylvlim = 0; 659264790Sbapt 660264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 661264790Sbapt /* Base of the lexical position queue */ 662264790Sbapt static YYLTYPE *yylpsns = 0; 663264790Sbapt 664264790Sbapt /* Current position at lexical position queue */ 665264790Sbapt static YYLTYPE *yylpp = 0; 666264790Sbapt 667264790Sbapt /* End position of lexical position queue */ 668264790Sbapt static YYLTYPE *yylpe = 0; 669264790Sbapt 670264790Sbapt /* The last allocated position at the lexical position queue */ 671264790Sbapt static YYLTYPE *yylplim = 0; 672264790Sbapt#endif 673264790Sbapt 674264790Sbapt /* Current position at lexical token queue */ 675264790Sbapt static short *yylexp = 0; 676264790Sbapt 677264790Sbapt static short *yylexemes = 0; 678264790Sbapt#endif /* YYBTYACC */ 679264790Sbapt int yym, yyn, yystate, yyresult; 680264790Sbapt#if YYBTYACC 681264790Sbapt int yynewerrflag; 682264790Sbapt YYParseState *yyerrctx = NULL; 683264790Sbapt#endif /* YYBTYACC */ 684264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 685264790Sbapt YYLTYPE yyerror_loc_range[2]; /* position of error start & end */ 686264790Sbapt#endif 687264790Sbapt#if YYDEBUG 688264790Sbapt const char *yys; 689264790Sbapt 690264790Sbapt if ((yys = getenv("YYDEBUG")) != 0) 691264790Sbapt { 692264790Sbapt yyn = *yys; 693264790Sbapt if (yyn >= '0' && yyn <= '9') 694264790Sbapt yydebug = yyn - '0'; 695264790Sbapt } 696264790Sbapt if (yydebug) 697264790Sbapt fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 698264790Sbapt#endif 699264790Sbapt 700264790Sbapt#if YYBTYACC 701264790Sbapt yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 702264790Sbapt yyps->save = 0; 703264790Sbapt#endif /* YYBTYACC */ 704264790Sbapt yynerrs = 0; 705264790Sbapt yyerrflag = 0; 706264790Sbapt yychar = YYEMPTY; 707264790Sbapt yystate = 0; 708264790Sbapt 709264790Sbapt#if YYPURE 710264790Sbapt memset(&yystack, 0, sizeof(yystack)); 711264790Sbapt#endif 712264790Sbapt 713264790Sbapt if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 714264790Sbapt yystack.s_mark = yystack.s_base; 715264790Sbapt yystack.l_mark = yystack.l_base; 716264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 717264790Sbapt yystack.p_mark = yystack.p_base; 718264790Sbapt#endif 719264790Sbapt yystate = 0; 720264790Sbapt *yystack.s_mark = 0; 721264790Sbapt 722264790Sbaptyyloop: 723264790Sbapt if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 724264790Sbapt if (yychar < 0) 725264790Sbapt { 726264790Sbapt#if YYBTYACC 727264790Sbapt do { 728264790Sbapt if (yylvp < yylve) 729264790Sbapt { 730264790Sbapt /* we're currently re-reading tokens */ 731264790Sbapt yylval = *yylvp++; 732264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 733264790Sbapt yylloc = *yylpp++; 734264790Sbapt#endif 735264790Sbapt yychar = *yylexp++; 736264790Sbapt break; 737264790Sbapt } 738264790Sbapt if (yyps->save) 739264790Sbapt { 740264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 741264790Sbapt if (yylvp == yylvlim) 742264790Sbapt { /* Enlarge lexical value queue */ 743272955Srodrigc size_t p = (size_t) (yylvp - yylvals); 744272955Srodrigc size_t s = (size_t) (yylvlim - yylvals); 745264790Sbapt 746264790Sbapt s += YYLVQUEUEGROWTH; 747264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem; 748264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 749264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 750264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 751264790Sbapt#endif 752264790Sbapt yylvp = yylve = yylvals + p; 753264790Sbapt yylvlim = yylvals + s; 754264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 755264790Sbapt yylpp = yylpe = yylpsns + p; 756264790Sbapt yylplim = yylpsns + s; 757264790Sbapt#endif 758264790Sbapt yylexp = yylexemes + p; 759264790Sbapt } 760264790Sbapt *yylexp = (short) YYLEX; 761264790Sbapt *yylvp++ = yylval; 762264790Sbapt yylve++; 763264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 764264790Sbapt *yylpp++ = yylloc; 765264790Sbapt yylpe++; 766264790Sbapt#endif 767264790Sbapt yychar = *yylexp++; 768264790Sbapt break; 769264790Sbapt } 770264790Sbapt /* normal operation, no conflict encountered */ 771264790Sbapt#endif /* YYBTYACC */ 772264790Sbapt yychar = YYLEX; 773264790Sbapt#if YYBTYACC 774264790Sbapt } while (0); 775264790Sbapt#endif /* YYBTYACC */ 776264790Sbapt if (yychar < 0) yychar = YYEOF; 777264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 778264790Sbapt#if YYDEBUG 779264790Sbapt if (yydebug) 780264790Sbapt { 781264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 782264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 783264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 784264790Sbapt#ifdef YYSTYPE_TOSTRING 785264790Sbapt#if YYBTYACC 786264790Sbapt if (!yytrial) 787264790Sbapt#endif /* YYBTYACC */ 788264790Sbapt fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 789264790Sbapt#endif 790264790Sbapt fputc('\n', stderr); 791264790Sbapt } 792264790Sbapt#endif 793264790Sbapt } 794264790Sbapt#if YYBTYACC 795264790Sbapt 796264790Sbapt /* Do we have a conflict? */ 797264790Sbapt if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 798264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 799264790Sbapt { 800264790Sbapt YYINT ctry; 801264790Sbapt 802264790Sbapt if (yypath) 803264790Sbapt { 804264790Sbapt YYParseState *save; 805264790Sbapt#if YYDEBUG 806264790Sbapt if (yydebug) 807264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 808264790Sbapt YYDEBUGSTR, yydepth, yystate); 809264790Sbapt#endif 810264790Sbapt /* Switch to the next conflict context */ 811264790Sbapt save = yypath; 812264790Sbapt yypath = save->save; 813264790Sbapt save->save = NULL; 814264790Sbapt ctry = save->ctry; 815264790Sbapt if (save->state != yystate) YYABORT; 816264790Sbapt yyFreeState(save); 817264790Sbapt 818264790Sbapt } 819264790Sbapt else 820264790Sbapt { 821264790Sbapt 822264790Sbapt /* Unresolved conflict - start/continue trial parse */ 823264790Sbapt YYParseState *save; 824264790Sbapt#if YYDEBUG 825264790Sbapt if (yydebug) 826264790Sbapt { 827264790Sbapt fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 828264790Sbapt if (yyps->save) 829264790Sbapt fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 830264790Sbapt else 831264790Sbapt fputs("Starting trial parse.\n", stderr); 832264790Sbapt } 833264790Sbapt#endif 834264790Sbapt save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 835264790Sbapt if (save == NULL) goto yyenomem; 836264790Sbapt save->save = yyps->save; 837264790Sbapt save->state = yystate; 838264790Sbapt save->errflag = yyerrflag; 839264790Sbapt save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 840272955Srodrigc memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 841264790Sbapt save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 842272955Srodrigc memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 843264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 844264790Sbapt save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 845272955Srodrigc memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 846264790Sbapt#endif 847264790Sbapt ctry = yytable[yyn]; 848264790Sbapt if (yyctable[ctry] == -1) 849264790Sbapt { 850264790Sbapt#if YYDEBUG 851264790Sbapt if (yydebug && yychar >= YYEOF) 852264790Sbapt fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 853264790Sbapt#endif 854264790Sbapt ctry++; 855264790Sbapt } 856264790Sbapt save->ctry = ctry; 857264790Sbapt if (yyps->save == NULL) 858264790Sbapt { 859264790Sbapt /* If this is a first conflict in the stack, start saving lexemes */ 860264790Sbapt if (!yylexemes) 861264790Sbapt { 862264790Sbapt yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short)); 863264790Sbapt if (yylexemes == NULL) goto yyenomem; 864264790Sbapt yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 865264790Sbapt if (yylvals == NULL) goto yyenomem; 866264790Sbapt yylvlim = yylvals + YYLVQUEUEGROWTH; 867264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 868264790Sbapt yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 869264790Sbapt if (yylpsns == NULL) goto yyenomem; 870264790Sbapt yylplim = yylpsns + YYLVQUEUEGROWTH; 871264790Sbapt#endif 872264790Sbapt } 873264790Sbapt if (yylvp == yylve) 874264790Sbapt { 875264790Sbapt yylvp = yylve = yylvals; 876264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 877264790Sbapt yylpp = yylpe = yylpsns; 878264790Sbapt#endif 879264790Sbapt yylexp = yylexemes; 880264790Sbapt if (yychar >= YYEOF) 881264790Sbapt { 882264790Sbapt *yylve++ = yylval; 883264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 884264790Sbapt *yylpe++ = yylloc; 885264790Sbapt#endif 886264790Sbapt *yylexp = (short) yychar; 887264790Sbapt yychar = YYEMPTY; 888264790Sbapt } 889264790Sbapt } 890264790Sbapt } 891264790Sbapt if (yychar >= YYEOF) 892264790Sbapt { 893264790Sbapt yylvp--; 894264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 895264790Sbapt yylpp--; 896264790Sbapt#endif 897264790Sbapt yylexp--; 898264790Sbapt yychar = YYEMPTY; 899264790Sbapt } 900272955Srodrigc save->lexeme = (int) (yylvp - yylvals); 901264790Sbapt yyps->save = save; 902264790Sbapt } 903264790Sbapt if (yytable[yyn] == ctry) 904264790Sbapt { 905264790Sbapt#if YYDEBUG 906264790Sbapt if (yydebug) 907264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 908264790Sbapt YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 909264790Sbapt#endif 910264790Sbapt if (yychar < 0) 911264790Sbapt { 912264790Sbapt yylvp++; 913264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 914264790Sbapt yylpp++; 915264790Sbapt#endif 916264790Sbapt yylexp++; 917264790Sbapt } 918264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 919264790Sbapt goto yyoverflow; 920264790Sbapt yystate = yyctable[ctry]; 921264790Sbapt *++yystack.s_mark = (short) yystate; 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 else 931264790Sbapt { 932264790Sbapt yyn = yyctable[ctry]; 933264790Sbapt goto yyreduce; 934264790Sbapt } 935264790Sbapt } /* End of code dealing with conflicts */ 936264790Sbapt#endif /* YYBTYACC */ 937264790Sbapt if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 938264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 939264790Sbapt { 940264790Sbapt#if YYDEBUG 941264790Sbapt if (yydebug) 942264790Sbapt fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 943264790Sbapt YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 944264790Sbapt#endif 945264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 946264790Sbapt yystate = yytable[yyn]; 947264790Sbapt *++yystack.s_mark = yytable[yyn]; 948264790Sbapt *++yystack.l_mark = yylval; 949264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 950264790Sbapt *++yystack.p_mark = yylloc; 951264790Sbapt#endif 952264790Sbapt yychar = YYEMPTY; 953264790Sbapt if (yyerrflag > 0) --yyerrflag; 954264790Sbapt goto yyloop; 955264790Sbapt } 956264790Sbapt if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 957264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 958264790Sbapt { 959264790Sbapt yyn = yytable[yyn]; 960264790Sbapt goto yyreduce; 961264790Sbapt } 962264790Sbapt if (yyerrflag != 0) goto yyinrecovery; 963264790Sbapt#if YYBTYACC 964264790Sbapt 965264790Sbapt yynewerrflag = 1; 966264790Sbapt goto yyerrhandler; 967264790Sbapt goto yyerrlab; 968264790Sbapt 969264790Sbaptyyerrlab: 970264790Sbapt yynewerrflag = 0; 971264790Sbaptyyerrhandler: 972264790Sbapt while (yyps->save) 973264790Sbapt { 974264790Sbapt int ctry; 975264790Sbapt YYParseState *save = yyps->save; 976264790Sbapt#if YYDEBUG 977264790Sbapt if (yydebug) 978264790Sbapt fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 979264790Sbapt YYDEBUGSTR, yydepth, yystate, yyps->save->state, 980264790Sbapt (int)(yylvp - yylvals - yyps->save->lexeme)); 981264790Sbapt#endif 982264790Sbapt /* Memorize most forward-looking error state in case it's really an error. */ 983264790Sbapt if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 984264790Sbapt { 985264790Sbapt /* Free old saved error context state */ 986264790Sbapt if (yyerrctx) yyFreeState(yyerrctx); 987264790Sbapt /* Create and fill out new saved error context state */ 988264790Sbapt yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 989264790Sbapt if (yyerrctx == NULL) goto yyenomem; 990264790Sbapt yyerrctx->save = yyps->save; 991264790Sbapt yyerrctx->state = yystate; 992264790Sbapt yyerrctx->errflag = yyerrflag; 993264790Sbapt yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 994272955Srodrigc memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 995264790Sbapt yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 996272955Srodrigc memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 997264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 998264790Sbapt yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 999272955Srodrigc memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1000264790Sbapt#endif 1001272955Srodrigc yyerrctx->lexeme = (int) (yylvp - yylvals); 1002264790Sbapt } 1003264790Sbapt yylvp = yylvals + save->lexeme; 1004264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1005264790Sbapt yylpp = yylpsns + save->lexeme; 1006264790Sbapt#endif 1007264790Sbapt yylexp = yylexemes + save->lexeme; 1008264790Sbapt yychar = YYEMPTY; 1009264790Sbapt yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 1010272955Srodrigc memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1011264790Sbapt yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 1012272955Srodrigc memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1013264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1014264790Sbapt yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 1015272955Srodrigc memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1016264790Sbapt#endif 1017264790Sbapt ctry = ++save->ctry; 1018264790Sbapt yystate = save->state; 1019264790Sbapt /* We tried shift, try reduce now */ 1020264790Sbapt if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1021264790Sbapt yyps->save = save->save; 1022264790Sbapt save->save = NULL; 1023264790Sbapt yyFreeState(save); 1024264790Sbapt 1025264790Sbapt /* Nothing left on the stack -- error */ 1026264790Sbapt if (!yyps->save) 1027264790Sbapt { 1028264790Sbapt#if YYDEBUG 1029264790Sbapt if (yydebug) 1030264790Sbapt fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1031264790Sbapt YYPREFIX, yydepth); 1032264790Sbapt#endif 1033264790Sbapt /* Restore state as it was in the most forward-advanced error */ 1034264790Sbapt yylvp = yylvals + yyerrctx->lexeme; 1035264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1036264790Sbapt yylpp = yylpsns + yyerrctx->lexeme; 1037264790Sbapt#endif 1038264790Sbapt yylexp = yylexemes + yyerrctx->lexeme; 1039264790Sbapt yychar = yylexp[-1]; 1040264790Sbapt yylval = yylvp[-1]; 1041264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1042264790Sbapt yylloc = yylpp[-1]; 1043264790Sbapt#endif 1044264790Sbapt yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1045272955Srodrigc memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1046264790Sbapt yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1047272955Srodrigc memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1048264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1049264790Sbapt yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1050272955Srodrigc memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1051264790Sbapt#endif 1052264790Sbapt yystate = yyerrctx->state; 1053264790Sbapt yyFreeState(yyerrctx); 1054264790Sbapt yyerrctx = NULL; 1055264790Sbapt } 1056264790Sbapt yynewerrflag = 1; 1057264790Sbapt } 1058264790Sbapt if (yynewerrflag == 0) goto yyinrecovery; 1059264790Sbapt#endif /* YYBTYACC */ 1060264790Sbapt 1061264790Sbapt YYERROR_CALL("syntax error"); 1062264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1063264790Sbapt yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */ 1064264790Sbapt#endif 1065264790Sbapt 1066264790Sbapt#if !YYBTYACC 1067264790Sbapt goto yyerrlab; 1068264790Sbaptyyerrlab: 1069264790Sbapt#endif 1070264790Sbapt ++yynerrs; 1071264790Sbapt 1072264790Sbaptyyinrecovery: 1073264790Sbapt if (yyerrflag < 3) 1074264790Sbapt { 1075264790Sbapt yyerrflag = 3; 1076264790Sbapt for (;;) 1077264790Sbapt { 1078264790Sbapt if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1079264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1080264790Sbapt { 1081264790Sbapt#if YYDEBUG 1082264790Sbapt if (yydebug) 1083264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1084264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1085264790Sbapt#endif 1086264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1087264790Sbapt yystate = yytable[yyn]; 1088264790Sbapt *++yystack.s_mark = yytable[yyn]; 1089264790Sbapt *++yystack.l_mark = yylval; 1090264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1091264790Sbapt /* lookahead position is error end position */ 1092264790Sbapt yyerror_loc_range[1] = yylloc; 1093264790Sbapt YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1094264790Sbapt *++yystack.p_mark = yyloc; 1095264790Sbapt#endif 1096264790Sbapt goto yyloop; 1097264790Sbapt } 1098264790Sbapt else 1099264790Sbapt { 1100264790Sbapt#if YYDEBUG 1101264790Sbapt if (yydebug) 1102264790Sbapt fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1103264790Sbapt YYDEBUGSTR, yydepth, *yystack.s_mark); 1104264790Sbapt#endif 1105264790Sbapt if (yystack.s_mark <= yystack.s_base) goto yyabort; 1106264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1107264790Sbapt /* the current TOS position is the error start position */ 1108264790Sbapt yyerror_loc_range[0] = *yystack.p_mark; 1109264790Sbapt#endif 1110264790Sbapt#if defined(YYDESTRUCT_CALL) 1111264790Sbapt#if YYBTYACC 1112264790Sbapt if (!yytrial) 1113264790Sbapt#endif /* YYBTYACC */ 1114264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1115264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1116264790Sbapt yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1117264790Sbapt#else 1118264790Sbapt YYDESTRUCT_CALL("error: discarding state", 1119264790Sbapt yystos[*yystack.s_mark], yystack.l_mark); 1120264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1121264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1122264790Sbapt --yystack.s_mark; 1123264790Sbapt --yystack.l_mark; 1124264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1125264790Sbapt --yystack.p_mark; 1126264790Sbapt#endif 1127264790Sbapt } 1128264790Sbapt } 1129264790Sbapt } 1130264790Sbapt else 1131264790Sbapt { 1132264790Sbapt if (yychar == YYEOF) goto yyabort; 1133264790Sbapt#if YYDEBUG 1134264790Sbapt if (yydebug) 1135264790Sbapt { 1136264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1137264790Sbapt fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1138264790Sbapt YYDEBUGSTR, yydepth, yystate, yychar, yys); 1139264790Sbapt } 1140264790Sbapt#endif 1141264790Sbapt#if defined(YYDESTRUCT_CALL) 1142264790Sbapt#if YYBTYACC 1143264790Sbapt if (!yytrial) 1144264790Sbapt#endif /* YYBTYACC */ 1145264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1146264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1147264790Sbapt#else 1148264790Sbapt YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1149264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1150264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1151264790Sbapt yychar = YYEMPTY; 1152264790Sbapt goto yyloop; 1153264790Sbapt } 1154264790Sbapt 1155264790Sbaptyyreduce: 1156264790Sbapt yym = yylen[yyn]; 1157264790Sbapt#if YYDEBUG 1158264790Sbapt if (yydebug) 1159264790Sbapt { 1160264790Sbapt fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1161264790Sbapt YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1162264790Sbapt#ifdef YYSTYPE_TOSTRING 1163264790Sbapt#if YYBTYACC 1164264790Sbapt if (!yytrial) 1165264790Sbapt#endif /* YYBTYACC */ 1166264790Sbapt if (yym > 0) 1167264790Sbapt { 1168264790Sbapt int i; 1169264790Sbapt fputc('<', stderr); 1170264790Sbapt for (i = yym; i > 0; i--) 1171264790Sbapt { 1172264790Sbapt if (i != yym) fputs(", ", stderr); 1173264790Sbapt fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1174264790Sbapt yystack.l_mark[1-i]), stderr); 1175264790Sbapt } 1176264790Sbapt fputc('>', stderr); 1177264790Sbapt } 1178264790Sbapt#endif 1179264790Sbapt fputc('\n', stderr); 1180264790Sbapt } 1181264790Sbapt#endif 1182264790Sbapt if (yym > 0) 1183264790Sbapt yyval = yystack.l_mark[1-yym]; 1184264790Sbapt else 1185264790Sbapt memset(&yyval, 0, sizeof yyval); 1186264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1187264790Sbapt 1188264790Sbapt /* Perform position reduction */ 1189264790Sbapt memset(&yyloc, 0, sizeof(yyloc)); 1190264790Sbapt#if YYBTYACC 1191264790Sbapt if (!yytrial) 1192264790Sbapt#endif /* YYBTYACC */ 1193264790Sbapt { 1194264790Sbapt YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym); 1195264790Sbapt /* just in case YYERROR is invoked within the action, save 1196264790Sbapt the start of the rhs as the error start position */ 1197264790Sbapt yyerror_loc_range[0] = yystack.p_mark[1-yym]; 1198264790Sbapt } 1199264790Sbapt#endif 1200264790Sbapt 1201264790Sbapt switch (yyn) 1202264790Sbapt { 1203264790Sbaptcase 3: 1204264790Sbapt#line 66 "ok_syntax1.y" 1205264790Sbapt { yyerrok ; } 1206264790Sbaptbreak; 1207264790Sbaptcase 4: 1208264790Sbapt#line 70 "ok_syntax1.y" 1209264790Sbapt { printf("%d\n",yystack.l_mark[0].ival);} 1210264790Sbaptbreak; 1211264790Sbaptcase 5: 1212264790Sbapt#line 72 "ok_syntax1.y" 1213264790Sbapt { regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; } 1214264790Sbaptbreak; 1215264790Sbaptcase 6: 1216264790Sbapt#line 76 "ok_syntax1.y" 1217264790Sbapt { yyval.ival = yystack.l_mark[-1].ival; } 1218264790Sbaptbreak; 1219264790Sbaptcase 7: 1220264790Sbapt#line 78 "ok_syntax1.y" 1221264790Sbapt { yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; } 1222264790Sbaptbreak; 1223264790Sbaptcase 8: 1224264790Sbapt#line 80 "ok_syntax1.y" 1225264790Sbapt { yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; } 1226264790Sbaptbreak; 1227264790Sbaptcase 9: 1228264790Sbapt#line 82 "ok_syntax1.y" 1229264790Sbapt { yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; } 1230264790Sbaptbreak; 1231264790Sbaptcase 10: 1232264790Sbapt#line 84 "ok_syntax1.y" 1233264790Sbapt { yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; } 1234264790Sbaptbreak; 1235264790Sbaptcase 11: 1236264790Sbapt#line 86 "ok_syntax1.y" 1237264790Sbapt { yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; } 1238264790Sbaptbreak; 1239264790Sbaptcase 12: 1240264790Sbapt#line 88 "ok_syntax1.y" 1241264790Sbapt { yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; } 1242264790Sbaptbreak; 1243264790Sbaptcase 13: 1244264790Sbapt#line 90 "ok_syntax1.y" 1245264790Sbapt { yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; } 1246264790Sbaptbreak; 1247264790Sbaptcase 14: 1248264790Sbapt#line 92 "ok_syntax1.y" 1249264790Sbapt { yyval.ival = - yystack.l_mark[0].ival; } 1250264790Sbaptbreak; 1251264790Sbaptcase 15: 1252264790Sbapt#line 94 "ok_syntax1.y" 1253264790Sbapt { yyval.ival = regs[yystack.l_mark[0].ival]; } 1254264790Sbaptbreak; 1255264790Sbaptcase 17: 1256264790Sbapt#line 99 "ok_syntax1.y" 1257264790Sbapt { yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; } 1258264790Sbaptbreak; 1259264790Sbaptcase 18: 1260264790Sbapt#line 101 "ok_syntax1.y" 1261264790Sbapt { yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; } 1262264790Sbaptbreak; 1263272955Srodrigc#line 1264 "ok_syntax1.tab.c" 1264264790Sbapt default: 1265264790Sbapt break; 1266264790Sbapt } 1267264790Sbapt yystack.s_mark -= yym; 1268264790Sbapt yystate = *yystack.s_mark; 1269264790Sbapt yystack.l_mark -= yym; 1270264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1271264790Sbapt yystack.p_mark -= yym; 1272264790Sbapt#endif 1273264790Sbapt yym = yylhs[yyn]; 1274264790Sbapt if (yystate == 0 && yym == 0) 1275264790Sbapt { 1276264790Sbapt#if YYDEBUG 1277264790Sbapt if (yydebug) 1278264790Sbapt { 1279264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1280264790Sbapt#ifdef YYSTYPE_TOSTRING 1281264790Sbapt#if YYBTYACC 1282264790Sbapt if (!yytrial) 1283264790Sbapt#endif /* YYBTYACC */ 1284264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1285264790Sbapt#endif 1286264790Sbapt fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1287264790Sbapt } 1288264790Sbapt#endif 1289264790Sbapt yystate = YYFINAL; 1290264790Sbapt *++yystack.s_mark = YYFINAL; 1291264790Sbapt *++yystack.l_mark = yyval; 1292264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1293264790Sbapt *++yystack.p_mark = yyloc; 1294264790Sbapt#endif 1295264790Sbapt if (yychar < 0) 1296264790Sbapt { 1297264790Sbapt#if YYBTYACC 1298264790Sbapt do { 1299264790Sbapt if (yylvp < yylve) 1300264790Sbapt { 1301264790Sbapt /* we're currently re-reading tokens */ 1302264790Sbapt yylval = *yylvp++; 1303264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1304264790Sbapt yylloc = *yylpp++; 1305264790Sbapt#endif 1306264790Sbapt yychar = *yylexp++; 1307264790Sbapt break; 1308264790Sbapt } 1309264790Sbapt if (yyps->save) 1310264790Sbapt { 1311264790Sbapt /* in trial mode; save scanner results for future parse attempts */ 1312264790Sbapt if (yylvp == yylvlim) 1313264790Sbapt { /* Enlarge lexical value queue */ 1314272955Srodrigc size_t p = (size_t) (yylvp - yylvals); 1315272955Srodrigc size_t s = (size_t) (yylvlim - yylvals); 1316264790Sbapt 1317264790Sbapt s += YYLVQUEUEGROWTH; 1318264790Sbapt if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) 1319264790Sbapt goto yyenomem; 1320264790Sbapt if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1321264790Sbapt goto yyenomem; 1322264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1323264790Sbapt if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1324264790Sbapt goto yyenomem; 1325264790Sbapt#endif 1326264790Sbapt yylvp = yylve = yylvals + p; 1327264790Sbapt yylvlim = yylvals + s; 1328264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1329264790Sbapt yylpp = yylpe = yylpsns + p; 1330264790Sbapt yylplim = yylpsns + s; 1331264790Sbapt#endif 1332264790Sbapt yylexp = yylexemes + p; 1333264790Sbapt } 1334264790Sbapt *yylexp = (short) YYLEX; 1335264790Sbapt *yylvp++ = yylval; 1336264790Sbapt yylve++; 1337264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1338264790Sbapt *yylpp++ = yylloc; 1339264790Sbapt yylpe++; 1340264790Sbapt#endif 1341264790Sbapt yychar = *yylexp++; 1342264790Sbapt break; 1343264790Sbapt } 1344264790Sbapt /* normal operation, no conflict encountered */ 1345264790Sbapt#endif /* YYBTYACC */ 1346264790Sbapt yychar = YYLEX; 1347264790Sbapt#if YYBTYACC 1348264790Sbapt } while (0); 1349264790Sbapt#endif /* YYBTYACC */ 1350264790Sbapt if (yychar < 0) yychar = YYEOF; 1351264790Sbapt /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */ 1352264790Sbapt#if YYDEBUG 1353264790Sbapt if (yydebug) 1354264790Sbapt { 1355264790Sbapt yys = yyname[YYTRANSLATE(yychar)]; 1356264790Sbapt fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n", 1357264790Sbapt YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1358264790Sbapt } 1359264790Sbapt#endif 1360264790Sbapt } 1361264790Sbapt if (yychar == YYEOF) goto yyaccept; 1362264790Sbapt goto yyloop; 1363264790Sbapt } 1364264790Sbapt if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1365264790Sbapt yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1366264790Sbapt yystate = yytable[yyn]; 1367264790Sbapt else 1368264790Sbapt yystate = yydgoto[yym]; 1369264790Sbapt#if YYDEBUG 1370264790Sbapt if (yydebug) 1371264790Sbapt { 1372264790Sbapt fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1373264790Sbapt#ifdef YYSTYPE_TOSTRING 1374264790Sbapt#if YYBTYACC 1375264790Sbapt if (!yytrial) 1376264790Sbapt#endif /* YYBTYACC */ 1377264790Sbapt fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1378264790Sbapt#endif 1379264790Sbapt fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1380264790Sbapt } 1381264790Sbapt#endif 1382264790Sbapt if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1383264790Sbapt *++yystack.s_mark = (short) yystate; 1384264790Sbapt *++yystack.l_mark = yyval; 1385264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1386264790Sbapt *++yystack.p_mark = yyloc; 1387264790Sbapt#endif 1388264790Sbapt goto yyloop; 1389264790Sbapt#if YYBTYACC 1390264790Sbapt 1391264790Sbapt /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1392264790Sbaptyyvalid: 1393264790Sbapt if (yypath) YYABORT; 1394264790Sbapt while (yyps->save) 1395264790Sbapt { 1396264790Sbapt YYParseState *save = yyps->save; 1397264790Sbapt yyps->save = save->save; 1398264790Sbapt save->save = yypath; 1399264790Sbapt yypath = save; 1400264790Sbapt } 1401264790Sbapt#if YYDEBUG 1402264790Sbapt if (yydebug) 1403264790Sbapt fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1404264790Sbapt YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1405264790Sbapt#endif 1406264790Sbapt if (yyerrctx) 1407264790Sbapt { 1408264790Sbapt yyFreeState(yyerrctx); 1409264790Sbapt yyerrctx = NULL; 1410264790Sbapt } 1411264790Sbapt yylvp = yylvals + yypath->lexeme; 1412264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1413264790Sbapt yylpp = yylpsns + yypath->lexeme; 1414264790Sbapt#endif 1415264790Sbapt yylexp = yylexemes + yypath->lexeme; 1416264790Sbapt yychar = YYEMPTY; 1417264790Sbapt yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1418272955Srodrigc memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short)); 1419264790Sbapt yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1420272955Srodrigc memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1421264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1422264790Sbapt yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1423272955Srodrigc memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1424264790Sbapt#endif 1425264790Sbapt yystate = yypath->state; 1426264790Sbapt goto yyloop; 1427264790Sbapt#endif /* YYBTYACC */ 1428264790Sbapt 1429264790Sbaptyyoverflow: 1430264790Sbapt YYERROR_CALL("yacc stack overflow"); 1431264790Sbapt#if YYBTYACC 1432264790Sbapt goto yyabort_nomem; 1433264790Sbaptyyenomem: 1434264790Sbapt YYERROR_CALL("memory exhausted"); 1435264790Sbaptyyabort_nomem: 1436264790Sbapt#endif /* YYBTYACC */ 1437264790Sbapt yyresult = 2; 1438264790Sbapt goto yyreturn; 1439264790Sbapt 1440264790Sbaptyyabort: 1441264790Sbapt yyresult = 1; 1442264790Sbapt goto yyreturn; 1443264790Sbapt 1444264790Sbaptyyaccept: 1445264790Sbapt#if YYBTYACC 1446264790Sbapt if (yyps->save) goto yyvalid; 1447264790Sbapt#endif /* YYBTYACC */ 1448264790Sbapt yyresult = 0; 1449264790Sbapt 1450264790Sbaptyyreturn: 1451264790Sbapt#if defined(YYDESTRUCT_CALL) 1452264790Sbapt if (yychar != YYEOF && yychar != YYEMPTY) 1453264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1454264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1455264790Sbapt#else 1456264790Sbapt YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1457264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1458264790Sbapt 1459264790Sbapt { 1460264790Sbapt YYSTYPE *pv; 1461264790Sbapt#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1462264790Sbapt YYLTYPE *pp; 1463264790Sbapt 1464264790Sbapt for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1465264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1466264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1467264790Sbapt#else 1468264790Sbapt for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1469264790Sbapt YYDESTRUCT_CALL("cleanup: discarding state", 1470264790Sbapt yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1471264790Sbapt#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1472264790Sbapt } 1473264790Sbapt#endif /* defined(YYDESTRUCT_CALL) */ 1474264790Sbapt 1475264790Sbapt#if YYBTYACC 1476264790Sbapt if (yyerrctx) 1477264790Sbapt { 1478264790Sbapt yyFreeState(yyerrctx); 1479264790Sbapt yyerrctx = NULL; 1480264790Sbapt } 1481264790Sbapt while (yyps) 1482264790Sbapt { 1483264790Sbapt YYParseState *save = yyps; 1484264790Sbapt yyps = save->save; 1485264790Sbapt save->save = NULL; 1486264790Sbapt yyFreeState(save); 1487264790Sbapt } 1488264790Sbapt while (yypath) 1489264790Sbapt { 1490264790Sbapt YYParseState *save = yypath; 1491264790Sbapt yypath = save->save; 1492264790Sbapt save->save = NULL; 1493264790Sbapt yyFreeState(save); 1494264790Sbapt } 1495264790Sbapt#endif /* YYBTYACC */ 1496264790Sbapt yyfreestack(&yystack); 1497264790Sbapt return (yyresult); 1498264790Sbapt} 1499