1/* original parser id follows */ 2/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */ 3/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */ 4 5#define YYBYACC 1 6#define YYMAJOR 2 7#define YYMINOR 0 8#define YYCHECK "yyyymmdd" 9 10#define YYEMPTY (-1) 11#define yyclearin (yychar = YYEMPTY) 12#define yyerrok (yyerrflag = 0) 13#define YYRECOVERING() (yyerrflag != 0) 14#define YYENOMEM (-2) 15#define YYEOF 0 16#undef YYBTYACC 17#define YYBTYACC 1 18#define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug") 19 20#ifndef yyparse 21#define yyparse destroy2_parse 22#endif /* yyparse */ 23 24#ifndef yylex 25#define yylex destroy2_lex 26#endif /* yylex */ 27 28#ifndef yyerror 29#define yyerror destroy2_error 30#endif /* yyerror */ 31 32#ifndef yychar 33#define yychar destroy2_char 34#endif /* yychar */ 35 36#ifndef yyval 37#define yyval destroy2_val 38#endif /* yyval */ 39 40#ifndef yylval 41#define yylval destroy2_lval 42#endif /* yylval */ 43 44#ifndef yydebug 45#define yydebug destroy2_debug 46#endif /* yydebug */ 47 48#ifndef yynerrs 49#define yynerrs destroy2_nerrs 50#endif /* yynerrs */ 51 52#ifndef yyerrflag 53#define yyerrflag destroy2_errflag 54#endif /* yyerrflag */ 55 56#ifndef yylhs 57#define yylhs destroy2_lhs 58#endif /* yylhs */ 59 60#ifndef yylen 61#define yylen destroy2_len 62#endif /* yylen */ 63 64#ifndef yydefred 65#define yydefred destroy2_defred 66#endif /* yydefred */ 67 68#ifndef yystos 69#define yystos destroy2_stos 70#endif /* yystos */ 71 72#ifndef yydgoto 73#define yydgoto destroy2_dgoto 74#endif /* yydgoto */ 75 76#ifndef yysindex 77#define yysindex destroy2_sindex 78#endif /* yysindex */ 79 80#ifndef yyrindex 81#define yyrindex destroy2_rindex 82#endif /* yyrindex */ 83 84#ifndef yygindex 85#define yygindex destroy2_gindex 86#endif /* yygindex */ 87 88#ifndef yytable 89#define yytable destroy2_table 90#endif /* yytable */ 91 92#ifndef yycheck 93#define yycheck destroy2_check 94#endif /* yycheck */ 95 96#ifndef yyname 97#define yyname destroy2_name 98#endif /* yyname */ 99 100#ifndef yyrule 101#define yyrule destroy2_rule 102#endif /* yyrule */ 103 104#if YYBTYACC 105 106#ifndef yycindex 107#define yycindex destroy2_cindex 108#endif /* yycindex */ 109 110#ifndef yyctable 111#define yyctable destroy2_ctable 112#endif /* yyctable */ 113 114#endif /* YYBTYACC */ 115 116#define YYPREFIX "destroy2_" 117 118#define YYPURE 0 119 120#line 4 "btyacc_destroy2.y" 121#include <stdlib.h> 122 123typedef enum {cGLOBAL, cLOCAL} class; 124typedef enum {tREAL, tINTEGER} type; 125typedef char * name; 126 127struct symbol { class c; type t; name id; }; 128typedef struct symbol symbol; 129 130struct namelist { symbol *s; struct namelist *next; }; 131typedef struct namelist namelist; 132 133struct parser_param { 134 int *rtrn; 135 symbol ss; 136}; 137 138extern symbol *mksymbol(type t, class c, name id); 139 140#ifdef YYBISON 141#define YYLEX_DECL() yylex(void) 142#define YYERROR_DECL() yyerror(const char *s) 143#endif 144#ifdef YYSTYPE 145#undef YYSTYPE_IS_DECLARED 146#define YYSTYPE_IS_DECLARED 1 147#endif 148#ifndef YYSTYPE_IS_DECLARED 149#define YYSTYPE_IS_DECLARED 1 150#line 50 "btyacc_destroy2.y" 151typedef union YYSTYPE 152{ 153 class cval; 154 type tval; 155 namelist * nlist; 156 name id; 157} YYSTYPE; 158#endif /* !YYSTYPE_IS_DECLARED */ 159#line 160 "btyacc_destroy2.tab.c" 160 161/* compatibility with bison */ 162#ifdef YYPARSE_PARAM 163/* compatibility with FreeBSD */ 164# ifdef YYPARSE_PARAM_TYPE 165# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM) 166# else 167# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM) 168# endif 169#else 170# define YYPARSE_DECL() yyparse(struct parser_param *param, int flag) 171#endif 172 173/* Parameters sent to lex. */ 174#ifdef YYLEX_PARAM 175# define YYLEX_DECL() yylex(void *YYLEX_PARAM) 176# define YYLEX yylex(YYLEX_PARAM) 177#else 178# define YYLEX_DECL() yylex(void) 179# define YYLEX yylex() 180#endif 181 182/* Parameters sent to yyerror. */ 183#ifndef YYERROR_DECL 184#define YYERROR_DECL() yyerror(struct parser_param *param, int flag, const char *s) 185#endif 186#ifndef YYERROR_CALL 187#define YYERROR_CALL(msg) yyerror(param, flag, msg) 188#endif 189 190#ifndef YYDESTRUCT_DECL 191#define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, struct parser_param *param, int flag) 192#endif 193#ifndef YYDESTRUCT_CALL 194#define YYDESTRUCT_CALL(msg, psymb, val) yydestruct(msg, psymb, val, param, flag) 195#endif 196 197extern int YYPARSE_DECL(); 198 199#define GLOBAL 257 200#define LOCAL 258 201#define REAL 259 202#define INTEGER 260 203#define NAME 261 204#define YYERRCODE 256 205typedef int YYINT; 206static const YYINT destroy2_lhs[] = { -1, 207 0, 0, 2, 2, 3, 3, 4, 4, 1, 208}; 209static const YYINT destroy2_len[] = { 2, 210 8, 5, 1, 1, 1, 1, 2, 1, 6, 211}; 212static const YYINT destroy2_defred[] = { 0, 213 3, 4, 5, 6, 0, 0, 0, 0, 8, 0, 214 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 215 0, 0, 0, 0, 9, 1, 216}; 217#if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING) 218static const YYINT destroy2_stos[] = { 0, 219 257, 258, 259, 260, 263, 265, 266, 266, 261, 264, 220 267, 267, 40, 261, 40, 40, 265, 258, 265, 41, 221 44, 44, 266, 266, 41, 41, 222}; 223#endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */ 224static const YYINT destroy2_dgoto[] = { 5, 225 10, 6, 7, 11, 226}; 227static const YYINT destroy2_sindex[] = { -254, 228 0, 0, 0, 0, 0, -251, -248, -248, 0, -26, 229 -40, -39, -246, 0, -243, -246, -25, -24, -23, 0, 230 -251, -251, -22, -19, 0, 0, 231}; 232static const YYINT destroy2_rindex[] = { 0, 233 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 234 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 235 0, 0, 0, 0, 0, 0, 236}; 237#if YYBTYACC 238static const YYINT destroy2_cindex[] = { 0, 239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241 0, 0, 0, 0, 0, 0, 242}; 243#endif 244static const YYINT destroy2_gindex[] = { 0, 245 0, -6, -4, 15, 246}; 247#define YYTABLESIZE 222 248static const YYINT destroy2_table[] = { 15, 249 16, 8, 1, 2, 3, 4, 17, 3, 4, 19, 250 1, 2, 9, 13, 18, 20, 23, 24, 25, 21, 251 22, 26, 12, 0, 0, 0, 0, 0, 0, 0, 252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 260 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 261 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 262 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 263 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 264 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 265 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 267 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 268 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 269 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 270 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 271 14, 14, 272}; 273static const YYINT destroy2_check[] = { 40, 274 40, 6, 257, 258, 259, 260, 13, 259, 260, 16, 275 257, 258, 261, 40, 258, 41, 21, 22, 41, 44, 276 44, 41, 8, -1, -1, -1, -1, -1, -1, -1, 277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 280 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 281 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 294 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 295 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 296 261, 261, 297}; 298#if YYBTYACC 299static const YYINT destroy2_ctable[] = { -1, 300 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 301 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 302 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 303 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 306 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 310 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 312 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 313 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 314 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 315 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 316 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 317 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 318 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 319 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 320 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 321 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 322 -1, 323}; 324#endif 325#define YYFINAL 5 326#ifndef YYDEBUG 327#define YYDEBUG 0 328#endif 329#define YYMAXTOKEN 261 330#define YYUNDFTOKEN 268 331#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a)) 332#if YYDEBUG 333static const char *const destroy2_name[] = { 334 335"$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 3360,0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 3370,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 3380,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 3390,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 3400,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 3410,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"error","GLOBAL","LOCAL", 342"REAL","INTEGER","NAME","$accept","declaration","locnamelist","class","type", 343"namelist","illegal-symbol", 344}; 345static const char *const destroy2_rule[] = { 346"$accept : declaration", 347"declaration : class type namelist '(' class ',' type ')'", 348"declaration : type locnamelist '(' class ')'", 349"class : GLOBAL", 350"class : LOCAL", 351"type : REAL", 352"type : INTEGER", 353"namelist : namelist NAME", 354"namelist : NAME", 355"locnamelist : namelist '(' LOCAL ',' type ')'", 356 357}; 358#endif 359 360#if YYDEBUG 361int yydebug; 362#endif 363 364int yyerrflag; 365int yychar; 366YYSTYPE yyval; 367YYSTYPE yylval; 368int yynerrs; 369 370#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 371YYLTYPE yyloc; /* position returned by actions */ 372YYLTYPE yylloc; /* position from the lexer */ 373#endif 374 375#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 376#ifndef YYLLOC_DEFAULT 377#define YYLLOC_DEFAULT(loc, rhs, n) \ 378do \ 379{ \ 380 if (n == 0) \ 381 { \ 382 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \ 383 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \ 384 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \ 385 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \ 386 } \ 387 else \ 388 { \ 389 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \ 390 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \ 391 (loc).last_line = YYRHSLOC(rhs, n).last_line; \ 392 (loc).last_column = YYRHSLOC(rhs, n).last_column; \ 393 } \ 394} while (0) 395#endif /* YYLLOC_DEFAULT */ 396#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 397#if YYBTYACC 398 399#ifndef YYLVQUEUEGROWTH 400#define YYLVQUEUEGROWTH 32 401#endif 402#endif /* YYBTYACC */ 403 404/* define the initial stack-sizes */ 405#ifdef YYSTACKSIZE 406#undef YYMAXDEPTH 407#define YYMAXDEPTH YYSTACKSIZE 408#else 409#ifdef YYMAXDEPTH 410#define YYSTACKSIZE YYMAXDEPTH 411#else 412#define YYSTACKSIZE 10000 413#define YYMAXDEPTH 10000 414#endif 415#endif 416 417#ifndef YYINITSTACKSIZE 418#define YYINITSTACKSIZE 200 419#endif 420 421typedef struct { 422 unsigned stacksize; 423 YYINT *s_base; 424 YYINT *s_mark; 425 YYINT *s_last; 426 YYSTYPE *l_base; 427 YYSTYPE *l_mark; 428#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 429 YYLTYPE *p_base; 430 YYLTYPE *p_mark; 431#endif 432} YYSTACKDATA; 433#if YYBTYACC 434 435struct YYParseState_s 436{ 437 struct YYParseState_s *save; /* Previously saved parser state */ 438 YYSTACKDATA yystack; /* saved parser stack */ 439 int state; /* saved parser state */ 440 int errflag; /* saved error recovery status */ 441 int lexeme; /* saved index of the conflict lexeme in the lexical queue */ 442 YYINT ctry; /* saved index in yyctable[] for this conflict */ 443}; 444typedef struct YYParseState_s YYParseState; 445#endif /* YYBTYACC */ 446/* variables for the parser stack */ 447static YYSTACKDATA yystack; 448#if YYBTYACC 449 450/* Current parser state */ 451static YYParseState *yyps = 0; 452 453/* yypath != NULL: do the full parse, starting at *yypath parser state. */ 454static YYParseState *yypath = 0; 455 456/* Base of the lexical value queue */ 457static YYSTYPE *yylvals = 0; 458 459/* Current position at lexical value queue */ 460static YYSTYPE *yylvp = 0; 461 462/* End position of lexical value queue */ 463static YYSTYPE *yylve = 0; 464 465/* The last allocated position at the lexical value queue */ 466static YYSTYPE *yylvlim = 0; 467 468#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 469/* Base of the lexical position queue */ 470static YYLTYPE *yylpsns = 0; 471 472/* Current position at lexical position queue */ 473static YYLTYPE *yylpp = 0; 474 475/* End position of lexical position queue */ 476static YYLTYPE *yylpe = 0; 477 478/* The last allocated position at the lexical position queue */ 479static YYLTYPE *yylplim = 0; 480#endif 481 482/* Current position at lexical token queue */ 483static YYINT *yylexp = 0; 484 485static YYINT *yylexemes = 0; 486#endif /* YYBTYACC */ 487#line 89 "btyacc_destroy2.y" 488 489extern int YYLEX_DECL(); 490extern void YYERROR_DECL(); 491#line 492 "btyacc_destroy2.tab.c" 492 493/* Release memory associated with symbol. */ 494#if ! defined YYDESTRUCT_IS_DECLARED 495static void 496YYDESTRUCT_DECL() 497{ 498 switch (psymb) 499 { 500 case 263: 501#line 41 "btyacc_destroy2.y" 502 { 503 namelist *p = (*val).nlist; 504 while (p != NULL) 505 { namelist *pp = p; 506 p = p->next; 507 free(pp->s); free(pp); 508 } 509 } 510#line 511 "btyacc_destroy2.tab.c" 511 break; 512 } 513} 514#define YYDESTRUCT_IS_DECLARED 1 515#endif 516 517/* For use in generated program */ 518#define yydepth (int)(yystack.s_mark - yystack.s_base) 519#if YYBTYACC 520#define yytrial (yyps->save) 521#endif /* YYBTYACC */ 522 523#if YYDEBUG 524#include <stdio.h> /* needed for printf */ 525#endif 526 527#include <stdlib.h> /* needed for malloc, etc */ 528#include <string.h> /* needed for memset */ 529 530/* allocate initial stack or double stack size, up to YYMAXDEPTH */ 531static int yygrowstack(YYSTACKDATA *data) 532{ 533 int i; 534 unsigned newsize; 535 YYINT *newss; 536 YYSTYPE *newvs; 537#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 538 YYLTYPE *newps; 539#endif 540 541 if ((newsize = data->stacksize) == 0) 542 newsize = YYINITSTACKSIZE; 543 else if (newsize >= YYMAXDEPTH) 544 return YYENOMEM; 545 else if ((newsize *= 2) > YYMAXDEPTH) 546 newsize = YYMAXDEPTH; 547 548 i = (int) (data->s_mark - data->s_base); 549 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss)); 550 if (newss == NULL) 551 return YYENOMEM; 552 553 data->s_base = newss; 554 data->s_mark = newss + i; 555 556 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs)); 557 if (newvs == NULL) 558 return YYENOMEM; 559 560 data->l_base = newvs; 561 data->l_mark = newvs + i; 562 563#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 564 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps)); 565 if (newps == NULL) 566 return YYENOMEM; 567 568 data->p_base = newps; 569 data->p_mark = newps + i; 570#endif 571 572 data->stacksize = newsize; 573 data->s_last = data->s_base + newsize - 1; 574 575#if YYDEBUG 576 if (yydebug) 577 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize); 578#endif 579 return 0; 580} 581 582#if YYPURE || defined(YY_NO_LEAKS) 583static void yyfreestack(YYSTACKDATA *data) 584{ 585 free(data->s_base); 586 free(data->l_base); 587#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 588 free(data->p_base); 589#endif 590 memset(data, 0, sizeof(*data)); 591} 592#else 593#define yyfreestack(data) /* nothing */ 594#endif /* YYPURE || defined(YY_NO_LEAKS) */ 595#if YYBTYACC 596 597static YYParseState * 598yyNewState(unsigned size) 599{ 600 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState)); 601 if (p == NULL) return NULL; 602 603 p->yystack.stacksize = size; 604 if (size == 0) 605 { 606 p->yystack.s_base = NULL; 607 p->yystack.l_base = NULL; 608#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 609 p->yystack.p_base = NULL; 610#endif 611 return p; 612 } 613 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT)); 614 if (p->yystack.s_base == NULL) return NULL; 615 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE)); 616 if (p->yystack.l_base == NULL) return NULL; 617 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE)); 618#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 619 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE)); 620 if (p->yystack.p_base == NULL) return NULL; 621 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE)); 622#endif 623 624 return p; 625} 626 627static void 628yyFreeState(YYParseState *p) 629{ 630 yyfreestack(&p->yystack); 631 free(p); 632} 633#endif /* YYBTYACC */ 634 635#define YYABORT goto yyabort 636#define YYREJECT goto yyabort 637#define YYACCEPT goto yyaccept 638#define YYERROR goto yyerrlab 639#if YYBTYACC 640#define YYVALID do { if (yyps->save) goto yyvalid; } while(0) 641#define YYVALID_NESTED do { if (yyps->save && \ 642 yyps->save->save == 0) goto yyvalid; } while(0) 643#endif /* YYBTYACC */ 644 645int 646YYPARSE_DECL() 647{ 648 int yym, yyn, yystate, yyresult; 649#if YYBTYACC 650 int yynewerrflag; 651 YYParseState *yyerrctx = NULL; 652#endif /* YYBTYACC */ 653#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 654 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */ 655#endif 656#if YYDEBUG 657 const char *yys; 658 659 if ((yys = getenv("YYDEBUG")) != NULL) 660 { 661 yyn = *yys; 662 if (yyn >= '0' && yyn <= '9') 663 yydebug = yyn - '0'; 664 } 665 if (yydebug) 666 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX); 667#endif 668#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 669 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range)); 670#endif 671 672#if YYBTYACC 673 yyps = yyNewState(0); if (yyps == 0) goto yyenomem; 674 yyps->save = 0; 675#endif /* YYBTYACC */ 676 yym = 0; 677 /* yyn is set below */ 678 yynerrs = 0; 679 yyerrflag = 0; 680 yychar = YYEMPTY; 681 yystate = 0; 682 683#if YYPURE 684 memset(&yystack, 0, sizeof(yystack)); 685#endif 686 687 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 688 yystack.s_mark = yystack.s_base; 689 yystack.l_mark = yystack.l_base; 690#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 691 yystack.p_mark = yystack.p_base; 692#endif 693 yystate = 0; 694 *yystack.s_mark = 0; 695 696yyloop: 697 if ((yyn = yydefred[yystate]) != 0) goto yyreduce; 698 if (yychar < 0) 699 { 700#if YYBTYACC 701 do { 702 if (yylvp < yylve) 703 { 704 /* we're currently re-reading tokens */ 705 yylval = *yylvp++; 706#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 707 yylloc = *yylpp++; 708#endif 709 yychar = *yylexp++; 710 break; 711 } 712 if (yyps->save) 713 { 714 /* in trial mode; save scanner results for future parse attempts */ 715 if (yylvp == yylvlim) 716 { /* Enlarge lexical value queue */ 717 size_t p = (size_t) (yylvp - yylvals); 718 size_t s = (size_t) (yylvlim - yylvals); 719 720 s += YYLVQUEUEGROWTH; 721 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem; 722 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem; 723#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 724 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem; 725#endif 726 yylvp = yylve = yylvals + p; 727 yylvlim = yylvals + s; 728#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 729 yylpp = yylpe = yylpsns + p; 730 yylplim = yylpsns + s; 731#endif 732 yylexp = yylexemes + p; 733 } 734 *yylexp = (YYINT) YYLEX; 735 *yylvp++ = yylval; 736 yylve++; 737#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 738 *yylpp++ = yylloc; 739 yylpe++; 740#endif 741 yychar = *yylexp++; 742 break; 743 } 744 /* normal operation, no conflict encountered */ 745#endif /* YYBTYACC */ 746 yychar = YYLEX; 747#if YYBTYACC 748 } while (0); 749#endif /* YYBTYACC */ 750 if (yychar < 0) yychar = YYEOF; 751#if YYDEBUG 752 if (yydebug) 753 { 754 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 755 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)", 756 YYDEBUGSTR, yydepth, yystate, yychar, yys); 757#ifdef YYSTYPE_TOSTRING 758#if YYBTYACC 759 if (!yytrial) 760#endif /* YYBTYACC */ 761 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval)); 762#endif 763 fputc('\n', stderr); 764 } 765#endif 766 } 767#if YYBTYACC 768 769 /* Do we have a conflict? */ 770 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 && 771 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 772 { 773 YYINT ctry; 774 775 if (yypath) 776 { 777 YYParseState *save; 778#if YYDEBUG 779 if (yydebug) 780 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n", 781 YYDEBUGSTR, yydepth, yystate); 782#endif 783 /* Switch to the next conflict context */ 784 save = yypath; 785 yypath = save->save; 786 save->save = NULL; 787 ctry = save->ctry; 788 if (save->state != yystate) YYABORT; 789 yyFreeState(save); 790 791 } 792 else 793 { 794 795 /* Unresolved conflict - start/continue trial parse */ 796 YYParseState *save; 797#if YYDEBUG 798 if (yydebug) 799 { 800 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate); 801 if (yyps->save) 802 fputs("ALREADY in conflict, continuing trial parse.\n", stderr); 803 else 804 fputs("Starting trial parse.\n", stderr); 805 } 806#endif 807 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 808 if (save == NULL) goto yyenomem; 809 save->save = yyps->save; 810 save->state = yystate; 811 save->errflag = yyerrflag; 812 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base); 813 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 814 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base); 815 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 816#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 817 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base); 818 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 819#endif 820 ctry = yytable[yyn]; 821 if (yyctable[ctry] == -1) 822 { 823#if YYDEBUG 824 if (yydebug && yychar >= YYEOF) 825 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth); 826#endif 827 ctry++; 828 } 829 save->ctry = ctry; 830 if (yyps->save == NULL) 831 { 832 /* If this is a first conflict in the stack, start saving lexemes */ 833 if (!yylexemes) 834 { 835 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT)); 836 if (yylexemes == NULL) goto yyenomem; 837 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE)); 838 if (yylvals == NULL) goto yyenomem; 839 yylvlim = yylvals + YYLVQUEUEGROWTH; 840#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 841 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE)); 842 if (yylpsns == NULL) goto yyenomem; 843 yylplim = yylpsns + YYLVQUEUEGROWTH; 844#endif 845 } 846 if (yylvp == yylve) 847 { 848 yylvp = yylve = yylvals; 849#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 850 yylpp = yylpe = yylpsns; 851#endif 852 yylexp = yylexemes; 853 if (yychar >= YYEOF) 854 { 855 *yylve++ = yylval; 856#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 857 *yylpe++ = yylloc; 858#endif 859 *yylexp = (YYINT) yychar; 860 yychar = YYEMPTY; 861 } 862 } 863 } 864 if (yychar >= YYEOF) 865 { 866 yylvp--; 867#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 868 yylpp--; 869#endif 870 yylexp--; 871 yychar = YYEMPTY; 872 } 873 save->lexeme = (int) (yylvp - yylvals); 874 yyps->save = save; 875 } 876 if (yytable[yyn] == ctry) 877 { 878#if YYDEBUG 879 if (yydebug) 880 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 881 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]); 882#endif 883 if (yychar < 0) 884 { 885 yylvp++; 886#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 887 yylpp++; 888#endif 889 yylexp++; 890 } 891 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) 892 goto yyoverflow; 893 yystate = yyctable[ctry]; 894 *++yystack.s_mark = (YYINT) yystate; 895 *++yystack.l_mark = yylval; 896#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 897 *++yystack.p_mark = yylloc; 898#endif 899 yychar = YYEMPTY; 900 if (yyerrflag > 0) --yyerrflag; 901 goto yyloop; 902 } 903 else 904 { 905 yyn = yyctable[ctry]; 906 goto yyreduce; 907 } 908 } /* End of code dealing with conflicts */ 909#endif /* YYBTYACC */ 910 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 && 911 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 912 { 913#if YYDEBUG 914 if (yydebug) 915 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n", 916 YYDEBUGSTR, yydepth, yystate, yytable[yyn]); 917#endif 918 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 919 yystate = yytable[yyn]; 920 *++yystack.s_mark = yytable[yyn]; 921 *++yystack.l_mark = yylval; 922#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 923 *++yystack.p_mark = yylloc; 924#endif 925 yychar = YYEMPTY; 926 if (yyerrflag > 0) --yyerrflag; 927 goto yyloop; 928 } 929 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 && 930 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar) 931 { 932 yyn = yytable[yyn]; 933 goto yyreduce; 934 } 935 if (yyerrflag != 0) goto yyinrecovery; 936#if YYBTYACC 937 938 yynewerrflag = 1; 939 goto yyerrhandler; 940 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 941 942yyerrlab: 943 /* explicit YYERROR from an action -- pop the rhs of the rule reduced 944 * before looking for error recovery */ 945 yystack.s_mark -= yym; 946 yystate = *yystack.s_mark; 947 yystack.l_mark -= yym; 948#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 949 yystack.p_mark -= yym; 950#endif 951 952 yynewerrflag = 0; 953yyerrhandler: 954 while (yyps->save) 955 { 956 int ctry; 957 YYParseState *save = yyps->save; 958#if YYDEBUG 959 if (yydebug) 960 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n", 961 YYDEBUGSTR, yydepth, yystate, yyps->save->state, 962 (int)(yylvp - yylvals - yyps->save->lexeme)); 963#endif 964 /* Memorize most forward-looking error state in case it's really an error. */ 965 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals) 966 { 967 /* Free old saved error context state */ 968 if (yyerrctx) yyFreeState(yyerrctx); 969 /* Create and fill out new saved error context state */ 970 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1)); 971 if (yyerrctx == NULL) goto yyenomem; 972 yyerrctx->save = yyps->save; 973 yyerrctx->state = yystate; 974 yyerrctx->errflag = yyerrflag; 975 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base); 976 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 977 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base); 978 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 979#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 980 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base); 981 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 982#endif 983 yyerrctx->lexeme = (int) (yylvp - yylvals); 984 } 985 yylvp = yylvals + save->lexeme; 986#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 987 yylpp = yylpsns + save->lexeme; 988#endif 989 yylexp = yylexemes + save->lexeme; 990 yychar = YYEMPTY; 991 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base); 992 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 993 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base); 994 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 995#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 996 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base); 997 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 998#endif 999 ctry = ++save->ctry; 1000 yystate = save->state; 1001 /* We tried shift, try reduce now */ 1002 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce; 1003 yyps->save = save->save; 1004 save->save = NULL; 1005 yyFreeState(save); 1006 1007 /* Nothing left on the stack -- error */ 1008 if (!yyps->save) 1009 { 1010#if YYDEBUG 1011 if (yydebug) 1012 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n", 1013 YYPREFIX, yydepth); 1014#endif 1015 /* Restore state as it was in the most forward-advanced error */ 1016 yylvp = yylvals + yyerrctx->lexeme; 1017#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1018 yylpp = yylpsns + yyerrctx->lexeme; 1019#endif 1020 yylexp = yylexemes + yyerrctx->lexeme; 1021 yychar = yylexp[-1]; 1022 yylval = yylvp[-1]; 1023#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1024 yylloc = yylpp[-1]; 1025#endif 1026 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base); 1027 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1028 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base); 1029 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1030#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1031 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base); 1032 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1033#endif 1034 yystate = yyerrctx->state; 1035 yyFreeState(yyerrctx); 1036 yyerrctx = NULL; 1037 } 1038 yynewerrflag = 1; 1039 } 1040 if (yynewerrflag == 0) goto yyinrecovery; 1041#endif /* YYBTYACC */ 1042 1043 YYERROR_CALL("syntax error"); 1044#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1045 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */ 1046#endif 1047 1048#if !YYBTYACC 1049 goto yyerrlab; /* redundant goto avoids 'unused label' warning */ 1050yyerrlab: 1051#endif 1052 ++yynerrs; 1053 1054yyinrecovery: 1055 if (yyerrflag < 3) 1056 { 1057 yyerrflag = 3; 1058 for (;;) 1059 { 1060 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 && 1061 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE) 1062 { 1063#if YYDEBUG 1064 if (yydebug) 1065 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n", 1066 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]); 1067#endif 1068 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1069 yystate = yytable[yyn]; 1070 *++yystack.s_mark = yytable[yyn]; 1071 *++yystack.l_mark = yylval; 1072#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1073 /* lookahead position is error end position */ 1074 yyerror_loc_range[2] = yylloc; 1075 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */ 1076 *++yystack.p_mark = yyloc; 1077#endif 1078 goto yyloop; 1079 } 1080 else 1081 { 1082#if YYDEBUG 1083 if (yydebug) 1084 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n", 1085 YYDEBUGSTR, yydepth, *yystack.s_mark); 1086#endif 1087 if (yystack.s_mark <= yystack.s_base) goto yyabort; 1088#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1089 /* the current TOS position is the error start position */ 1090 yyerror_loc_range[1] = *yystack.p_mark; 1091#endif 1092#if defined(YYDESTRUCT_CALL) 1093#if YYBTYACC 1094 if (!yytrial) 1095#endif /* YYBTYACC */ 1096#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1097 YYDESTRUCT_CALL("error: discarding state", 1098 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark); 1099#else 1100 YYDESTRUCT_CALL("error: discarding state", 1101 yystos[*yystack.s_mark], yystack.l_mark); 1102#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1103#endif /* defined(YYDESTRUCT_CALL) */ 1104 --yystack.s_mark; 1105 --yystack.l_mark; 1106#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1107 --yystack.p_mark; 1108#endif 1109 } 1110 } 1111 } 1112 else 1113 { 1114 if (yychar == YYEOF) goto yyabort; 1115#if YYDEBUG 1116 if (yydebug) 1117 { 1118 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1119 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n", 1120 YYDEBUGSTR, yydepth, yystate, yychar, yys); 1121 } 1122#endif 1123#if defined(YYDESTRUCT_CALL) 1124#if YYBTYACC 1125 if (!yytrial) 1126#endif /* YYBTYACC */ 1127#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1128 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc); 1129#else 1130 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval); 1131#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1132#endif /* defined(YYDESTRUCT_CALL) */ 1133 yychar = YYEMPTY; 1134 goto yyloop; 1135 } 1136 1137yyreduce: 1138 yym = yylen[yyn]; 1139#if YYDEBUG 1140 if (yydebug) 1141 { 1142 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)", 1143 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]); 1144#ifdef YYSTYPE_TOSTRING 1145#if YYBTYACC 1146 if (!yytrial) 1147#endif /* YYBTYACC */ 1148 if (yym > 0) 1149 { 1150 int i; 1151 fputc('<', stderr); 1152 for (i = yym; i > 0; i--) 1153 { 1154 if (i != yym) fputs(", ", stderr); 1155 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]], 1156 yystack.l_mark[1-i]), stderr); 1157 } 1158 fputc('>', stderr); 1159 } 1160#endif 1161 fputc('\n', stderr); 1162 } 1163#endif 1164 if (yym > 0) 1165 yyval = yystack.l_mark[1-yym]; 1166 else 1167 memset(&yyval, 0, sizeof yyval); 1168#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1169 1170 /* Perform position reduction */ 1171 memset(&yyloc, 0, sizeof(yyloc)); 1172#if YYBTYACC 1173 if (!yytrial) 1174#endif /* YYBTYACC */ 1175 { 1176 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym); 1177 /* just in case YYERROR is invoked within the action, save 1178 the start of the rhs as the error start position */ 1179 yyerror_loc_range[1] = yystack.p_mark[1-yym]; 1180 } 1181#endif 1182 1183 switch (yyn) 1184 { 1185case 1: 1186 if (!yytrial) 1187#line 62 "btyacc_destroy2.y" 1188 { yyval.nlist = yystack.l_mark[-5].nlist; } 1189#line 1190 "btyacc_destroy2.tab.c" 1190break; 1191case 2: 1192 if (!yytrial) 1193#line 64 "btyacc_destroy2.y" 1194 { yyval.nlist = yystack.l_mark[-3].nlist; } 1195#line 1196 "btyacc_destroy2.tab.c" 1196break; 1197case 3: 1198 if (!yytrial) 1199#line 67 "btyacc_destroy2.y" 1200 { yyval.cval = cGLOBAL; } 1201#line 1202 "btyacc_destroy2.tab.c" 1202break; 1203case 4: 1204 if (!yytrial) 1205#line 68 "btyacc_destroy2.y" 1206 { yyval.cval = cLOCAL; } 1207#line 1208 "btyacc_destroy2.tab.c" 1208break; 1209case 5: 1210 if (!yytrial) 1211#line 71 "btyacc_destroy2.y" 1212 { yyval.tval = tREAL; } 1213#line 1214 "btyacc_destroy2.tab.c" 1214break; 1215case 6: 1216 if (!yytrial) 1217#line 72 "btyacc_destroy2.y" 1218 { yyval.tval = tINTEGER; } 1219#line 1220 "btyacc_destroy2.tab.c" 1220break; 1221case 7: 1222 if (!yytrial) 1223#line 76 "btyacc_destroy2.y" 1224 { yyval.nlist->s = mksymbol(yystack.l_mark[-2].tval, yystack.l_mark[-2].cval, yystack.l_mark[0].id); 1225 yyval.nlist->next = yystack.l_mark[-1].nlist; 1226 } 1227#line 1228 "btyacc_destroy2.tab.c" 1228break; 1229case 8: 1230 if (!yytrial) 1231#line 80 "btyacc_destroy2.y" 1232 { yyval.nlist->s = mksymbol(0, 0, yystack.l_mark[0].id); 1233 yyval.nlist->next = NULL; 1234 } 1235#line 1236 "btyacc_destroy2.tab.c" 1236break; 1237case 9: 1238 if (!yytrial) 1239#line 86 "btyacc_destroy2.y" 1240 { yyval.nlist = yystack.l_mark[-5].nlist; } 1241#line 1242 "btyacc_destroy2.tab.c" 1242break; 1243#line 1244 "btyacc_destroy2.tab.c" 1244 default: 1245 break; 1246 } 1247 yystack.s_mark -= yym; 1248 yystate = *yystack.s_mark; 1249 yystack.l_mark -= yym; 1250#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1251 yystack.p_mark -= yym; 1252#endif 1253 yym = yylhs[yyn]; 1254 if (yystate == 0 && yym == 0) 1255 { 1256#if YYDEBUG 1257 if (yydebug) 1258 { 1259 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1260#ifdef YYSTYPE_TOSTRING 1261#if YYBTYACC 1262 if (!yytrial) 1263#endif /* YYBTYACC */ 1264 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval)); 1265#endif 1266 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL); 1267 } 1268#endif 1269 yystate = YYFINAL; 1270 *++yystack.s_mark = YYFINAL; 1271 *++yystack.l_mark = yyval; 1272#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1273 *++yystack.p_mark = yyloc; 1274#endif 1275 if (yychar < 0) 1276 { 1277#if YYBTYACC 1278 do { 1279 if (yylvp < yylve) 1280 { 1281 /* we're currently re-reading tokens */ 1282 yylval = *yylvp++; 1283#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1284 yylloc = *yylpp++; 1285#endif 1286 yychar = *yylexp++; 1287 break; 1288 } 1289 if (yyps->save) 1290 { 1291 /* in trial mode; save scanner results for future parse attempts */ 1292 if (yylvp == yylvlim) 1293 { /* Enlarge lexical value queue */ 1294 size_t p = (size_t) (yylvp - yylvals); 1295 size_t s = (size_t) (yylvlim - yylvals); 1296 1297 s += YYLVQUEUEGROWTH; 1298 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) 1299 goto yyenomem; 1300 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) 1301 goto yyenomem; 1302#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1303 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) 1304 goto yyenomem; 1305#endif 1306 yylvp = yylve = yylvals + p; 1307 yylvlim = yylvals + s; 1308#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1309 yylpp = yylpe = yylpsns + p; 1310 yylplim = yylpsns + s; 1311#endif 1312 yylexp = yylexemes + p; 1313 } 1314 *yylexp = (YYINT) YYLEX; 1315 *yylvp++ = yylval; 1316 yylve++; 1317#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1318 *yylpp++ = yylloc; 1319 yylpe++; 1320#endif 1321 yychar = *yylexp++; 1322 break; 1323 } 1324 /* normal operation, no conflict encountered */ 1325#endif /* YYBTYACC */ 1326 yychar = YYLEX; 1327#if YYBTYACC 1328 } while (0); 1329#endif /* YYBTYACC */ 1330 if (yychar < 0) yychar = YYEOF; 1331#if YYDEBUG 1332 if (yydebug) 1333 { 1334 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN]; 1335 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n", 1336 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys); 1337 } 1338#endif 1339 } 1340 if (yychar == YYEOF) goto yyaccept; 1341 goto yyloop; 1342 } 1343 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 && 1344 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate) 1345 yystate = yytable[yyn]; 1346 else 1347 yystate = yydgoto[yym]; 1348#if YYDEBUG 1349 if (yydebug) 1350 { 1351 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth); 1352#ifdef YYSTYPE_TOSTRING 1353#if YYBTYACC 1354 if (!yytrial) 1355#endif /* YYBTYACC */ 1356 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval)); 1357#endif 1358 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate); 1359 } 1360#endif 1361 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow; 1362 *++yystack.s_mark = (YYINT) yystate; 1363 *++yystack.l_mark = yyval; 1364#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1365 *++yystack.p_mark = yyloc; 1366#endif 1367 goto yyloop; 1368#if YYBTYACC 1369 1370 /* Reduction declares that this path is valid. Set yypath and do a full parse */ 1371yyvalid: 1372 if (yypath) YYABORT; 1373 while (yyps->save) 1374 { 1375 YYParseState *save = yyps->save; 1376 yyps->save = save->save; 1377 save->save = yypath; 1378 yypath = save; 1379 } 1380#if YYDEBUG 1381 if (yydebug) 1382 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n", 1383 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme)); 1384#endif 1385 if (yyerrctx) 1386 { 1387 yyFreeState(yyerrctx); 1388 yyerrctx = NULL; 1389 } 1390 yylvp = yylvals + yypath->lexeme; 1391#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1392 yylpp = yylpsns + yypath->lexeme; 1393#endif 1394 yylexp = yylexemes + yypath->lexeme; 1395 yychar = YYEMPTY; 1396 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base); 1397 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT)); 1398 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base); 1399 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE)); 1400#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1401 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base); 1402 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE)); 1403#endif 1404 yystate = yypath->state; 1405 goto yyloop; 1406#endif /* YYBTYACC */ 1407 1408yyoverflow: 1409 YYERROR_CALL("yacc stack overflow"); 1410#if YYBTYACC 1411 goto yyabort_nomem; 1412yyenomem: 1413 YYERROR_CALL("memory exhausted"); 1414yyabort_nomem: 1415#endif /* YYBTYACC */ 1416 yyresult = 2; 1417 goto yyreturn; 1418 1419yyabort: 1420 yyresult = 1; 1421 goto yyreturn; 1422 1423yyaccept: 1424#if YYBTYACC 1425 if (yyps->save) goto yyvalid; 1426#endif /* YYBTYACC */ 1427 yyresult = 0; 1428 1429yyreturn: 1430#if defined(YYDESTRUCT_CALL) 1431 if (yychar != YYEOF && yychar != YYEMPTY) 1432#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1433 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc); 1434#else 1435 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval); 1436#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1437 1438 { 1439 YYSTYPE *pv; 1440#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) 1441 YYLTYPE *pp; 1442 1443 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp) 1444 YYDESTRUCT_CALL("cleanup: discarding state", 1445 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp); 1446#else 1447 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv) 1448 YYDESTRUCT_CALL("cleanup: discarding state", 1449 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv); 1450#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */ 1451 } 1452#endif /* defined(YYDESTRUCT_CALL) */ 1453 1454#if YYBTYACC 1455 if (yyerrctx) 1456 { 1457 yyFreeState(yyerrctx); 1458 yyerrctx = NULL; 1459 } 1460 while (yyps) 1461 { 1462 YYParseState *save = yyps; 1463 yyps = save->save; 1464 save->save = NULL; 1465 yyFreeState(save); 1466 } 1467 while (yypath) 1468 { 1469 YYParseState *save = yypath; 1470 yypath = save->save; 1471 save->save = NULL; 1472 yyFreeState(save); 1473 } 1474#endif /* YYBTYACC */ 1475 yyfreestack(&yystack); 1476 return (yyresult); 1477} 1478