| 1 | m4_divert(-1) -*- C -*- |
| 2 | |
| 3 | # GLR skeleton for Bison |
| 4 | # Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. |
| 5 | |
| 6 | # This program is free software; you can redistribute it and/or modify |
| 7 | # it under the terms of the GNU General Public License as published by |
| 8 | # the Free Software Foundation; either version 2 of the License, or |
| 9 | # (at your option) any later version. |
| 10 | |
| 11 | # This program is distributed in the hope that it will be useful, |
| 12 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | # GNU General Public License for more details. |
| 15 | |
| 16 | # You should have received a copy of the GNU General Public License |
| 17 | # along with this program; if not, write to the Free Software |
| 18 | # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 19 | # 02110-1301 USA |
| 20 | |
| 21 | |
| 22 | m4_include(b4_pkgdatadir/[c.m4]) |
| 23 | |
| 24 | ## ---------------- ## |
| 25 | ## Default values. ## |
| 26 | ## ---------------- ## |
| 27 | |
| 28 | # Stack parameters. |
| 29 | m4_define_default([b4_stack_depth_max], [10000]) |
| 30 | m4_define_default([b4_stack_depth_init], [200]) |
| 31 | |
| 32 | |
| 33 | |
| 34 | ## ------------------------ ## |
| 35 | ## Pure/impure interfaces. ## |
| 36 | ## ------------------------ ## |
| 37 | |
| 38 | |
| 39 | # b4_user_formals |
| 40 | # --------------- |
| 41 | # The possible parse-params formal arguments preceded by a comma. |
| 42 | # |
| 43 | # This is not shared with yacc.c in c.m4 because GLR relies on ISO C |
| 44 | # formal argument declarations. |
| 45 | m4_define([b4_user_formals], |
| 46 | [m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])]) |
| 47 | |
| 48 | |
| 49 | # b4_lex_param |
| 50 | # ------------ |
| 51 | # Accumule in b4_lex_param all the yylex arguments. |
| 52 | # Yes, this is quite ugly... |
| 53 | m4_define([b4_lex_param], |
| 54 | m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl |
| 55 | b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl |
| 56 | m4_ifdef([b4_lex_param], [, ]b4_lex_param))) |
| 57 | |
| 58 | |
| 59 | # b4_yyerror_args |
| 60 | # --------------- |
| 61 | # Optional effective arguments passed to yyerror: user args plus yylloc, and |
| 62 | # a trailing comma. |
| 63 | m4_define([b4_yyerror_args], |
| 64 | [b4_pure_if([b4_location_if([yylocp, ])])dnl |
| 65 | m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) |
| 66 | |
| 67 | |
| 68 | # b4_lyyerror_args |
| 69 | # ---------------- |
| 70 | # Same as above, but on the look-ahead, hence &yylloc instead of yylocp. |
| 71 | m4_define([b4_lyyerror_args], |
| 72 | [b4_pure_if([b4_location_if([&yylloc, ])])dnl |
| 73 | m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) |
| 74 | |
| 75 | |
| 76 | # b4_pure_args |
| 77 | # ------------ |
| 78 | # Same as b4_yyerror_args, but with a leading comma. |
| 79 | m4_define([b4_pure_args], |
| 80 | [b4_pure_if([b4_location_if([, yylocp])])[]b4_user_args]) |
| 81 | |
| 82 | |
| 83 | # b4_lpure_args |
| 84 | # ------------- |
| 85 | # Same as above, but on the look-ahead, hence &yylloc instead of yylocp. |
| 86 | m4_define([b4_lpure_args], |
| 87 | [b4_pure_if([b4_location_if([, &yylloc])])[]b4_user_args]) |
| 88 | |
| 89 | |
| 90 | # b4_pure_formals |
| 91 | # --------------- |
| 92 | # Arguments passed to yyerror: user formals plus yylocp. |
| 93 | m4_define([b4_pure_formals], |
| 94 | [b4_pure_if([b4_location_if([, YYLTYPE *yylocp])])[]b4_user_formals]) |
| 95 | |
| 96 | |
| 97 | ## ----------------- ## |
| 98 | ## Semantic Values. ## |
| 99 | ## ----------------- ## |
| 100 | |
| 101 | |
| 102 | # b4_lhs_value([TYPE]) |
| 103 | # -------------------- |
| 104 | # Expansion of $<TYPE>$. |
| 105 | m4_define([b4_lhs_value], |
| 106 | [((*yyvalp)[]m4_ifval([$1], [.$1]))]) |
| 107 | |
| 108 | |
| 109 | # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) |
| 110 | # -------------------------------------- |
| 111 | # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH |
| 112 | # symbols on RHS. |
| 113 | m4_define([b4_rhs_value], |
| 114 | [(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))]) |
| 115 | |
| 116 | |
| 117 | |
| 118 | ## ----------- ## |
| 119 | ## Locations. ## |
| 120 | ## ----------- ## |
| 121 | |
| 122 | # b4_lhs_location() |
| 123 | # ----------------- |
| 124 | # Expansion of @$. |
| 125 | m4_define([b4_lhs_location], |
| 126 | [(*yylocp)]) |
| 127 | |
| 128 | |
| 129 | # b4_rhs_location(RULE-LENGTH, NUM) |
| 130 | # --------------------------------- |
| 131 | # Expansion of @NUM, where the current rule has RULE-LENGTH symbols |
| 132 | # on RHS. |
| 133 | m4_define([b4_rhs_location], |
| 134 | [(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)]) |
| 135 | |
| 136 | |
| 137 | |
| 138 | ## -------------- ## |
| 139 | ## Output files. ## |
| 140 | ## -------------- ## |
| 141 | |
| 142 | # We do want M4 expansion after # for CPP macros. |
| 143 | m4_changecom() |
| 144 | m4_divert(0)dnl |
| 145 | @output @output_parser_name@ |
| 146 | b4_copyright([Skeleton parser for GLR parsing with Bison], |
| 147 | [2002, 2003, 2004, 2005, 2006]) |
| 148 | [ |
| 149 | /* This is the parser code for GLR (Generalized LR) parser. */ |
| 150 | |
| 151 | ]b4_identification |
| 152 | |
| 153 | m4_if(b4_prefix[], [yy], [], |
| 154 | [/* Substitute the variable and function names. */ |
| 155 | #define yyparse b4_prefix[]parse |
| 156 | #define yylex b4_prefix[]lex |
| 157 | #define yyerror b4_prefix[]error |
| 158 | #define yylval b4_prefix[]lval |
| 159 | #define yychar b4_prefix[]char |
| 160 | #define yydebug b4_prefix[]debug |
| 161 | #define yynerrs b4_prefix[]nerrs |
| 162 | #define yylloc b4_prefix[]lloc]) |
| 163 | |
| 164 | dnl # b4_shared_declarations |
| 165 | dnl # ---------------------- |
| 166 | dnl # Declaration that might either go into the header (if --defines) |
| 167 | dnl # or open coded in the parser body. |
| 168 | m4_define([b4_shared_declarations], |
| 169 | [b4_token_enums(b4_tokens)[ |
| 170 | |
| 171 | /* Copy the first part of user declarations. */ |
| 172 | ]b4_pre_prologue[ |
| 173 | |
| 174 | #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) |
| 175 | ]m4_ifdef([b4_stype], |
| 176 | [typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ]) |
| 177 | b4_stype |
| 178 | /* Line __line__ of glr.c. */ |
| 179 | b4_syncline([@oline@], [@ofile@]) |
| 180 | YYSTYPE;], |
| 181 | [typedef int YYSTYPE;])[ |
| 182 | # define YYSTYPE_IS_DECLARED 1 |
| 183 | # define YYSTYPE_IS_TRIVIAL 1 |
| 184 | #endif |
| 185 | |
| 186 | #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) |
| 187 | typedef struct YYLTYPE |
| 188 | { |
| 189 | ]b4_location_if([ |
| 190 | int first_line; |
| 191 | int first_column; |
| 192 | int last_line; |
| 193 | int last_column; |
| 194 | ],[ |
| 195 | char yydummy; |
| 196 | ])[ |
| 197 | } YYLTYPE; |
| 198 | # define YYLTYPE_IS_DECLARED 1 |
| 199 | # define YYLTYPE_IS_TRIVIAL 1 |
| 200 | #endif |
| 201 | ]]) |
| 202 | |
| 203 | m4_if(b4_defines_flag, 0, |
| 204 | [b4_shared_declarations], |
| 205 | [#include @output_header_name@])[ |
| 206 | |
| 207 | /* Enabling traces. */ |
| 208 | #ifndef YYDEBUG |
| 209 | # define YYDEBUG ]b4_debug[ |
| 210 | #endif |
| 211 | |
| 212 | /* Enabling verbose error messages. */ |
| 213 | #ifdef YYERROR_VERBOSE |
| 214 | # undef YYERROR_VERBOSE |
| 215 | # define YYERROR_VERBOSE 1 |
| 216 | #else |
| 217 | # define YYERROR_VERBOSE ]b4_error_verbose[ |
| 218 | #endif |
| 219 | |
| 220 | /* Enabling the token table. */ |
| 221 | #ifndef YYTOKEN_TABLE |
| 222 | # define YYTOKEN_TABLE ]b4_token_table[ |
| 223 | #endif |
| 224 | |
| 225 | /* Default (constant) value used for initialization for null |
| 226 | right-hand sides. Unlike the standard yacc.c template, |
| 227 | here we set the default value of $$ to a zeroed-out value. |
| 228 | Since the default value is undefined, this behavior is |
| 229 | technically correct. */ |
| 230 | static YYSTYPE yyval_default; |
| 231 | |
| 232 | /* Copy the second part of user declarations. */ |
| 233 | ]b4_post_prologue[ |
| 234 | |
| 235 | ]/* Line __line__ of glr.c. */ |
| 236 | b4_syncline([@oline@], [@ofile@]) |
| 237 | [ |
| 238 | #include <stdio.h> |
| 239 | #include <stdlib.h> |
| 240 | #include <string.h> |
| 241 | #include <stdarg.h> |
| 242 | |
| 243 | #ifndef YY_ |
| 244 | # if YYENABLE_NLS |
| 245 | # if ENABLE_NLS |
| 246 | # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ |
| 247 | # define YY_(msgid) dgettext ("bison-runtime", msgid) |
| 248 | # endif |
| 249 | # endif |
| 250 | # ifndef YY_ |
| 251 | # define YY_(msgid) msgid |
| 252 | # endif |
| 253 | #endif |
| 254 | |
| 255 | /* Suppress unused-variable warnings by "using" E. */ |
| 256 | #if !defined (lint) || defined (__GNUC__) |
| 257 | # define YYUSE(e) ((void) (e)) |
| 258 | #else |
| 259 | # define YYUSE(e) /* empty */ |
| 260 | #endif |
| 261 | |
| 262 | /* Identity function, used to suppress warnings about constant conditions. */ |
| 263 | #ifndef lint |
| 264 | # define YYID(n) (n) |
| 265 | #else |
| 266 | ]b4_c_function_def([YYID], [static int], [[int i], [i]])[ |
| 267 | { |
| 268 | return i; |
| 269 | } |
| 270 | #endif |
| 271 | |
| 272 | #ifndef YYFREE |
| 273 | # define YYFREE free |
| 274 | #endif |
| 275 | #ifndef YYMALLOC |
| 276 | # define YYMALLOC malloc |
| 277 | #endif |
| 278 | #ifndef YYREALLOC |
| 279 | # define YYREALLOC realloc |
| 280 | #endif |
| 281 | |
| 282 | #define YYSIZEMAX ((size_t) -1) |
| 283 | |
| 284 | #ifdef __cplusplus |
| 285 | typedef bool yybool; |
| 286 | #else |
| 287 | typedef unsigned char yybool; |
| 288 | #endif |
| 289 | #define yytrue 1 |
| 290 | #define yyfalse 0 |
| 291 | |
| 292 | #ifndef YYSETJMP |
| 293 | # include <setjmp.h> |
| 294 | # define YYJMP_BUF jmp_buf |
| 295 | # define YYSETJMP(env) setjmp (env) |
| 296 | # define YYLONGJMP(env, val) longjmp (env, val) |
| 297 | #endif |
| 298 | |
| 299 | /*-----------------. |
| 300 | | GCC extensions. | |
| 301 | `-----------------*/ |
| 302 | |
| 303 | #ifndef __attribute__ |
| 304 | /* This feature is available in gcc versions 2.5 and later. */ |
| 305 | # if (!defined (__GNUC__) || __GNUC__ < 2 \ |
| 306 | || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__) |
| 307 | # define __attribute__(Spec) /* empty */ |
| 308 | # endif |
| 309 | #endif |
| 310 | |
| 311 | ]b4_location_if([#define YYOPTIONAL_LOC(Name) Name],[ |
| 312 | #ifdef __cplusplus |
| 313 | # define YYOPTIONAL_LOC(Name) /* empty */ |
| 314 | #else |
| 315 | # define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__)) |
| 316 | #endif])[ |
| 317 | |
| 318 | #ifndef YYASSERT |
| 319 | # define YYASSERT(condition) ((void) ((condition) || (abort (), 0))) |
| 320 | #endif |
| 321 | |
| 322 | /* YYFINAL -- State number of the termination state. */ |
| 323 | #define YYFINAL ]b4_final_state_number[ |
| 324 | /* YYLAST -- Last index in YYTABLE. */ |
| 325 | #define YYLAST ]b4_last[ |
| 326 | |
| 327 | /* YYNTOKENS -- Number of terminals. */ |
| 328 | #define YYNTOKENS ]b4_tokens_number[ |
| 329 | /* YYNNTS -- Number of nonterminals. */ |
| 330 | #define YYNNTS ]b4_nterms_number[ |
| 331 | /* YYNRULES -- Number of rules. */ |
| 332 | #define YYNRULES ]b4_rules_number[ |
| 333 | /* YYNRULES -- Number of states. */ |
| 334 | #define YYNSTATES ]b4_states_number[ |
| 335 | /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ |
| 336 | #define YYMAXRHS ]b4_r2_max[ |
| 337 | /* YYMAXLEFT -- Maximum number of symbols to the left of a handle |
| 338 | accessed by $0, $-1, etc., in any rule. */ |
| 339 | #define YYMAXLEFT ]b4_max_left_semantic_context[ |
| 340 | |
| 341 | /* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */ |
| 342 | #define YYUNDEFTOK ]b4_undef_token_number[ |
| 343 | #define YYMAXUTOK ]b4_user_token_number_max[ |
| 344 | |
| 345 | #define YYTRANSLATE(YYX) \ |
| 346 | ((YYX <= 0) ? YYEOF : \ |
| 347 | (unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
| 348 | |
| 349 | /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
| 350 | static const ]b4_int_type_for([b4_translate])[ yytranslate[] = |
| 351 | { |
| 352 | ]b4_translate[ |
| 353 | }; |
| 354 | |
| 355 | #if YYDEBUG |
| 356 | /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
| 357 | YYRHS. */ |
| 358 | static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = |
| 359 | { |
| 360 | ]b4_prhs[ |
| 361 | }; |
| 362 | |
| 363 | /* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
| 364 | static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = |
| 365 | { |
| 366 | ]b4_rhs[ |
| 367 | }; |
| 368 | |
| 369 | /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
| 370 | static const ]b4_int_type_for([b4_rline])[ yyrline[] = |
| 371 | { |
| 372 | ]b4_rline[ |
| 373 | }; |
| 374 | #endif |
| 375 | |
| 376 | #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
| 377 | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
| 378 | First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
| 379 | static const char *const yytname[] = |
| 380 | { |
| 381 | ]b4_tname[ |
| 382 | }; |
| 383 | #endif |
| 384 | |
| 385 | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
| 386 | static const ]b4_int_type_for([b4_r1])[ yyr1[] = |
| 387 | { |
| 388 | ]b4_r1[ |
| 389 | }; |
| 390 | |
| 391 | /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
| 392 | static const ]b4_int_type_for([b4_r2])[ yyr2[] = |
| 393 | { |
| 394 | ]b4_r2[ |
| 395 | }; |
| 396 | |
| 397 | /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ |
| 398 | static const ]b4_int_type_for([b4_dprec])[ yydprec[] = |
| 399 | { |
| 400 | ]b4_dprec[ |
| 401 | }; |
| 402 | |
| 403 | /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ |
| 404 | static const ]b4_int_type_for([b4_merger])[ yymerger[] = |
| 405 | { |
| 406 | ]b4_merger[ |
| 407 | }; |
| 408 | |
| 409 | /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE |
| 410 | doesn't specify something else to do. Zero means the default is an |
| 411 | error. */ |
| 412 | static const ]b4_int_type_for([b4_defact])[ yydefact[] = |
| 413 | { |
| 414 | ]b4_defact[ |
| 415 | }; |
| 416 | |
| 417 | /* YYPDEFGOTO[NTERM-NUM]. */ |
| 418 | static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = |
| 419 | { |
| 420 | ]b4_defgoto[ |
| 421 | }; |
| 422 | |
| 423 | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
| 424 | STATE-NUM. */ |
| 425 | #define YYPACT_NINF ]b4_pact_ninf[ |
| 426 | static const ]b4_int_type_for([b4_pact])[ yypact[] = |
| 427 | { |
| 428 | ]b4_pact[ |
| 429 | }; |
| 430 | |
| 431 | /* YYPGOTO[NTERM-NUM]. */ |
| 432 | static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = |
| 433 | { |
| 434 | ]b4_pgoto[ |
| 435 | }; |
| 436 | |
| 437 | /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
| 438 | positive, shift that token. If negative, reduce the rule which |
| 439 | number is the opposite. If zero, do what YYDEFACT says. |
| 440 | If YYTABLE_NINF, syntax error. */ |
| 441 | #define YYTABLE_NINF ]b4_table_ninf[ |
| 442 | static const ]b4_int_type_for([b4_table])[ yytable[] = |
| 443 | { |
| 444 | ]b4_table[ |
| 445 | }; |
| 446 | |
| 447 | /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of |
| 448 | list of conflicting reductions corresponding to action entry for |
| 449 | state STATE-NUM in yytable. 0 means no conflicts. The list in |
| 450 | yyconfl is terminated by a rule number of 0. */ |
| 451 | static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = |
| 452 | { |
| 453 | ]b4_conflict_list_heads[ |
| 454 | }; |
| 455 | |
| 456 | /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by |
| 457 | 0, pointed into by YYCONFLP. */ |
| 458 | ]dnl Do not use b4_int_type_for here, since there are places where |
| 459 | dnl pointers onto yyconfl are taken, which type is "short int *". |
| 460 | dnl We probably ought to introduce a type for confl. |
| 461 | [static const short int yyconfl[] = |
| 462 | { |
| 463 | ]b4_conflicting_rules[ |
| 464 | }; |
| 465 | |
| 466 | static const ]b4_int_type_for([b4_check])[ yycheck[] = |
| 467 | { |
| 468 | ]b4_check[ |
| 469 | }; |
| 470 | |
| 471 | /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
| 472 | symbol of state STATE-NUM. */ |
| 473 | static const ]b4_int_type_for([b4_stos])[ yystos[] = |
| 474 | { |
| 475 | ]b4_stos[ |
| 476 | }; |
| 477 | |
| 478 | \f |
| 479 | /* Prevent warning if -Wmissing-prototypes. */ |
| 480 | ]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[ |
| 481 | |
| 482 | /* Error token number */ |
| 483 | #define YYTERROR 1 |
| 484 | |
| 485 | /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
| 486 | If N is 0, then set CURRENT to the empty location which ends |
| 487 | the previous symbol: RHS[0] (always defined). */ |
| 488 | |
| 489 | ]b4_location_if([[ |
| 490 | #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) |
| 491 | #ifndef YYLLOC_DEFAULT |
| 492 | # define YYLLOC_DEFAULT(Current, Rhs, N) \ |
| 493 | do \ |
| 494 | if (YYID (N)) \ |
| 495 | { \ |
| 496 | (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ |
| 497 | (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ |
| 498 | (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ |
| 499 | (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ |
| 500 | } \ |
| 501 | else \ |
| 502 | { \ |
| 503 | (Current).first_line = (Current).last_line = \ |
| 504 | YYRHSLOC (Rhs, 0).last_line; \ |
| 505 | (Current).first_column = (Current).last_column = \ |
| 506 | YYRHSLOC (Rhs, 0).last_column; \ |
| 507 | } \ |
| 508 | while (YYID (0)) |
| 509 | |
| 510 | /* YY_LOCATION_PRINT -- Print the location on the stream. |
| 511 | This macro was not mandated originally: define only if we know |
| 512 | we won't break user code: when these are the locations we know. */ |
| 513 | |
| 514 | # define YY_LOCATION_PRINT(File, Loc) \ |
| 515 | fprintf (File, "%d.%d-%d.%d", \ |
| 516 | (Loc).first_line, (Loc).first_column, \ |
| 517 | (Loc).last_line, (Loc).last_column) |
| 518 | #endif |
| 519 | ]],[ |
| 520 | #ifndef YYLLOC_DEFAULT |
| 521 | # define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0) |
| 522 | #endif |
| 523 | ])[ |
| 524 | |
| 525 | #ifndef YY_LOCATION_PRINT |
| 526 | # define YY_LOCATION_PRINT(File, Loc) ((void) 0) |
| 527 | #endif |
| 528 | |
| 529 | |
| 530 | /* YYLEX -- calling `yylex' with the right arguments. */ |
| 531 | #define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ |
| 532 | |
| 533 | ]b4_pure_if( |
| 534 | [ |
| 535 | #undef yynerrs |
| 536 | #define yynerrs (yystackp->yyerrcnt) |
| 537 | #undef yychar |
| 538 | #define yychar (yystackp->yyrawchar) |
| 539 | #undef yylval |
| 540 | #define yylval (yystackp->yyval) |
| 541 | #undef yylloc |
| 542 | #define yylloc (yystackp->yyloc) |
| 543 | m4_if(b4_prefix[], [yy], [], |
| 544 | [#define b4_prefix[]nerrs yynerrs |
| 545 | #define b4_prefix[]char yychar |
| 546 | #define b4_prefix[]lval yylval |
| 547 | #define b4_prefix[]lloc yylloc])], |
| 548 | [YYSTYPE yylval; |
| 549 | |
| 550 | YYLTYPE yylloc; |
| 551 | |
| 552 | int yynerrs; |
| 553 | int yychar;])[ |
| 554 | |
| 555 | static const int YYEOF = 0; |
| 556 | static const int YYEMPTY = -2; |
| 557 | |
| 558 | typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; |
| 559 | |
| 560 | #define YYCHK(YYE) \ |
| 561 | do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \ |
| 562 | while (YYID (0)) |
| 563 | |
| 564 | #if YYDEBUG |
| 565 | |
| 566 | #if ! defined (YYFPRINTF) |
| 567 | # define YYFPRINTF fprintf |
| 568 | #endif |
| 569 | |
| 570 | # define YYDPRINTF(Args) \ |
| 571 | do { \ |
| 572 | if (yydebug) \ |
| 573 | YYFPRINTF Args; \ |
| 574 | } while (YYID (0)) |
| 575 | |
| 576 | ]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[ |
| 577 | |
| 578 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
| 579 | do { \ |
| 580 | if (yydebug) \ |
| 581 | { \ |
| 582 | YYFPRINTF (stderr, "%s ", Title); \ |
| 583 | yy_symbol_print (stderr, Type, \ |
| 584 | Value]b4_location_if([, Location])[]b4_user_args[); \ |
| 585 | YYFPRINTF (stderr, "\n"); \ |
| 586 | } \ |
| 587 | } while (YYID (0)) |
| 588 | |
| 589 | /* Nonzero means print parse trace. It is left uninitialized so that |
| 590 | multiple parsers can coexist. */ |
| 591 | int yydebug; |
| 592 | |
| 593 | #else /* !YYDEBUG */ |
| 594 | |
| 595 | # define YYDPRINTF(Args) |
| 596 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location) |
| 597 | |
| 598 | #endif /* !YYDEBUG */ |
| 599 | |
| 600 | /* YYINITDEPTH -- initial size of the parser's stacks. */ |
| 601 | #ifndef YYINITDEPTH |
| 602 | # define YYINITDEPTH ]b4_stack_depth_init[ |
| 603 | #endif |
| 604 | |
| 605 | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
| 606 | if the built-in stack extension method is used). |
| 607 | |
| 608 | Do not make this value too large; the results are undefined if |
| 609 | SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) |
| 610 | evaluated with infinite-precision integer arithmetic. */ |
| 611 | |
| 612 | #ifndef YYMAXDEPTH |
| 613 | # define YYMAXDEPTH ]b4_stack_depth_max[ |
| 614 | #endif |
| 615 | |
| 616 | /* Minimum number of free items on the stack allowed after an |
| 617 | allocation. This is to allow allocation and initialization |
| 618 | to be completed by functions that call yyexpandGLRStack before the |
| 619 | stack is expanded, thus insuring that all necessary pointers get |
| 620 | properly redirected to new data. */ |
| 621 | #define YYHEADROOM 2 |
| 622 | |
| 623 | #ifndef YYSTACKEXPANDABLE |
| 624 | # if (! defined (__cplusplus) \ |
| 625 | || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \ |
| 626 | && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)) |
| 627 | # define YYSTACKEXPANDABLE 1 |
| 628 | # else |
| 629 | # define YYSTACKEXPANDABLE 0 |
| 630 | # endif |
| 631 | #endif |
| 632 | |
| 633 | #if YYSTACKEXPANDABLE |
| 634 | # define YY_RESERVE_GLRSTACK(Yystack) \ |
| 635 | do { \ |
| 636 | if (Yystack->yyspaceLeft < YYHEADROOM) \ |
| 637 | yyexpandGLRStack (Yystack); \ |
| 638 | } while (YYID (0)) |
| 639 | #else |
| 640 | # define YY_RESERVE_GLRSTACK(Yystack) \ |
| 641 | do { \ |
| 642 | if (Yystack->yyspaceLeft < YYHEADROOM) \ |
| 643 | yyMemoryExhausted (Yystack); \ |
| 644 | } while (YYID (0)) |
| 645 | #endif |
| 646 | |
| 647 | |
| 648 | #if YYERROR_VERBOSE |
| 649 | |
| 650 | # ifndef yystpcpy |
| 651 | # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) |
| 652 | # define yystpcpy stpcpy |
| 653 | # else |
| 654 | /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in |
| 655 | YYDEST. */ |
| 656 | static char * |
| 657 | yystpcpy (char *yydest, const char *yysrc) |
| 658 | { |
| 659 | char *yyd = yydest; |
| 660 | const char *yys = yysrc; |
| 661 | |
| 662 | while ((*yyd++ = *yys++) != '\0') |
| 663 | continue; |
| 664 | |
| 665 | return yyd - 1; |
| 666 | } |
| 667 | # endif |
| 668 | # endif |
| 669 | |
| 670 | # ifndef yytnamerr |
| 671 | /* Copy to YYRES the contents of YYSTR after stripping away unnecessary |
| 672 | quotes and backslashes, so that it's suitable for yyerror. The |
| 673 | heuristic is that double-quoting is unnecessary unless the string |
| 674 | contains an apostrophe, a comma, or backslash (other than |
| 675 | backslash-backslash). YYSTR is taken from yytname. If YYRES is |
| 676 | null, do not copy; instead, return the length of what the result |
| 677 | would have been. */ |
| 678 | static size_t |
| 679 | yytnamerr (char *yyres, const char *yystr) |
| 680 | { |
| 681 | if (*yystr == '"') |
| 682 | { |
| 683 | size_t yyn = 0; |
| 684 | char const *yyp = yystr; |
| 685 | |
| 686 | for (;;) |
| 687 | switch (*++yyp) |
| 688 | { |
| 689 | case '\'': |
| 690 | case ',': |
| 691 | goto do_not_strip_quotes; |
| 692 | |
| 693 | case '\\': |
| 694 | if (*++yyp != '\\') |
| 695 | goto do_not_strip_quotes; |
| 696 | /* Fall through. */ |
| 697 | default: |
| 698 | if (yyres) |
| 699 | yyres[yyn] = *yyp; |
| 700 | yyn++; |
| 701 | break; |
| 702 | |
| 703 | case '"': |
| 704 | if (yyres) |
| 705 | yyres[yyn] = '\0'; |
| 706 | return yyn; |
| 707 | } |
| 708 | do_not_strip_quotes: ; |
| 709 | } |
| 710 | |
| 711 | if (! yyres) |
| 712 | return strlen (yystr); |
| 713 | |
| 714 | return yystpcpy (yyres, yystr) - yyres; |
| 715 | } |
| 716 | # endif |
| 717 | |
| 718 | #endif /* !YYERROR_VERBOSE */ |
| 719 | |
| 720 | /** State numbers, as in LALR(1) machine */ |
| 721 | typedef int yyStateNum; |
| 722 | |
| 723 | /** Rule numbers, as in LALR(1) machine */ |
| 724 | typedef int yyRuleNum; |
| 725 | |
| 726 | /** Grammar symbol */ |
| 727 | typedef short int yySymbol; |
| 728 | |
| 729 | /** Item references, as in LALR(1) machine */ |
| 730 | typedef short int yyItemNum; |
| 731 | |
| 732 | typedef struct yyGLRState yyGLRState; |
| 733 | typedef struct yyGLRStateSet yyGLRStateSet; |
| 734 | typedef struct yySemanticOption yySemanticOption; |
| 735 | typedef union yyGLRStackItem yyGLRStackItem; |
| 736 | typedef struct yyGLRStack yyGLRStack; |
| 737 | |
| 738 | struct yyGLRState { |
| 739 | /** Type tag: always true. */ |
| 740 | yybool yyisState; |
| 741 | /** Type tag for yysemantics. If true, yysval applies, otherwise |
| 742 | * yyfirstVal applies. */ |
| 743 | yybool yyresolved; |
| 744 | /** Number of corresponding LALR(1) machine state. */ |
| 745 | yyStateNum yylrState; |
| 746 | /** Preceding state in this stack */ |
| 747 | yyGLRState* yypred; |
| 748 | /** Source position of the first token produced by my symbol */ |
| 749 | size_t yyposn; |
| 750 | union { |
| 751 | /** First in a chain of alternative reductions producing the |
| 752 | * non-terminal corresponding to this state, threaded through |
| 753 | * yynext. */ |
| 754 | yySemanticOption* yyfirstVal; |
| 755 | /** Semantic value for this state. */ |
| 756 | YYSTYPE yysval; |
| 757 | } yysemantics; |
| 758 | /** Source location for this state. */ |
| 759 | YYLTYPE yyloc; |
| 760 | }; |
| 761 | |
| 762 | struct yyGLRStateSet { |
| 763 | yyGLRState** yystates; |
| 764 | /** During nondeterministic operation, yylookaheadNeeds tracks which |
| 765 | * stacks have actually needed the current lookahead. During deterministic |
| 766 | * operation, yylookaheadNeeds[0] is not maintained since it would merely |
| 767 | * duplicate yychar != YYEMPTY. */ |
| 768 | yybool* yylookaheadNeeds; |
| 769 | size_t yysize, yycapacity; |
| 770 | }; |
| 771 | |
| 772 | struct yySemanticOption { |
| 773 | /** Type tag: always false. */ |
| 774 | yybool yyisState; |
| 775 | /** Rule number for this reduction */ |
| 776 | yyRuleNum yyrule; |
| 777 | /** The last RHS state in the list of states to be reduced. */ |
| 778 | yyGLRState* yystate; |
| 779 | /** The lookahead for this reduction. */ |
| 780 | int yyrawchar; |
| 781 | YYSTYPE yyval; |
| 782 | YYLTYPE yyloc; |
| 783 | /** Next sibling in chain of options. To facilitate merging, |
| 784 | * options are chained in decreasing order by address. */ |
| 785 | yySemanticOption* yynext; |
| 786 | }; |
| 787 | |
| 788 | /** Type of the items in the GLR stack. The yyisState field |
| 789 | * indicates which item of the union is valid. */ |
| 790 | union yyGLRStackItem { |
| 791 | yyGLRState yystate; |
| 792 | yySemanticOption yyoption; |
| 793 | }; |
| 794 | |
| 795 | struct yyGLRStack { |
| 796 | int yyerrState; |
| 797 | ]b4_location_if([[ /* To compute the location of the error token. */ |
| 798 | yyGLRStackItem yyerror_range[3];]])[ |
| 799 | ]b4_pure_if( |
| 800 | [ |
| 801 | int yyerrcnt; |
| 802 | int yyrawchar; |
| 803 | YYSTYPE yyval; |
| 804 | YYLTYPE yyloc; |
| 805 | ])[ |
| 806 | yySymbol* yytokenp; |
| 807 | YYJMP_BUF yyexception_buffer; |
| 808 | yyGLRStackItem* yyitems; |
| 809 | yyGLRStackItem* yynextFree; |
| 810 | size_t yyspaceLeft; |
| 811 | yyGLRState* yysplitPoint; |
| 812 | yyGLRState* yylastDeleted; |
| 813 | yyGLRStateSet yytops; |
| 814 | }; |
| 815 | |
| 816 | #if YYSTACKEXPANDABLE |
| 817 | static void yyexpandGLRStack (yyGLRStack* yystackp); |
| 818 | #endif |
| 819 | |
| 820 | static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) |
| 821 | __attribute__ ((__noreturn__)); |
| 822 | static void |
| 823 | yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) |
| 824 | { |
| 825 | if (yymsg != NULL) |
| 826 | yyerror (]b4_yyerror_args[yymsg); |
| 827 | YYLONGJMP (yystackp->yyexception_buffer, 1); |
| 828 | } |
| 829 | |
| 830 | static void yyMemoryExhausted (yyGLRStack* yystackp) |
| 831 | __attribute__ ((__noreturn__)); |
| 832 | static void |
| 833 | yyMemoryExhausted (yyGLRStack* yystackp) |
| 834 | { |
| 835 | YYLONGJMP (yystackp->yyexception_buffer, 2); |
| 836 | } |
| 837 | |
| 838 | #if YYDEBUG || YYERROR_VERBOSE |
| 839 | /** A printable representation of TOKEN. */ |
| 840 | static inline const char* |
| 841 | yytokenName (yySymbol yytoken) |
| 842 | { |
| 843 | if (yytoken == YYEMPTY) |
| 844 | return ""; |
| 845 | |
| 846 | return yytname[yytoken]; |
| 847 | } |
| 848 | #endif |
| 849 | |
| 850 | /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting |
| 851 | * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred |
| 852 | * containing the pointer to the next state in the chain. */ |
| 853 | static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__)); |
| 854 | static void |
| 855 | yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) |
| 856 | { |
| 857 | yyGLRState* s; |
| 858 | int i; |
| 859 | s = yyvsp[yylow0].yystate.yypred; |
| 860 | for (i = yylow0-1; i >= yylow1; i -= 1) |
| 861 | { |
| 862 | YYASSERT (s->yyresolved); |
| 863 | yyvsp[i].yystate.yyresolved = yytrue; |
| 864 | yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval; |
| 865 | yyvsp[i].yystate.yyloc = s->yyloc; |
| 866 | s = yyvsp[i].yystate.yypred = s->yypred; |
| 867 | } |
| 868 | } |
| 869 | |
| 870 | /* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in |
| 871 | * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. |
| 872 | * For convenience, always return YYLOW1. */ |
| 873 | static inline int yyfill (yyGLRStackItem *, int *, int, yybool) |
| 874 | __attribute__ ((__unused__)); |
| 875 | static inline int |
| 876 | yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) |
| 877 | { |
| 878 | if (!yynormal && yylow1 < *yylow) |
| 879 | { |
| 880 | yyfillin (yyvsp, *yylow, yylow1); |
| 881 | *yylow = yylow1; |
| 882 | } |
| 883 | return yylow1; |
| 884 | } |
| 885 | |
| 886 | /** Perform user action for rule number YYN, with RHS length YYRHSLEN, |
| 887 | * and top stack item YYVSP. YYLVALP points to place to put semantic |
| 888 | * value ($$), and yylocp points to place for location information |
| 889 | * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT, |
| 890 | * yyerr for YYERROR, yyabort for YYABORT. */ |
| 891 | /*ARGSUSED*/ static YYRESULTTAG |
| 892 | yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, |
| 893 | YYSTYPE* yyvalp, |
| 894 | YYLTYPE* YYOPTIONAL_LOC (yylocp), |
| 895 | yyGLRStack* yystackp |
| 896 | ]b4_user_formals[) |
| 897 | { |
| 898 | yybool yynormal __attribute__ ((__unused__)) = |
| 899 | (yystackp->yysplitPoint == NULL); |
| 900 | int yylow; |
| 901 | ]b4_parse_param_use[]dnl |
| 902 | [# undef yyerrok |
| 903 | # define yyerrok (yystackp->yyerrState = 0) |
| 904 | # undef YYACCEPT |
| 905 | # define YYACCEPT return yyaccept |
| 906 | # undef YYABORT |
| 907 | # define YYABORT return yyabort |
| 908 | # undef YYERROR |
| 909 | # define YYERROR return yyerrok, yyerr |
| 910 | # undef YYRECOVERING |
| 911 | # define YYRECOVERING (yystackp->yyerrState != 0) |
| 912 | # undef yyclearin |
| 913 | # define yyclearin (yychar = *(yystackp->yytokenp) = YYEMPTY) |
| 914 | # undef YYFILL |
| 915 | # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal) |
| 916 | # undef YYBACKUP |
| 917 | # define YYBACKUP(Token, Value) \ |
| 918 | return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \ |
| 919 | yyerrok, yyerr |
| 920 | |
| 921 | yylow = 1; |
| 922 | if (yyrhslen == 0) |
| 923 | *yyvalp = yyval_default; |
| 924 | else |
| 925 | *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval; |
| 926 | YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen); |
| 927 | ]b4_location_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp; |
| 928 | ]])[ |
| 929 | switch (yyn) |
| 930 | { |
| 931 | ]b4_actions |
| 932 | /* Line __line__ of glr.c. */ |
| 933 | b4_syncline([@oline@], [@ofile@])[ |
| 934 | default: break; |
| 935 | } |
| 936 | |
| 937 | return yyok; |
| 938 | # undef yyerrok |
| 939 | # undef YYABORT |
| 940 | # undef YYACCEPT |
| 941 | # undef YYERROR |
| 942 | # undef YYBACKUP |
| 943 | # undef yyclearin |
| 944 | # undef YYRECOVERING |
| 945 | } |
| 946 | \f |
| 947 | |
| 948 | /*ARGSUSED*/ static void |
| 949 | yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) |
| 950 | { |
| 951 | YYUSE (yy0); |
| 952 | YYUSE (yy1); |
| 953 | |
| 954 | switch (yyn) |
| 955 | { |
| 956 | ]b4_mergers[ |
| 957 | default: break; |
| 958 | } |
| 959 | } |
| 960 | |
| 961 | /* Bison grammar-table manipulation. */ |
| 962 | |
| 963 | ]b4_yydestruct_generate([b4_c_ansi_function_def])[ |
| 964 | |
| 965 | /** Number of symbols composing the right hand side of rule #RULE. */ |
| 966 | static inline int |
| 967 | yyrhsLength (yyRuleNum yyrule) |
| 968 | { |
| 969 | return yyr2[yyrule]; |
| 970 | } |
| 971 | |
| 972 | static void |
| 973 | yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) |
| 974 | { |
| 975 | if (yys->yyresolved) |
| 976 | yydestruct (yymsg, yystos[yys->yylrState], |
| 977 | &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[]b4_user_args[); |
| 978 | else |
| 979 | { |
| 980 | #if YYDEBUG |
| 981 | if (yydebug) |
| 982 | { |
| 983 | YYFPRINTF (stderr, "%s unresolved ", yymsg); |
| 984 | yy_symbol_print (stderr, yystos[yys->yylrState], |
| 985 | NULL]b4_location_if([, &yys->yyloc])[]b4_user_args[); |
| 986 | YYFPRINTF (stderr, "\n"); |
| 987 | } |
| 988 | #endif |
| 989 | |
| 990 | if (yys->yysemantics.yyfirstVal) |
| 991 | { |
| 992 | yySemanticOption *yyoption = yys->yysemantics.yyfirstVal; |
| 993 | yyGLRState *yyrh; |
| 994 | int yyn; |
| 995 | for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule); |
| 996 | yyn > 0; |
| 997 | yyrh = yyrh->yypred, yyn -= 1) |
| 998 | yydestroyGLRState (yymsg, yyrh]b4_user_args[); |
| 999 | } |
| 1000 | } |
| 1001 | } |
| 1002 | |
| 1003 | /** Left-hand-side symbol for rule #RULE. */ |
| 1004 | static inline yySymbol |
| 1005 | yylhsNonterm (yyRuleNum yyrule) |
| 1006 | { |
| 1007 | return yyr1[yyrule]; |
| 1008 | } |
| 1009 | |
| 1010 | #define yyis_pact_ninf(yystate) \ |
| 1011 | ]m4_if(m4_eval(b4_pact_ninf < b4_pact_min), [1], |
| 1012 | [0], |
| 1013 | [((yystate) == YYPACT_NINF)])[ |
| 1014 | |
| 1015 | /** True iff LR state STATE has only a default reduction (regardless |
| 1016 | * of token). */ |
| 1017 | static inline yybool |
| 1018 | yyisDefaultedState (yyStateNum yystate) |
| 1019 | { |
| 1020 | return yyis_pact_ninf (yypact[yystate]); |
| 1021 | } |
| 1022 | |
| 1023 | /** The default reduction for STATE, assuming it has one. */ |
| 1024 | static inline yyRuleNum |
| 1025 | yydefaultAction (yyStateNum yystate) |
| 1026 | { |
| 1027 | return yydefact[yystate]; |
| 1028 | } |
| 1029 | |
| 1030 | #define yyis_table_ninf(yytable_value) \ |
| 1031 | ]m4_if(m4_eval(b4_table_ninf < b4_table_min), [1], |
| 1032 | [YYID (0)], |
| 1033 | [((yytable_value) == YYTABLE_NINF)])[ |
| 1034 | |
| 1035 | /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. |
| 1036 | * Result R means |
| 1037 | * R < 0: Reduce on rule -R. |
| 1038 | * R = 0: Error. |
| 1039 | * R > 0: Shift to state R. |
| 1040 | * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of |
| 1041 | * conflicting reductions. |
| 1042 | */ |
| 1043 | static inline void |
| 1044 | yygetLRActions (yyStateNum yystate, int yytoken, |
| 1045 | int* yyaction, const short int** yyconflicts) |
| 1046 | { |
| 1047 | int yyindex = yypact[yystate] + yytoken; |
| 1048 | if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) |
| 1049 | { |
| 1050 | *yyaction = -yydefact[yystate]; |
| 1051 | *yyconflicts = yyconfl; |
| 1052 | } |
| 1053 | else if (! yyis_table_ninf (yytable[yyindex])) |
| 1054 | { |
| 1055 | *yyaction = yytable[yyindex]; |
| 1056 | *yyconflicts = yyconfl + yyconflp[yyindex]; |
| 1057 | } |
| 1058 | else |
| 1059 | { |
| 1060 | *yyaction = 0; |
| 1061 | *yyconflicts = yyconfl + yyconflp[yyindex]; |
| 1062 | } |
| 1063 | } |
| 1064 | |
| 1065 | static inline yyStateNum |
| 1066 | yyLRgotoState (yyStateNum yystate, yySymbol yylhs) |
| 1067 | { |
| 1068 | int yyr; |
| 1069 | yyr = yypgoto[yylhs - YYNTOKENS] + yystate; |
| 1070 | if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) |
| 1071 | return yytable[yyr]; |
| 1072 | else |
| 1073 | return yydefgoto[yylhs - YYNTOKENS]; |
| 1074 | } |
| 1075 | |
| 1076 | static inline yybool |
| 1077 | yyisShiftAction (int yyaction) |
| 1078 | { |
| 1079 | return 0 < yyaction; |
| 1080 | } |
| 1081 | |
| 1082 | static inline yybool |
| 1083 | yyisErrorAction (int yyaction) |
| 1084 | { |
| 1085 | return yyaction == 0; |
| 1086 | } |
| 1087 | |
| 1088 | /* GLRStates */ |
| 1089 | |
| 1090 | /** Return a fresh GLRStackItem. Callers should call |
| 1091 | * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient |
| 1092 | * headroom. */ |
| 1093 | |
| 1094 | static inline yyGLRStackItem* |
| 1095 | yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) |
| 1096 | { |
| 1097 | yyGLRStackItem* yynewItem = yystackp->yynextFree; |
| 1098 | yystackp->yyspaceLeft -= 1; |
| 1099 | yystackp->yynextFree += 1; |
| 1100 | yynewItem->yystate.yyisState = yyisState; |
| 1101 | return yynewItem; |
| 1102 | } |
| 1103 | |
| 1104 | /** Add a new semantic action that will execute the action for rule |
| 1105 | * RULENUM on the semantic values in RHS to the list of |
| 1106 | * alternative actions for STATE. Assumes that RHS comes from |
| 1107 | * stack #K of *STACKP. */ |
| 1108 | static void |
| 1109 | yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate, |
| 1110 | yyGLRState* rhs, yyRuleNum yyrule) |
| 1111 | { |
| 1112 | yySemanticOption* yynewOption = |
| 1113 | &yynewGLRStackItem (yystackp, yyfalse)->yyoption; |
| 1114 | yynewOption->yystate = rhs; |
| 1115 | yynewOption->yyrule = yyrule; |
| 1116 | if (yystackp->yytops.yylookaheadNeeds[yyk]) |
| 1117 | { |
| 1118 | yynewOption->yyrawchar = yychar; |
| 1119 | yynewOption->yyval = yylval; |
| 1120 | yynewOption->yyloc = yylloc; |
| 1121 | } |
| 1122 | else |
| 1123 | yynewOption->yyrawchar = YYEMPTY; |
| 1124 | yynewOption->yynext = yystate->yysemantics.yyfirstVal; |
| 1125 | yystate->yysemantics.yyfirstVal = yynewOption; |
| 1126 | |
| 1127 | YY_RESERVE_GLRSTACK (yystackp); |
| 1128 | } |
| 1129 | |
| 1130 | /* GLRStacks */ |
| 1131 | |
| 1132 | /** Initialize SET to a singleton set containing an empty stack. */ |
| 1133 | static yybool |
| 1134 | yyinitStateSet (yyGLRStateSet* yyset) |
| 1135 | { |
| 1136 | yyset->yysize = 1; |
| 1137 | yyset->yycapacity = 16; |
| 1138 | yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]); |
| 1139 | if (! yyset->yystates) |
| 1140 | return yyfalse; |
| 1141 | yyset->yystates[0] = NULL; |
| 1142 | yyset->yylookaheadNeeds = |
| 1143 | (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]); |
| 1144 | if (! yyset->yylookaheadNeeds) |
| 1145 | { |
| 1146 | YYFREE (yyset->yystates); |
| 1147 | return yyfalse; |
| 1148 | } |
| 1149 | return yytrue; |
| 1150 | } |
| 1151 | |
| 1152 | static void yyfreeStateSet (yyGLRStateSet* yyset) |
| 1153 | { |
| 1154 | YYFREE (yyset->yystates); |
| 1155 | YYFREE (yyset->yylookaheadNeeds); |
| 1156 | } |
| 1157 | |
| 1158 | /** Initialize STACK to a single empty stack, with total maximum |
| 1159 | * capacity for all stacks of SIZE. */ |
| 1160 | static yybool |
| 1161 | yyinitGLRStack (yyGLRStack* yystackp, size_t yysize) |
| 1162 | { |
| 1163 | yystackp->yyerrState = 0; |
| 1164 | yynerrs = 0; |
| 1165 | yystackp->yyspaceLeft = yysize; |
| 1166 | yystackp->yyitems = |
| 1167 | (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]); |
| 1168 | if (!yystackp->yyitems) |
| 1169 | return yyfalse; |
| 1170 | yystackp->yynextFree = yystackp->yyitems; |
| 1171 | yystackp->yysplitPoint = NULL; |
| 1172 | yystackp->yylastDeleted = NULL; |
| 1173 | return yyinitStateSet (&yystackp->yytops); |
| 1174 | } |
| 1175 | |
| 1176 | |
| 1177 | #if YYSTACKEXPANDABLE |
| 1178 | # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ |
| 1179 | &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE |
| 1180 | |
| 1181 | /** If STACK is expandable, extend it. WARNING: Pointers into the |
| 1182 | stack from outside should be considered invalid after this call. |
| 1183 | We always expand when there are 1 or fewer items left AFTER an |
| 1184 | allocation, so that we can avoid having external pointers exist |
| 1185 | across an allocation. */ |
| 1186 | static void |
| 1187 | yyexpandGLRStack (yyGLRStack* yystackp) |
| 1188 | { |
| 1189 | yyGLRStackItem* yynewItems; |
| 1190 | yyGLRStackItem* yyp0, *yyp1; |
| 1191 | size_t yysize, yynewSize; |
| 1192 | size_t yyn; |
| 1193 | yysize = yystackp->yynextFree - yystackp->yyitems; |
| 1194 | if (YYMAXDEPTH <= yysize) |
| 1195 | yyMemoryExhausted (yystackp); |
| 1196 | yynewSize = 2*yysize; |
| 1197 | if (YYMAXDEPTH < yynewSize) |
| 1198 | yynewSize = YYMAXDEPTH; |
| 1199 | yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]); |
| 1200 | if (! yynewItems) |
| 1201 | yyMemoryExhausted (yystackp); |
| 1202 | for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize; |
| 1203 | 0 < yyn; |
| 1204 | yyn -= 1, yyp0 += 1, yyp1 += 1) |
| 1205 | { |
| 1206 | *yyp1 = *yyp0; |
| 1207 | if (*(yybool *) yyp0) |
| 1208 | { |
| 1209 | yyGLRState* yys0 = &yyp0->yystate; |
| 1210 | yyGLRState* yys1 = &yyp1->yystate; |
| 1211 | if (yys0->yypred != NULL) |
| 1212 | yys1->yypred = |
| 1213 | YYRELOC (yyp0, yyp1, yys0->yypred, yystate); |
| 1214 | if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL) |
| 1215 | yys1->yysemantics.yyfirstVal = |
| 1216 | YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); |
| 1217 | } |
| 1218 | else |
| 1219 | { |
| 1220 | yySemanticOption* yyv0 = &yyp0->yyoption; |
| 1221 | yySemanticOption* yyv1 = &yyp1->yyoption; |
| 1222 | if (yyv0->yystate != NULL) |
| 1223 | yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); |
| 1224 | if (yyv0->yynext != NULL) |
| 1225 | yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); |
| 1226 | } |
| 1227 | } |
| 1228 | if (yystackp->yysplitPoint != NULL) |
| 1229 | yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, |
| 1230 | yystackp->yysplitPoint, yystate); |
| 1231 | |
| 1232 | for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) |
| 1233 | if (yystackp->yytops.yystates[yyn] != NULL) |
| 1234 | yystackp->yytops.yystates[yyn] = |
| 1235 | YYRELOC (yystackp->yyitems, yynewItems, |
| 1236 | yystackp->yytops.yystates[yyn], yystate); |
| 1237 | YYFREE (yystackp->yyitems); |
| 1238 | yystackp->yyitems = yynewItems; |
| 1239 | yystackp->yynextFree = yynewItems + yysize; |
| 1240 | yystackp->yyspaceLeft = yynewSize - yysize; |
| 1241 | } |
| 1242 | #endif |
| 1243 | |
| 1244 | static void |
| 1245 | yyfreeGLRStack (yyGLRStack* yystackp) |
| 1246 | { |
| 1247 | YYFREE (yystackp->yyitems); |
| 1248 | yyfreeStateSet (&yystackp->yytops); |
| 1249 | } |
| 1250 | |
| 1251 | /** Assuming that S is a GLRState somewhere on STACK, update the |
| 1252 | * splitpoint of STACK, if needed, so that it is at least as deep as |
| 1253 | * S. */ |
| 1254 | static inline void |
| 1255 | yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) |
| 1256 | { |
| 1257 | if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys) |
| 1258 | yystackp->yysplitPoint = yys; |
| 1259 | } |
| 1260 | |
| 1261 | /** Invalidate stack #K in STACK. */ |
| 1262 | static inline void |
| 1263 | yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) |
| 1264 | { |
| 1265 | if (yystackp->yytops.yystates[yyk] != NULL) |
| 1266 | yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; |
| 1267 | yystackp->yytops.yystates[yyk] = NULL; |
| 1268 | } |
| 1269 | |
| 1270 | /** Undelete the last stack that was marked as deleted. Can only be |
| 1271 | done once after a deletion, and only when all other stacks have |
| 1272 | been deleted. */ |
| 1273 | static void |
| 1274 | yyundeleteLastStack (yyGLRStack* yystackp) |
| 1275 | { |
| 1276 | if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0) |
| 1277 | return; |
| 1278 | yystackp->yytops.yystates[0] = yystackp->yylastDeleted; |
| 1279 | yystackp->yytops.yysize = 1; |
| 1280 | YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); |
| 1281 | yystackp->yylastDeleted = NULL; |
| 1282 | } |
| 1283 | |
| 1284 | static inline void |
| 1285 | yyremoveDeletes (yyGLRStack* yystackp) |
| 1286 | { |
| 1287 | size_t yyi, yyj; |
| 1288 | yyi = yyj = 0; |
| 1289 | while (yyj < yystackp->yytops.yysize) |
| 1290 | { |
| 1291 | if (yystackp->yytops.yystates[yyi] == NULL) |
| 1292 | { |
| 1293 | if (yyi == yyj) |
| 1294 | { |
| 1295 | YYDPRINTF ((stderr, "Removing dead stacks.\n")); |
| 1296 | } |
| 1297 | yystackp->yytops.yysize -= 1; |
| 1298 | } |
| 1299 | else |
| 1300 | { |
| 1301 | yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; |
| 1302 | /* In the current implementation, it's unnecessary to copy |
| 1303 | yystackp->yytops.yylookaheadNeeds[yyi] since, after |
| 1304 | yyremoveDeletes returns, the parser immediately either enters |
| 1305 | deterministic operation or shifts a token. However, it doesn't |
| 1306 | hurt, and the code might evolve to need it. */ |
| 1307 | yystackp->yytops.yylookaheadNeeds[yyj] = |
| 1308 | yystackp->yytops.yylookaheadNeeds[yyi]; |
| 1309 | if (yyj != yyi) |
| 1310 | { |
| 1311 | YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", |
| 1312 | (unsigned long int) yyi, (unsigned long int) yyj)); |
| 1313 | } |
| 1314 | yyj += 1; |
| 1315 | } |
| 1316 | yyi += 1; |
| 1317 | } |
| 1318 | } |
| 1319 | |
| 1320 | /** Shift to a new state on stack #K of STACK, corresponding to LR state |
| 1321 | * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ |
| 1322 | static inline void |
| 1323 | yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, |
| 1324 | size_t yyposn, |
| 1325 | YYSTYPE* yyvalp, YYLTYPE* yylocp) |
| 1326 | { |
| 1327 | yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; |
| 1328 | |
| 1329 | yynewState->yylrState = yylrState; |
| 1330 | yynewState->yyposn = yyposn; |
| 1331 | yynewState->yyresolved = yytrue; |
| 1332 | yynewState->yypred = yystackp->yytops.yystates[yyk]; |
| 1333 | yynewState->yysemantics.yysval = *yyvalp; |
| 1334 | yynewState->yyloc = *yylocp; |
| 1335 | yystackp->yytops.yystates[yyk] = yynewState; |
| 1336 | |
| 1337 | YY_RESERVE_GLRSTACK (yystackp); |
| 1338 | } |
| 1339 | |
| 1340 | /** Shift stack #K of YYSTACK, to a new state corresponding to LR |
| 1341 | * state YYLRSTATE, at input position YYPOSN, with the (unresolved) |
| 1342 | * semantic value of YYRHS under the action for YYRULE. */ |
| 1343 | static inline void |
| 1344 | yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, |
| 1345 | size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule) |
| 1346 | { |
| 1347 | yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; |
| 1348 | |
| 1349 | yynewState->yylrState = yylrState; |
| 1350 | yynewState->yyposn = yyposn; |
| 1351 | yynewState->yyresolved = yyfalse; |
| 1352 | yynewState->yypred = yystackp->yytops.yystates[yyk]; |
| 1353 | yynewState->yysemantics.yyfirstVal = NULL; |
| 1354 | yystackp->yytops.yystates[yyk] = yynewState; |
| 1355 | |
| 1356 | /* Invokes YY_RESERVE_GLRSTACK. */ |
| 1357 | yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule); |
| 1358 | } |
| 1359 | |
| 1360 | /** Pop the symbols consumed by reduction #RULE from the top of stack |
| 1361 | * #K of STACK, and perform the appropriate semantic action on their |
| 1362 | * semantic values. Assumes that all ambiguities in semantic values |
| 1363 | * have been previously resolved. Set *VALP to the resulting value, |
| 1364 | * and *LOCP to the computed location (if any). Return value is as |
| 1365 | * for userAction. */ |
| 1366 | static inline YYRESULTTAG |
| 1367 | yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, |
| 1368 | YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
| 1369 | { |
| 1370 | int yynrhs = yyrhsLength (yyrule); |
| 1371 | |
| 1372 | if (yystackp->yysplitPoint == NULL) |
| 1373 | { |
| 1374 | /* Standard special case: single stack. */ |
| 1375 | yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; |
| 1376 | YYASSERT (yyk == 0); |
| 1377 | yystackp->yynextFree -= yynrhs; |
| 1378 | yystackp->yyspaceLeft += yynrhs; |
| 1379 | yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; |
| 1380 | return yyuserAction (yyrule, yynrhs, rhs, |
| 1381 | yyvalp, yylocp, yystackp]b4_user_args[); |
| 1382 | } |
| 1383 | else |
| 1384 | { |
| 1385 | /* At present, doAction is never called in nondeterministic |
| 1386 | * mode, so this branch is never taken. It is here in |
| 1387 | * anticipation of a future feature that will allow immediate |
| 1388 | * evaluation of selected actions in nondeterministic mode. */ |
| 1389 | int yyi; |
| 1390 | yyGLRState* yys; |
| 1391 | yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; |
| 1392 | yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred |
| 1393 | = yystackp->yytops.yystates[yyk];]b4_location_if([[ |
| 1394 | if (yynrhs == 0) |
| 1395 | /* Set default location. */ |
| 1396 | yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ |
| 1397 | for (yyi = 0; yyi < yynrhs; yyi += 1) |
| 1398 | { |
| 1399 | yys = yys->yypred; |
| 1400 | YYASSERT (yys); |
| 1401 | } |
| 1402 | yyupdateSplit (yystackp, yys); |
| 1403 | yystackp->yytops.yystates[yyk] = yys; |
| 1404 | return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, |
| 1405 | yyvalp, yylocp, yystackp]b4_user_args[); |
| 1406 | } |
| 1407 | } |
| 1408 | |
| 1409 | #if !YYDEBUG |
| 1410 | # define YY_REDUCE_PRINT(Args) |
| 1411 | #else |
| 1412 | # define YY_REDUCE_PRINT(Args) \ |
| 1413 | do { \ |
| 1414 | if (yydebug) \ |
| 1415 | yy_reduce_print Args; \ |
| 1416 | } while (YYID (0)) |
| 1417 | |
| 1418 | /*----------------------------------------------------------. |
| 1419 | | Report that the RULE is going to be reduced on stack #K. | |
| 1420 | `----------------------------------------------------------*/ |
| 1421 | |
| 1422 | /*ARGSUSED*/ static inline void |
| 1423 | yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, |
| 1424 | YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
| 1425 | { |
| 1426 | int yynrhs = yyrhsLength (yyrule); |
| 1427 | yybool yynormal __attribute__ ((__unused__)) = |
| 1428 | (yystackp->yysplitPoint == NULL); |
| 1429 | yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; |
| 1430 | int yylow = 1; |
| 1431 | int yyi; |
| 1432 | YYUSE (yyvalp); |
| 1433 | YYUSE (yylocp); |
| 1434 | ]b4_parse_param_use[]dnl |
| 1435 | [ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", |
| 1436 | (unsigned long int) yyk, yyrule - 1, |
| 1437 | (unsigned long int) yyrline[yyrule]); |
| 1438 | /* The symbols being reduced. */ |
| 1439 | for (yyi = 0; yyi < yynrhs; yyi++) |
| 1440 | { |
| 1441 | fprintf (stderr, " $%d = ", yyi + 1); |
| 1442 | yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
| 1443 | &]b4_rhs_value(yynrhs, yyi + 1)[ |
| 1444 | ]b4_location_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl |
| 1445 | b4_user_args[); |
| 1446 | fprintf (stderr, "\n"); |
| 1447 | } |
| 1448 | } |
| 1449 | #endif |
| 1450 | |
| 1451 | /** Pop items off stack #K of STACK according to grammar rule RULE, |
| 1452 | * and push back on the resulting nonterminal symbol. Perform the |
| 1453 | * semantic action associated with RULE and store its value with the |
| 1454 | * newly pushed state, if FORCEEVAL or if STACK is currently |
| 1455 | * unambiguous. Otherwise, store the deferred semantic action with |
| 1456 | * the new state. If the new state would have an identical input |
| 1457 | * position, LR state, and predecessor to an existing state on the stack, |
| 1458 | * it is identified with that existing state, eliminating stack #K from |
| 1459 | * the STACK. In this case, the (necessarily deferred) semantic value is |
| 1460 | * added to the options for the existing state's semantic value. |
| 1461 | */ |
| 1462 | static inline YYRESULTTAG |
| 1463 | yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, |
| 1464 | yybool yyforceEval]b4_user_formals[) |
| 1465 | { |
| 1466 | size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn; |
| 1467 | |
| 1468 | if (yyforceEval || yystackp->yysplitPoint == NULL) |
| 1469 | { |
| 1470 | YYSTYPE yysval; |
| 1471 | YYLTYPE yyloc; |
| 1472 | |
| 1473 | YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval, &yyloc]b4_user_args[)); |
| 1474 | YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval, |
| 1475 | &yyloc]b4_user_args[)); |
| 1476 | YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); |
| 1477 | yyglrShift (yystackp, yyk, |
| 1478 | yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, |
| 1479 | yylhsNonterm (yyrule)), |
| 1480 | yyposn, &yysval, &yyloc); |
| 1481 | } |
| 1482 | else |
| 1483 | { |
| 1484 | size_t yyi; |
| 1485 | int yyn; |
| 1486 | yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk]; |
| 1487 | yyStateNum yynewLRState; |
| 1488 | |
| 1489 | for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); |
| 1490 | 0 < yyn; yyn -= 1) |
| 1491 | { |
| 1492 | yys = yys->yypred; |
| 1493 | YYASSERT (yys); |
| 1494 | } |
| 1495 | yyupdateSplit (yystackp, yys); |
| 1496 | yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); |
| 1497 | YYDPRINTF ((stderr, |
| 1498 | "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n", |
| 1499 | (unsigned long int) yyk, yyrule - 1, yynewLRState)); |
| 1500 | for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) |
| 1501 | if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL) |
| 1502 | { |
| 1503 | yyGLRState* yyp, *yysplit = yystackp->yysplitPoint; |
| 1504 | yyp = yystackp->yytops.yystates[yyi]; |
| 1505 | while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) |
| 1506 | { |
| 1507 | if (yyp->yylrState == yynewLRState && yyp->yypred == yys) |
| 1508 | { |
| 1509 | yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); |
| 1510 | yymarkStackDeleted (yystackp, yyk); |
| 1511 | YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", |
| 1512 | (unsigned long int) yyk, |
| 1513 | (unsigned long int) yyi)); |
| 1514 | return yyok; |
| 1515 | } |
| 1516 | yyp = yyp->yypred; |
| 1517 | } |
| 1518 | } |
| 1519 | yystackp->yytops.yystates[yyk] = yys; |
| 1520 | yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule); |
| 1521 | } |
| 1522 | return yyok; |
| 1523 | } |
| 1524 | |
| 1525 | static size_t |
| 1526 | yysplitStack (yyGLRStack* yystackp, size_t yyk) |
| 1527 | { |
| 1528 | if (yystackp->yysplitPoint == NULL) |
| 1529 | { |
| 1530 | YYASSERT (yyk == 0); |
| 1531 | yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; |
| 1532 | } |
| 1533 | if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity) |
| 1534 | { |
| 1535 | yyGLRState** yynewStates; |
| 1536 | yybool* yynewLookaheadNeeds; |
| 1537 | |
| 1538 | yynewStates = NULL; |
| 1539 | |
| 1540 | if (yystackp->yytops.yycapacity |
| 1541 | > (YYSIZEMAX / (2 * sizeof yynewStates[0]))) |
| 1542 | yyMemoryExhausted (yystackp); |
| 1543 | yystackp->yytops.yycapacity *= 2; |
| 1544 | |
| 1545 | yynewStates = |
| 1546 | (yyGLRState**) YYREALLOC (yystackp->yytops.yystates, |
| 1547 | (yystackp->yytops.yycapacity |
| 1548 | * sizeof yynewStates[0])); |
| 1549 | if (yynewStates == NULL) |
| 1550 | yyMemoryExhausted (yystackp); |
| 1551 | yystackp->yytops.yystates = yynewStates; |
| 1552 | |
| 1553 | yynewLookaheadNeeds = |
| 1554 | (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, |
| 1555 | (yystackp->yytops.yycapacity |
| 1556 | * sizeof yynewLookaheadNeeds[0])); |
| 1557 | if (yynewLookaheadNeeds == NULL) |
| 1558 | yyMemoryExhausted (yystackp); |
| 1559 | yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; |
| 1560 | } |
| 1561 | yystackp->yytops.yystates[yystackp->yytops.yysize] |
| 1562 | = yystackp->yytops.yystates[yyk]; |
| 1563 | yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize] |
| 1564 | = yystackp->yytops.yylookaheadNeeds[yyk]; |
| 1565 | yystackp->yytops.yysize += 1; |
| 1566 | return yystackp->yytops.yysize-1; |
| 1567 | } |
| 1568 | |
| 1569 | /** True iff Y0 and Y1 represent identical options at the top level. |
| 1570 | * That is, they represent the same rule applied to RHS symbols |
| 1571 | * that produce the same terminal symbols. */ |
| 1572 | static yybool |
| 1573 | yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) |
| 1574 | { |
| 1575 | if (yyy0->yyrule == yyy1->yyrule) |
| 1576 | { |
| 1577 | yyGLRState *yys0, *yys1; |
| 1578 | int yyn; |
| 1579 | for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, |
| 1580 | yyn = yyrhsLength (yyy0->yyrule); |
| 1581 | yyn > 0; |
| 1582 | yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) |
| 1583 | if (yys0->yyposn != yys1->yyposn) |
| 1584 | return yyfalse; |
| 1585 | return yytrue; |
| 1586 | } |
| 1587 | else |
| 1588 | return yyfalse; |
| 1589 | } |
| 1590 | |
| 1591 | /** Assuming identicalOptions (Y0,Y1), destructively merge the |
| 1592 | * alternative semantic values for the RHS-symbols of Y1 and Y0. */ |
| 1593 | static void |
| 1594 | yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) |
| 1595 | { |
| 1596 | yyGLRState *yys0, *yys1; |
| 1597 | int yyn; |
| 1598 | for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, |
| 1599 | yyn = yyrhsLength (yyy0->yyrule); |
| 1600 | yyn > 0; |
| 1601 | yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) |
| 1602 | { |
| 1603 | if (yys0 == yys1) |
| 1604 | break; |
| 1605 | else if (yys0->yyresolved) |
| 1606 | { |
| 1607 | yys1->yyresolved = yytrue; |
| 1608 | yys1->yysemantics.yysval = yys0->yysemantics.yysval; |
| 1609 | } |
| 1610 | else if (yys1->yyresolved) |
| 1611 | { |
| 1612 | yys0->yyresolved = yytrue; |
| 1613 | yys0->yysemantics.yysval = yys1->yysemantics.yysval; |
| 1614 | } |
| 1615 | else |
| 1616 | { |
| 1617 | yySemanticOption** yyz0p; |
| 1618 | yySemanticOption* yyz1; |
| 1619 | yyz0p = &yys0->yysemantics.yyfirstVal; |
| 1620 | yyz1 = yys1->yysemantics.yyfirstVal; |
| 1621 | while (YYID (yytrue)) |
| 1622 | { |
| 1623 | if (yyz1 == *yyz0p || yyz1 == NULL) |
| 1624 | break; |
| 1625 | else if (*yyz0p == NULL) |
| 1626 | { |
| 1627 | *yyz0p = yyz1; |
| 1628 | break; |
| 1629 | } |
| 1630 | else if (*yyz0p < yyz1) |
| 1631 | { |
| 1632 | yySemanticOption* yyz = *yyz0p; |
| 1633 | *yyz0p = yyz1; |
| 1634 | yyz1 = yyz1->yynext; |
| 1635 | (*yyz0p)->yynext = yyz; |
| 1636 | } |
| 1637 | yyz0p = &(*yyz0p)->yynext; |
| 1638 | } |
| 1639 | yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; |
| 1640 | } |
| 1641 | } |
| 1642 | } |
| 1643 | |
| 1644 | /** Y0 and Y1 represent two possible actions to take in a given |
| 1645 | * parsing state; return 0 if no combination is possible, |
| 1646 | * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ |
| 1647 | static int |
| 1648 | yypreference (yySemanticOption* y0, yySemanticOption* y1) |
| 1649 | { |
| 1650 | yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; |
| 1651 | int p0 = yydprec[r0], p1 = yydprec[r1]; |
| 1652 | |
| 1653 | if (p0 == p1) |
| 1654 | { |
| 1655 | if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) |
| 1656 | return 0; |
| 1657 | else |
| 1658 | return 1; |
| 1659 | } |
| 1660 | if (p0 == 0 || p1 == 0) |
| 1661 | return 0; |
| 1662 | if (p0 < p1) |
| 1663 | return 3; |
| 1664 | if (p1 < p0) |
| 1665 | return 2; |
| 1666 | return 0; |
| 1667 | } |
| 1668 | |
| 1669 | static YYRESULTTAG yyresolveValue (yyGLRState* yys, |
| 1670 | yyGLRStack* yystackp, YYSTYPE* yyvalp, |
| 1671 | YYLTYPE* yylocp]b4_user_formals[); |
| 1672 | |
| 1673 | static YYRESULTTAG |
| 1674 | yyresolveStates (yyGLRState* yys, int yyn, |
| 1675 | yyGLRStack* yystackp]b4_user_formals[) |
| 1676 | { |
| 1677 | if (0 < yyn) |
| 1678 | { |
| 1679 | YYASSERT (yys->yypred); |
| 1680 | YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[)); |
| 1681 | if (! yys->yyresolved) |
| 1682 | { |
| 1683 | YYSTYPE yysval; |
| 1684 | YYRESULTTAG yyflag = yyresolveValue (yys, yystackp, &yysval, |
| 1685 | &yys->yyloc]b4_user_args[); |
| 1686 | if (yyflag != yyok) |
| 1687 | { |
| 1688 | yys->yysemantics.yyfirstVal = NULL; |
| 1689 | return yyflag; |
| 1690 | } |
| 1691 | yys->yysemantics.yysval = yysval; |
| 1692 | yys->yyresolved = yytrue; |
| 1693 | } |
| 1694 | } |
| 1695 | return yyok; |
| 1696 | } |
| 1697 | |
| 1698 | static YYRESULTTAG |
| 1699 | yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, |
| 1700 | YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
| 1701 | { |
| 1702 | yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; |
| 1703 | int yynrhs; |
| 1704 | int yychar_current; |
| 1705 | YYSTYPE yylval_current; |
| 1706 | YYLTYPE yylloc_current; |
| 1707 | YYRESULTTAG yyresult; |
| 1708 | |
| 1709 | yynrhs = yyrhsLength (yyopt->yyrule); |
| 1710 | YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[)); |
| 1711 | yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[ |
| 1712 | if (yynrhs == 0) |
| 1713 | /* Set default location. */ |
| 1714 | yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ |
| 1715 | yychar_current = yychar; |
| 1716 | yylval_current = yylval; |
| 1717 | yylloc_current = yylloc; |
| 1718 | yychar = yyopt->yyrawchar; |
| 1719 | yylval = yyopt->yyval; |
| 1720 | yylloc = yyopt->yyloc; |
| 1721 | yyresult = yyuserAction (yyopt->yyrule, yynrhs, |
| 1722 | yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, |
| 1723 | yyvalp, yylocp, yystackp]b4_user_args[); |
| 1724 | yychar = yychar_current; |
| 1725 | yylval = yylval_current; |
| 1726 | yylloc = yylloc_current; |
| 1727 | return yyresult; |
| 1728 | } |
| 1729 | |
| 1730 | #if YYDEBUG |
| 1731 | static void |
| 1732 | yyreportTree (yySemanticOption* yyx, int yyindent) |
| 1733 | { |
| 1734 | int yynrhs = yyrhsLength (yyx->yyrule); |
| 1735 | int yyi; |
| 1736 | yyGLRState* yys; |
| 1737 | yyGLRState* yystates[YYMAXRHS]; |
| 1738 | yyGLRState yyleftmost_state; |
| 1739 | |
| 1740 | for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) |
| 1741 | yystates[yyi] = yys; |
| 1742 | if (yys == NULL) |
| 1743 | { |
| 1744 | yyleftmost_state.yyposn = 0; |
| 1745 | yystates[0] = &yyleftmost_state; |
| 1746 | } |
| 1747 | else |
| 1748 | yystates[0] = yys; |
| 1749 | |
| 1750 | if (yyx->yystate->yyposn < yys->yyposn + 1) |
| 1751 | YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n", |
| 1752 | yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), |
| 1753 | yyx->yyrule); |
| 1754 | else |
| 1755 | YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n", |
| 1756 | yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), |
| 1757 | yyx->yyrule, (unsigned long int) (yys->yyposn + 1), |
| 1758 | (unsigned long int) yyx->yystate->yyposn); |
| 1759 | for (yyi = 1; yyi <= yynrhs; yyi += 1) |
| 1760 | { |
| 1761 | if (yystates[yyi]->yyresolved) |
| 1762 | { |
| 1763 | if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) |
| 1764 | YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "", |
| 1765 | yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1])); |
| 1766 | else |
| 1767 | YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "", |
| 1768 | yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]), |
| 1769 | (unsigned long int) (yystates[yyi - 1]->yyposn + 1), |
| 1770 | (unsigned long int) yystates[yyi]->yyposn); |
| 1771 | } |
| 1772 | else |
| 1773 | yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); |
| 1774 | } |
| 1775 | } |
| 1776 | #endif |
| 1777 | |
| 1778 | static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, |
| 1779 | yyGLRStack* yystackp]b4_pure_formals[) |
| 1780 | __attribute__ ((__noreturn__)); |
| 1781 | /*ARGSUSED*/ static void |
| 1782 | yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, |
| 1783 | yyGLRStack* yystackp]b4_pure_formals[) |
| 1784 | { |
| 1785 | YYUSE (yyx0); |
| 1786 | YYUSE (yyx1); |
| 1787 | |
| 1788 | #if YYDEBUG |
| 1789 | YYFPRINTF (stderr, "Ambiguity detected.\n"); |
| 1790 | YYFPRINTF (stderr, "Option 1,\n"); |
| 1791 | yyreportTree (yyx0, 2); |
| 1792 | YYFPRINTF (stderr, "\nOption 2,\n"); |
| 1793 | yyreportTree (yyx1, 2); |
| 1794 | YYFPRINTF (stderr, "\n"); |
| 1795 | #endif |
| 1796 | yyFail (yystackp][]b4_pure_args[, YY_("syntax is ambiguous")); |
| 1797 | } |
| 1798 | |
| 1799 | |
| 1800 | /** Resolve the ambiguity represented in state S, perform the indicated |
| 1801 | * actions, and return the result. */ |
| 1802 | static YYRESULTTAG |
| 1803 | yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp, YYSTYPE* yyvalp, |
| 1804 | YYLTYPE* yylocp]b4_user_formals[) |
| 1805 | { |
| 1806 | yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; |
| 1807 | yySemanticOption* yybest; |
| 1808 | yySemanticOption** yypp; |
| 1809 | yybool yymerge; |
| 1810 | |
| 1811 | yybest = yyoptionList; |
| 1812 | yymerge = yyfalse; |
| 1813 | for (yypp = &yyoptionList->yynext; *yypp != NULL; ) |
| 1814 | { |
| 1815 | yySemanticOption* yyp = *yypp; |
| 1816 | |
| 1817 | if (yyidenticalOptions (yybest, yyp)) |
| 1818 | { |
| 1819 | yymergeOptionSets (yybest, yyp); |
| 1820 | *yypp = yyp->yynext; |
| 1821 | } |
| 1822 | else |
| 1823 | { |
| 1824 | switch (yypreference (yybest, yyp)) |
| 1825 | { |
| 1826 | case 0: |
| 1827 | yyreportAmbiguity (yybest, yyp, yystackp]b4_pure_args[); |
| 1828 | break; |
| 1829 | case 1: |
| 1830 | yymerge = yytrue; |
| 1831 | break; |
| 1832 | case 2: |
| 1833 | break; |
| 1834 | case 3: |
| 1835 | yybest = yyp; |
| 1836 | yymerge = yyfalse; |
| 1837 | break; |
| 1838 | default: |
| 1839 | /* This cannot happen so it is not worth a YYASSERT (yyfalse), |
| 1840 | but some compilers complain if the default case is |
| 1841 | omitted. */ |
| 1842 | break; |
| 1843 | } |
| 1844 | yypp = &yyp->yynext; |
| 1845 | } |
| 1846 | } |
| 1847 | |
| 1848 | if (yymerge) |
| 1849 | { |
| 1850 | yySemanticOption* yyp; |
| 1851 | int yyprec = yydprec[yybest->yyrule]; |
| 1852 | YYCHK (yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[)); |
| 1853 | for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) |
| 1854 | { |
| 1855 | if (yyprec == yydprec[yyp->yyrule]) |
| 1856 | { |
| 1857 | YYSTYPE yyval1; |
| 1858 | YYLTYPE yydummy; |
| 1859 | YYRESULTTAG yyflag = yyresolveAction (yyp, yystackp, &yyval1, |
| 1860 | &yydummy]b4_user_args[); |
| 1861 | if (yyflag != yyok) |
| 1862 | { |
| 1863 | yydestruct ("Cleanup: discarding merged value", |
| 1864 | yystos[yys->yylrState], |
| 1865 | yyvalp]b4_location_if([, yylocp])[]b4_user_args[); |
| 1866 | return yyflag; |
| 1867 | } |
| 1868 | yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1); |
| 1869 | } |
| 1870 | } |
| 1871 | return yyok; |
| 1872 | } |
| 1873 | else |
| 1874 | return yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[); |
| 1875 | } |
| 1876 | |
| 1877 | static YYRESULTTAG |
| 1878 | yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) |
| 1879 | { |
| 1880 | if (yystackp->yysplitPoint != NULL) |
| 1881 | { |
| 1882 | yyGLRState* yys; |
| 1883 | int yyn; |
| 1884 | |
| 1885 | for (yyn = 0, yys = yystackp->yytops.yystates[0]; |
| 1886 | yys != yystackp->yysplitPoint; |
| 1887 | yys = yys->yypred, yyn += 1) |
| 1888 | continue; |
| 1889 | YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp |
| 1890 | ]b4_user_args[)); |
| 1891 | } |
| 1892 | return yyok; |
| 1893 | } |
| 1894 | |
| 1895 | static void |
| 1896 | yycompressStack (yyGLRStack* yystackp) |
| 1897 | { |
| 1898 | yyGLRState* yyp, *yyq, *yyr; |
| 1899 | |
| 1900 | if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL) |
| 1901 | return; |
| 1902 | |
| 1903 | for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL; |
| 1904 | yyp != yystackp->yysplitPoint; |
| 1905 | yyr = yyp, yyp = yyq, yyq = yyp->yypred) |
| 1906 | yyp->yypred = yyr; |
| 1907 | |
| 1908 | yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; |
| 1909 | yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1; |
| 1910 | yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; |
| 1911 | yystackp->yysplitPoint = NULL; |
| 1912 | yystackp->yylastDeleted = NULL; |
| 1913 | |
| 1914 | while (yyr != NULL) |
| 1915 | { |
| 1916 | yystackp->yynextFree->yystate = *yyr; |
| 1917 | yyr = yyr->yypred; |
| 1918 | yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate; |
| 1919 | yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate; |
| 1920 | yystackp->yynextFree += 1; |
| 1921 | yystackp->yyspaceLeft -= 1; |
| 1922 | } |
| 1923 | } |
| 1924 | |
| 1925 | static YYRESULTTAG |
| 1926 | yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, |
| 1927 | size_t yyposn]b4_pure_formals[) |
| 1928 | { |
| 1929 | int yyaction; |
| 1930 | const short int* yyconflicts; |
| 1931 | yyRuleNum yyrule; |
| 1932 | yySymbol* const yytokenp = yystackp->yytokenp; |
| 1933 | |
| 1934 | while (yystackp->yytops.yystates[yyk] != NULL) |
| 1935 | { |
| 1936 | yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; |
| 1937 | YYDPRINTF ((stderr, "Stack %lu Entering state %d\n", |
| 1938 | (unsigned long int) yyk, yystate)); |
| 1939 | |
| 1940 | YYASSERT (yystate != YYFINAL); |
| 1941 | |
| 1942 | if (yyisDefaultedState (yystate)) |
| 1943 | { |
| 1944 | yyrule = yydefaultAction (yystate); |
| 1945 | if (yyrule == 0) |
| 1946 | { |
| 1947 | YYDPRINTF ((stderr, "Stack %lu dies.\n", |
| 1948 | (unsigned long int) yyk)); |
| 1949 | yymarkStackDeleted (yystackp, yyk); |
| 1950 | return yyok; |
| 1951 | } |
| 1952 | YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[)); |
| 1953 | } |
| 1954 | else |
| 1955 | { |
| 1956 | yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; |
| 1957 | if (*yytokenp == YYEMPTY) |
| 1958 | { |
| 1959 | YYDPRINTF ((stderr, "Reading a token: ")); |
| 1960 | yychar = YYLEX; |
| 1961 | *yytokenp = YYTRANSLATE (yychar); |
| 1962 | YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc); |
| 1963 | } |
| 1964 | yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts); |
| 1965 | |
| 1966 | while (*yyconflicts != 0) |
| 1967 | { |
| 1968 | size_t yynewStack = yysplitStack (yystackp, yyk); |
| 1969 | YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n", |
| 1970 | (unsigned long int) yynewStack, |
| 1971 | (unsigned long int) yyk)); |
| 1972 | YYCHK (yyglrReduce (yystackp, yynewStack, |
| 1973 | *yyconflicts, yyfalse]b4_user_args[)); |
| 1974 | YYCHK (yyprocessOneStack (yystackp, yynewStack, |
| 1975 | yyposn]b4_pure_args[)); |
| 1976 | yyconflicts += 1; |
| 1977 | } |
| 1978 | |
| 1979 | if (yyisShiftAction (yyaction)) |
| 1980 | break; |
| 1981 | else if (yyisErrorAction (yyaction)) |
| 1982 | { |
| 1983 | YYDPRINTF ((stderr, "Stack %lu dies.\n", |
| 1984 | (unsigned long int) yyk)); |
| 1985 | yymarkStackDeleted (yystackp, yyk); |
| 1986 | break; |
| 1987 | } |
| 1988 | else |
| 1989 | YYCHK (yyglrReduce (yystackp, yyk, -yyaction, |
| 1990 | yyfalse]b4_user_args[)); |
| 1991 | } |
| 1992 | } |
| 1993 | return yyok; |
| 1994 | } |
| 1995 | |
| 1996 | /*ARGSUSED*/ static void |
| 1997 | yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) |
| 1998 | { |
| 1999 | if (yystackp->yyerrState == 0) |
| 2000 | { |
| 2001 | #if YYERROR_VERBOSE |
| 2002 | yySymbol* const yytokenp = yystackp->yytokenp; |
| 2003 | int yyn; |
| 2004 | yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; |
| 2005 | if (YYPACT_NINF < yyn && yyn < YYLAST) |
| 2006 | { |
| 2007 | size_t yysize0 = yytnamerr (NULL, yytokenName (*yytokenp)); |
| 2008 | size_t yysize = yysize0; |
| 2009 | size_t yysize1; |
| 2010 | yybool yysize_overflow = yyfalse; |
| 2011 | char* yymsg = NULL; |
| 2012 | enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; |
| 2013 | char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; |
| 2014 | int yyx; |
| 2015 | char *yyfmt; |
| 2016 | char const *yyf; |
| 2017 | static char const yyunexpected[] = "syntax error, unexpected %s"; |
| 2018 | static char const yyexpecting[] = ", expecting %s"; |
| 2019 | static char const yyor[] = " or %s"; |
| 2020 | char yyformat[sizeof yyunexpected |
| 2021 | + sizeof yyexpecting - 1 |
| 2022 | + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) |
| 2023 | * (sizeof yyor - 1))]; |
| 2024 | char const *yyprefix = yyexpecting; |
| 2025 | |
| 2026 | /* Start YYX at -YYN if negative to avoid negative indexes in |
| 2027 | YYCHECK. */ |
| 2028 | int yyxbegin = yyn < 0 ? -yyn : 0; |
| 2029 | |
| 2030 | /* Stay within bounds of both yycheck and yytname. */ |
| 2031 | int yychecklim = YYLAST - yyn; |
| 2032 | int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; |
| 2033 | int yycount = 1; |
| 2034 | |
| 2035 | yyarg[0] = yytokenName (*yytokenp); |
| 2036 | yyfmt = yystpcpy (yyformat, yyunexpected); |
| 2037 | |
| 2038 | for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
| 2039 | if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
| 2040 | { |
| 2041 | if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) |
| 2042 | { |
| 2043 | yycount = 1; |
| 2044 | yysize = yysize0; |
| 2045 | yyformat[sizeof yyunexpected - 1] = '\0'; |
| 2046 | break; |
| 2047 | } |
| 2048 | yyarg[yycount++] = yytokenName (yyx); |
| 2049 | yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx)); |
| 2050 | yysize_overflow |= yysize1 < yysize; |
| 2051 | yysize = yysize1; |
| 2052 | yyfmt = yystpcpy (yyfmt, yyprefix); |
| 2053 | yyprefix = yyor; |
| 2054 | } |
| 2055 | |
| 2056 | yyf = YY_(yyformat); |
| 2057 | yysize1 = yysize + strlen (yyf); |
| 2058 | yysize_overflow |= yysize1 < yysize; |
| 2059 | yysize = yysize1; |
| 2060 | |
| 2061 | if (!yysize_overflow) |
| 2062 | yymsg = (char *) YYMALLOC (yysize); |
| 2063 | |
| 2064 | if (yymsg) |
| 2065 | { |
| 2066 | char *yyp = yymsg; |
| 2067 | int yyi = 0; |
| 2068 | while ((*yyp = *yyf)) |
| 2069 | { |
| 2070 | if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) |
| 2071 | { |
| 2072 | yyp += yytnamerr (yyp, yyarg[yyi++]); |
| 2073 | yyf += 2; |
| 2074 | } |
| 2075 | else |
| 2076 | { |
| 2077 | yyp++; |
| 2078 | yyf++; |
| 2079 | } |
| 2080 | } |
| 2081 | yyerror (]b4_lyyerror_args[yymsg); |
| 2082 | YYFREE (yymsg); |
| 2083 | } |
| 2084 | else |
| 2085 | { |
| 2086 | yyerror (]b4_lyyerror_args[YY_("syntax error")); |
| 2087 | yyMemoryExhausted (yystackp); |
| 2088 | } |
| 2089 | } |
| 2090 | else |
| 2091 | #endif /* YYERROR_VERBOSE */ |
| 2092 | yyerror (]b4_lyyerror_args[YY_("syntax error")); |
| 2093 | yynerrs += 1; |
| 2094 | } |
| 2095 | } |
| 2096 | |
| 2097 | /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP, |
| 2098 | yylval, and yylloc are the syntactic category, semantic value, and location |
| 2099 | of the look-ahead. */ |
| 2100 | /*ARGSUSED*/ static void |
| 2101 | yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) |
| 2102 | { |
| 2103 | yySymbol* const yytokenp = yystackp->yytokenp; |
| 2104 | size_t yyk; |
| 2105 | int yyj; |
| 2106 | |
| 2107 | if (yystackp->yyerrState == 3) |
| 2108 | /* We just shifted the error token and (perhaps) took some |
| 2109 | reductions. Skip tokens until we can proceed. */ |
| 2110 | while (YYID (yytrue)) |
| 2111 | { |
| 2112 | if (*yytokenp == YYEOF) |
| 2113 | yyFail (yystackp][]b4_lpure_args[, NULL); |
| 2114 | if (*yytokenp != YYEMPTY) |
| 2115 | {]b4_location_if([[ |
| 2116 | /* We throw away the lookahead, but the error range |
| 2117 | of the shifted error token must take it into account. */ |
| 2118 | yyGLRState *yys = yystackp->yytops.yystates[0]; |
| 2119 | yyGLRStackItem yyerror_range[3]; |
| 2120 | yyerror_range[1].yystate.yyloc = yys->yyloc; |
| 2121 | yyerror_range[2].yystate.yyloc = yylloc; |
| 2122 | YYLLOC_DEFAULT (yys->yyloc, yyerror_range, 2);]])[ |
| 2123 | yydestruct ("Error: discarding", |
| 2124 | *yytokenp, &yylval]b4_location_if([, &yylloc])[]b4_user_args[); |
| 2125 | } |
| 2126 | YYDPRINTF ((stderr, "Reading a token: ")); |
| 2127 | yychar = YYLEX; |
| 2128 | *yytokenp = YYTRANSLATE (yychar); |
| 2129 | YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc); |
| 2130 | yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; |
| 2131 | if (yyis_pact_ninf (yyj)) |
| 2132 | return; |
| 2133 | yyj += *yytokenp; |
| 2134 | if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp) |
| 2135 | { |
| 2136 | if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) |
| 2137 | return; |
| 2138 | } |
| 2139 | else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj])) |
| 2140 | return; |
| 2141 | } |
| 2142 | |
| 2143 | /* Reduce to one stack. */ |
| 2144 | for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) |
| 2145 | if (yystackp->yytops.yystates[yyk] != NULL) |
| 2146 | break; |
| 2147 | if (yyk >= yystackp->yytops.yysize) |
| 2148 | yyFail (yystackp][]b4_lpure_args[, NULL); |
| 2149 | for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1) |
| 2150 | yymarkStackDeleted (yystackp, yyk); |
| 2151 | yyremoveDeletes (yystackp); |
| 2152 | yycompressStack (yystackp); |
| 2153 | |
| 2154 | /* Now pop stack until we find a state that shifts the error token. */ |
| 2155 | yystackp->yyerrState = 3; |
| 2156 | while (yystackp->yytops.yystates[0] != NULL) |
| 2157 | { |
| 2158 | yyGLRState *yys = yystackp->yytops.yystates[0]; |
| 2159 | yyj = yypact[yys->yylrState]; |
| 2160 | if (! yyis_pact_ninf (yyj)) |
| 2161 | { |
| 2162 | yyj += YYTERROR; |
| 2163 | if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR |
| 2164 | && yyisShiftAction (yytable[yyj])) |
| 2165 | { |
| 2166 | /* Shift the error token having adjusted its location. */ |
| 2167 | YYLTYPE yyerrloc;]b4_location_if([[ |
| 2168 | yystackp->yyerror_range[2].yystate.yyloc = yylloc; |
| 2169 | YYLLOC_DEFAULT (yyerrloc, yystackp->yyerror_range, 2);]])[ |
| 2170 | YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], |
| 2171 | &yylval, &yyerrloc); |
| 2172 | yyglrShift (yystackp, 0, yytable[yyj], |
| 2173 | yys->yyposn, &yylval, &yyerrloc); |
| 2174 | yys = yystackp->yytops.yystates[0]; |
| 2175 | break; |
| 2176 | } |
| 2177 | } |
| 2178 | ]b4_location_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ |
| 2179 | yydestroyGLRState ("Error: popping", yys]b4_user_args[); |
| 2180 | yystackp->yytops.yystates[0] = yys->yypred; |
| 2181 | yystackp->yynextFree -= 1; |
| 2182 | yystackp->yyspaceLeft += 1; |
| 2183 | } |
| 2184 | if (yystackp->yytops.yystates[0] == NULL) |
| 2185 | yyFail (yystackp][]b4_lpure_args[, NULL); |
| 2186 | } |
| 2187 | |
| 2188 | #define YYCHK1(YYE) \ |
| 2189 | do { \ |
| 2190 | switch (YYE) { \ |
| 2191 | case yyok: \ |
| 2192 | break; \ |
| 2193 | case yyabort: \ |
| 2194 | goto yyabortlab; \ |
| 2195 | case yyaccept: \ |
| 2196 | goto yyacceptlab; \ |
| 2197 | case yyerr: \ |
| 2198 | goto yyuser_error; \ |
| 2199 | default: \ |
| 2200 | goto yybuglab; \ |
| 2201 | } \ |
| 2202 | } while (YYID (0)) |
| 2203 | |
| 2204 | |
| 2205 | /*----------. |
| 2206 | | yyparse. | |
| 2207 | `----------*/ |
| 2208 | |
| 2209 | ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[ |
| 2210 | { |
| 2211 | int yyresult; |
| 2212 | yySymbol yytoken; |
| 2213 | yyGLRStack yystack; |
| 2214 | yyGLRStack* const yystackp = &yystack; |
| 2215 | size_t yyposn; |
| 2216 | |
| 2217 | YYDPRINTF ((stderr, "Starting parse\n")); |
| 2218 | |
| 2219 | yychar = YYEMPTY; |
| 2220 | yytoken = YYEMPTY; |
| 2221 | yylval = yyval_default; |
| 2222 | ]b4_location_if([ |
| 2223 | #if YYLTYPE_IS_TRIVIAL |
| 2224 | yylloc.first_line = yylloc.last_line = 1; |
| 2225 | yylloc.first_column = yylloc.last_column = 0; |
| 2226 | #endif |
| 2227 | ]) |
| 2228 | m4_ifdef([b4_initial_action], [ |
| 2229 | m4_pushdef([b4_at_dollar], [yylloc])dnl |
| 2230 | m4_pushdef([b4_dollar_dollar], [yylval])dnl |
| 2231 | /* User initialization code. */ |
| 2232 | b4_initial_action |
| 2233 | m4_popdef([b4_dollar_dollar])dnl |
| 2234 | m4_popdef([b4_at_dollar])dnl |
| 2235 | /* Line __line__ of glr.c. */ |
| 2236 | b4_syncline([@oline@], [@ofile@])])dnl |
| 2237 | [ |
| 2238 | if (! yyinitGLRStack (yystackp, YYINITDEPTH)) |
| 2239 | goto yyexhaustedlab; |
| 2240 | switch (YYSETJMP (yystack.yyexception_buffer)) |
| 2241 | { |
| 2242 | case 0: break; |
| 2243 | case 1: goto yyabortlab; |
| 2244 | case 2: goto yyexhaustedlab; |
| 2245 | default: goto yybuglab; |
| 2246 | } |
| 2247 | yystack.yytokenp = &yytoken; |
| 2248 | yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc); |
| 2249 | yyposn = 0; |
| 2250 | |
| 2251 | while (YYID (yytrue)) |
| 2252 | { |
| 2253 | /* For efficiency, we have two loops, the first of which is |
| 2254 | specialized to deterministic operation (single stack, no |
| 2255 | potential ambiguity). */ |
| 2256 | /* Standard mode */ |
| 2257 | while (YYID (yytrue)) |
| 2258 | { |
| 2259 | yyRuleNum yyrule; |
| 2260 | int yyaction; |
| 2261 | const short int* yyconflicts; |
| 2262 | |
| 2263 | yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; |
| 2264 | YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
| 2265 | if (yystate == YYFINAL) |
| 2266 | goto yyacceptlab; |
| 2267 | if (yyisDefaultedState (yystate)) |
| 2268 | { |
| 2269 | yyrule = yydefaultAction (yystate); |
| 2270 | if (yyrule == 0) |
| 2271 | { |
| 2272 | ]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ |
| 2273 | yyreportSyntaxError (&yystack]b4_user_args[); |
| 2274 | goto yyuser_error; |
| 2275 | } |
| 2276 | YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); |
| 2277 | } |
| 2278 | else |
| 2279 | { |
| 2280 | if (yytoken == YYEMPTY) |
| 2281 | { |
| 2282 | YYDPRINTF ((stderr, "Reading a token: ")); |
| 2283 | yychar = YYLEX; |
| 2284 | yytoken = YYTRANSLATE (yychar); |
| 2285 | YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
| 2286 | } |
| 2287 | yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); |
| 2288 | if (*yyconflicts != 0) |
| 2289 | break; |
| 2290 | if (yyisShiftAction (yyaction)) |
| 2291 | { |
| 2292 | YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
| 2293 | if (yytoken != YYEOF) |
| 2294 | { |
| 2295 | yychar = YYEMPTY; |
| 2296 | yytoken = YYEMPTY; |
| 2297 | } |
| 2298 | yyposn += 1; |
| 2299 | yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc); |
| 2300 | if (0 < yystack.yyerrState) |
| 2301 | yystack.yyerrState -= 1; |
| 2302 | } |
| 2303 | else if (yyisErrorAction (yyaction)) |
| 2304 | { |
| 2305 | ]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ |
| 2306 | yyreportSyntaxError (&yystack]b4_user_args[); |
| 2307 | goto yyuser_error; |
| 2308 | } |
| 2309 | else |
| 2310 | YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); |
| 2311 | } |
| 2312 | } |
| 2313 | |
| 2314 | while (YYID (yytrue)) |
| 2315 | { |
| 2316 | yySymbol yytoken_to_shift; |
| 2317 | size_t yys; |
| 2318 | size_t yyn = yystack.yytops.yysize; |
| 2319 | |
| 2320 | for (yys = 0; yys < yyn; yys += 1) |
| 2321 | yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; |
| 2322 | |
| 2323 | /* yyprocessOneStack returns one of three things: |
| 2324 | |
| 2325 | - An error flag. If the caller is yyprocessOneStack, it |
| 2326 | immediately returns as well. When the caller is finally |
| 2327 | yyparse, it jumps to an error label via YYCHK1. |
| 2328 | |
| 2329 | - yyok, but yyprocessOneStack has invoked yymarkStackDeleted |
| 2330 | (&yystack, yys), which sets the top state of yys to NULL. Thus, |
| 2331 | yyparse's following invocation of yyremoveDeletes will remove |
| 2332 | the stack. |
| 2333 | |
| 2334 | - yyok, when ready to shift a token. |
| 2335 | |
| 2336 | Except in the first case, yyparse will invoke yyremoveDeletes and |
| 2337 | then shift the next token onto all remaining stacks. This |
| 2338 | synchronization of the shift (that is, after all preceding |
| 2339 | reductions on all stacks) helps prevents double destructor calls |
| 2340 | on yylval in the event of memory exhaustion. */ |
| 2341 | |
| 2342 | for (yys = 0; yys < yyn; yys += 1) |
| 2343 | YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); |
| 2344 | yyremoveDeletes (&yystack); |
| 2345 | yyn = yystack.yytops.yysize; |
| 2346 | |
| 2347 | /* If any yyglrShift call fails, it will fail after shifting. Thus, |
| 2348 | a copy of yylval will already be on stack 0 in the event of a |
| 2349 | failure in the following loop. Thus, yytoken is set to YYEMPTY |
| 2350 | before the loop to make sure the user destructor for yylval isn't |
| 2351 | called twice. */ |
| 2352 | yytoken_to_shift = yytoken; |
| 2353 | yychar = YYEMPTY; |
| 2354 | yytoken = YYEMPTY; |
| 2355 | yyposn += 1; |
| 2356 | for (yys = 0; yys < yyn; yys += 1) |
| 2357 | { |
| 2358 | int yyaction; |
| 2359 | const short int* yyconflicts; |
| 2360 | yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState; |
| 2361 | yygetLRActions (yystate, yytoken_to_shift, &yyaction, |
| 2362 | &yyconflicts); |
| 2363 | /* Note that yyconflicts were handled by yyprocessOneStack. */ |
| 2364 | YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys)); |
| 2365 | YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); |
| 2366 | yyglrShift (&yystack, yys, yyaction, yyposn, |
| 2367 | &yylval, &yylloc); |
| 2368 | YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", |
| 2369 | (unsigned long int) yys, |
| 2370 | yystack.yytops.yystates[yys]->yylrState)); |
| 2371 | } |
| 2372 | if (yystack.yytops.yysize == 0) |
| 2373 | { |
| 2374 | yyundeleteLastStack (&yystack); |
| 2375 | if (yystack.yytops.yysize == 0) |
| 2376 | yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); |
| 2377 | YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); |
| 2378 | YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); |
| 2379 | ]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ |
| 2380 | yyreportSyntaxError (&yystack]b4_user_args[); |
| 2381 | goto yyuser_error; |
| 2382 | } |
| 2383 | else if (yystack.yytops.yysize == 1) |
| 2384 | { |
| 2385 | YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); |
| 2386 | YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); |
| 2387 | yycompressStack (&yystack); |
| 2388 | break; |
| 2389 | } |
| 2390 | } |
| 2391 | continue; |
| 2392 | yyuser_error: |
| 2393 | yyrecoverSyntaxError (&yystack]b4_user_args[); |
| 2394 | yyposn = yystack.yytops.yystates[0]->yyposn; |
| 2395 | } |
| 2396 | |
| 2397 | yyacceptlab: |
| 2398 | yyresult = 0; |
| 2399 | goto yyreturn; |
| 2400 | |
| 2401 | yybuglab: |
| 2402 | YYASSERT (yyfalse); |
| 2403 | goto yyabortlab; |
| 2404 | |
| 2405 | yyabortlab: |
| 2406 | yyresult = 1; |
| 2407 | goto yyreturn; |
| 2408 | |
| 2409 | yyexhaustedlab: |
| 2410 | yyerror (]b4_lyyerror_args[YY_("memory exhausted")); |
| 2411 | yyresult = 2; |
| 2412 | goto yyreturn; |
| 2413 | |
| 2414 | yyreturn: |
| 2415 | if (yytoken != YYEOF && yytoken != YYEMPTY) |
| 2416 | yydestruct ("Cleanup: discarding lookahead", |
| 2417 | yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[); |
| 2418 | |
| 2419 | /* If the stack is well-formed, pop the stack until it is empty, |
| 2420 | destroying its entries as we go. But free the stack regardless |
| 2421 | of whether it is well-formed. */ |
| 2422 | if (yystack.yyitems) |
| 2423 | { |
| 2424 | yyGLRState** yystates = yystack.yytops.yystates; |
| 2425 | if (yystates) |
| 2426 | { |
| 2427 | size_t yysize = yystack.yytops.yysize; |
| 2428 | size_t yyk; |
| 2429 | for (yyk = 0; yyk < yysize; yyk += 1) |
| 2430 | if (yystates[yyk]) |
| 2431 | { |
| 2432 | while (yystates[yyk]) |
| 2433 | { |
| 2434 | yyGLRState *yys = yystates[yyk]; |
| 2435 | ]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] |
| 2436 | )[ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); |
| 2437 | yystates[yyk] = yys->yypred; |
| 2438 | yystack.yynextFree -= 1; |
| 2439 | yystack.yyspaceLeft += 1; |
| 2440 | } |
| 2441 | break; |
| 2442 | } |
| 2443 | } |
| 2444 | yyfreeGLRStack (&yystack); |
| 2445 | } |
| 2446 | |
| 2447 | return yyresult; |
| 2448 | } |
| 2449 | |
| 2450 | /* DEBUGGING ONLY */ |
| 2451 | #ifdef YYDEBUG |
| 2452 | static void yypstack (yyGLRStack* yystackp, size_t yyk) |
| 2453 | __attribute__ ((__unused__)); |
| 2454 | static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__)); |
| 2455 | |
| 2456 | static void |
| 2457 | yy_yypstack (yyGLRState* yys) |
| 2458 | { |
| 2459 | if (yys->yypred) |
| 2460 | { |
| 2461 | yy_yypstack (yys->yypred); |
| 2462 | fprintf (stderr, " -> "); |
| 2463 | } |
| 2464 | fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn); |
| 2465 | } |
| 2466 | |
| 2467 | static void |
| 2468 | yypstates (yyGLRState* yyst) |
| 2469 | { |
| 2470 | if (yyst == NULL) |
| 2471 | fprintf (stderr, "<null>"); |
| 2472 | else |
| 2473 | yy_yypstack (yyst); |
| 2474 | fprintf (stderr, "\n"); |
| 2475 | } |
| 2476 | |
| 2477 | static void |
| 2478 | yypstack (yyGLRStack* yystackp, size_t yyk) |
| 2479 | { |
| 2480 | yypstates (yystackp->yytops.yystates[yyk]); |
| 2481 | } |
| 2482 | |
| 2483 | #define YYINDEX(YYX) \ |
| 2484 | ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) |
| 2485 | |
| 2486 | |
| 2487 | static void |
| 2488 | yypdumpstack (yyGLRStack* yystackp) |
| 2489 | { |
| 2490 | yyGLRStackItem* yyp; |
| 2491 | size_t yyi; |
| 2492 | for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) |
| 2493 | { |
| 2494 | fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystackp->yyitems)); |
| 2495 | if (*(yybool *) yyp) |
| 2496 | { |
| 2497 | fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", |
| 2498 | yyp->yystate.yyresolved, yyp->yystate.yylrState, |
| 2499 | (unsigned long int) yyp->yystate.yyposn, |
| 2500 | (long int) YYINDEX (yyp->yystate.yypred)); |
| 2501 | if (! yyp->yystate.yyresolved) |
| 2502 | fprintf (stderr, ", firstVal: %ld", |
| 2503 | (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); |
| 2504 | } |
| 2505 | else |
| 2506 | { |
| 2507 | fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld", |
| 2508 | yyp->yyoption.yyrule, |
| 2509 | (long int) YYINDEX (yyp->yyoption.yystate), |
| 2510 | (long int) YYINDEX (yyp->yyoption.yynext)); |
| 2511 | } |
| 2512 | fprintf (stderr, "\n"); |
| 2513 | } |
| 2514 | fprintf (stderr, "Tops:"); |
| 2515 | for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) |
| 2516 | fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi, |
| 2517 | (long int) YYINDEX (yystackp->yytops.yystates[yyi])); |
| 2518 | fprintf (stderr, "\n"); |
| 2519 | } |
| 2520 | #endif |
| 2521 | ] |
| 2522 | |
| 2523 | b4_epilogue |
| 2524 | m4_if(b4_defines_flag, 0, [], |
| 2525 | [@output @output_header_name@ |
| 2526 | b4_copyright([Skeleton parser for GLR parsing with Bison], |
| 2527 | [2002, 2003, 2004, 2005, 2006])[ |
| 2528 | |
| 2529 | /* C GLR parser skeleton written by Paul Hilfinger. */ |
| 2530 | ] |
| 2531 | |
| 2532 | b4_shared_declarations |
| 2533 | |
| 2534 | extern YYSTYPE b4_prefix[]lval; |
| 2535 | |
| 2536 | b4_location_if([b4_pure_if([], |
| 2537 | [extern YYLTYPE b4_prefix[]lloc;]) |
| 2538 | ]) |
| 2539 | ]) |