Index: bison/src/bison/2.4.1/bison-2.4.1-src/data/glr.c |
=================================================================== |
--- bison/src/bison/2.4.1/bison-2.4.1-src/data/glr.c (revision 0) |
+++ bison/src/bison/2.4.1/bison-2.4.1-src/data/glr.c (revision 0) |
@@ -0,0 +1,2653 @@ |
+ -*- C -*- |
+ |
+# GLR skeleton for Bison |
+# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software |
+# Foundation, Inc. |
+ |
+# This program is free software: you can redistribute it and/or modify |
+# it under the terms of the GNU General Public License as published by |
+# the Free Software Foundation, either version 3 of the License, or |
+# (at your option) any later version. |
+# |
+# This program is distributed in the hope that it will be useful, |
+# but WITHOUT ANY WARRANTY; without even the implied warranty of |
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
+# GNU General Public License for more details. |
+# |
+# You should have received a copy of the GNU General Public License |
+# along with this program. If not, see <http://www.gnu.org/licenses/>. |
+ |
+ |
+m4_include(b4_pkgdatadir/[c.m4]) |
+ |
+## ---------------- ## |
+## Default values. ## |
+## ---------------- ## |
+ |
+# Stack parameters. |
+m4_define_default([b4_stack_depth_max], [10000]) |
+m4_define_default([b4_stack_depth_init], [200]) |
+ |
+ |
+ |
+## ------------------------ ## |
+## Pure/impure interfaces. ## |
+## ------------------------ ## |
+ |
+b4_define_flag_if([pure]) |
+# If glr.cc is including this file and thus has already set b4_pure_flag, don't |
+# change the value of b4_pure_flag, and don't record a use of api.pure. |
+m4_ifndef([b4_pure_flag], |
+[b4_percent_define_default([[api.pure]], [[false]]) |
+ m4_define([b4_pure_flag], |
+ [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])]) |
+ |
+# b4_user_formals |
+# --------------- |
+# The possible parse-params formal arguments preceded by a comma. |
+# |
+# This is not shared with yacc.c in c.m4 because GLR relies on ISO C |
+# formal argument declarations. |
+m4_define([b4_user_formals], |
+[m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])]) |
+ |
+ |
+# b4_lex_param |
+# ------------ |
+# Accumule in b4_lex_param all the yylex arguments. |
+# Yes, this is quite ugly... |
+m4_define([b4_lex_param], |
+m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl |
+b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl |
+m4_ifdef([b4_lex_param], [, ]b4_lex_param))) |
+ |
+ |
+# b4_yyerror_args |
+# --------------- |
+# Optional effective arguments passed to yyerror: user args plus yylloc, and |
+# a trailing comma. |
+m4_define([b4_yyerror_args], |
+[b4_pure_if([b4_locations_if([yylocp, ])])dnl |
+m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) |
+ |
+ |
+# b4_lyyerror_args |
+# ---------------- |
+# Same as above, but on the lookahead, hence &yylloc instead of yylocp. |
+m4_define([b4_lyyerror_args], |
+[b4_pure_if([b4_locations_if([&yylloc, ])])dnl |
+m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) |
+ |
+ |
+# b4_pure_args |
+# ------------ |
+# Same as b4_yyerror_args, but with a leading comma. |
+m4_define([b4_pure_args], |
+[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args]) |
+ |
+ |
+# b4_lpure_args |
+# ------------- |
+# Same as above, but on the lookahead, hence &yylloc instead of yylocp. |
+m4_define([b4_lpure_args], |
+[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args]) |
+ |
+ |
+# b4_pure_formals |
+# --------------- |
+# Arguments passed to yyerror: user formals plus yylocp. |
+m4_define([b4_pure_formals], |
+[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) |
+ |
+ |
+## ----------------- ## |
+## Semantic Values. ## |
+## ----------------- ## |
+ |
+ |
+# b4_lhs_value([TYPE]) |
+# -------------------- |
+# Expansion of $<TYPE>$. |
+m4_define([b4_lhs_value], |
+[((*yyvalp)[]m4_ifval([$1], [.$1]))]) |
+ |
+ |
+# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) |
+# -------------------------------------- |
+# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH |
+# symbols on RHS. |
+m4_define([b4_rhs_value], |
+[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))]) |
+ |
+ |
+ |
+## ----------- ## |
+## Locations. ## |
+## ----------- ## |
+ |
+# b4_lhs_location() |
+# ----------------- |
+# Expansion of @$. |
+m4_define([b4_lhs_location], |
+[(*yylocp)]) |
+ |
+ |
+# b4_rhs_location(RULE-LENGTH, NUM) |
+# --------------------------------- |
+# Expansion of @NUM, where the current rule has RULE-LENGTH symbols |
+# on RHS. |
+m4_define([b4_rhs_location], |
+[(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)]) |
+ |
+ |
+ |
+## -------------- ## |
+## Output files. ## |
+## -------------- ## |
+ |
+# We do want M4 expansion after # for CPP macros. |
+m4_changecom() |
+m4_divert_push(0)dnl |
+@output(b4_parser_file_name@) |
+b4_copyright([Skeleton implementation for Bison GLR parsers in C], |
+ [2002, 2003, 2004, 2005, 2006]) |
+[ |
+/* C GLR parser skeleton written by Paul Hilfinger. */ |
+ |
+]b4_identification |
+ |
+b4_percent_code_get([[top]])[]dnl |
+m4_if(b4_prefix, [yy], [], |
+[/* Substitute the variable and function names. */ |
+#define yyparse b4_prefix[]parse |
+#define yylex b4_prefix[]lex |
+#define yyerror b4_prefix[]error |
+#define yylval b4_prefix[]lval |
+#define yychar b4_prefix[]char |
+#define yydebug b4_prefix[]debug |
+#define yynerrs b4_prefix[]nerrs |
+#define yylloc b4_prefix[]lloc])[ |
+ |
+/* Copy the first part of user declarations. */ |
+]b4_user_pre_prologue |
+ |
+dnl # b4_shared_declarations |
+dnl # ---------------------- |
+dnl # Declaration that might either go into the header (if --defines) |
+dnl # or open coded in the parser body. |
+m4_define([b4_shared_declarations], |
+[b4_percent_code_get([[requires]])[]dnl |
+ |
+b4_token_enums(b4_tokens) |
+ |
+[#ifndef YYSTYPE |
+]m4_ifdef([b4_stype], |
+[[typedef union ]b4_union_name[ |
+{ |
+]b4_user_stype[ |
+} YYSTYPE; |
+# define YYSTYPE_IS_TRIVIAL 1]], |
+[m4_if(b4_tag_seen_flag, 0, |
+[[typedef int YYSTYPE; |
+# define YYSTYPE_IS_TRIVIAL 1]])])[ |
+#endif |
+ |
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED |
+typedef struct YYLTYPE |
+{ |
+]b4_locations_if([ |
+ int first_line; |
+ int first_column; |
+ int last_line; |
+ int last_column; |
+],[ |
+ char yydummy; |
+])[ |
+} YYLTYPE; |
+# define YYLTYPE_IS_DECLARED 1 |
+# define YYLTYPE_IS_TRIVIAL 1 |
+#endif |
+ |
+]b4_percent_code_get([[provides]])[]dnl |
+]) |
+ |
+b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], |
+ [b4_shared_declarations])[ |
+ |
+/* Enabling traces. */ |
+#ifndef YYDEBUG |
+# define YYDEBUG ]b4_debug_flag[ |
+#endif |
+ |
+/* Enabling verbose error messages. */ |
+#ifdef YYERROR_VERBOSE |
+# undef YYERROR_VERBOSE |
+# define YYERROR_VERBOSE 1 |
+#else |
+# define YYERROR_VERBOSE ]b4_error_verbose_flag[ |
+#endif |
+ |
+/* Enabling the token table. */ |
+#ifndef YYTOKEN_TABLE |
+# define YYTOKEN_TABLE ]b4_token_table[ |
+#endif |
+ |
+/* Default (constant) value used for initialization for null |
+ right-hand sides. Unlike the standard yacc.c template, |
+ here we set the default value of $$ to a zeroed-out value. |
+ Since the default value is undefined, this behavior is |
+ technically correct. */ |
+static YYSTYPE yyval_default; |
+ |
+/* Copy the second part of user declarations. */ |
+]b4_user_post_prologue |
+b4_percent_code_get[]dnl |
+ |
+[#include <stdio.h> |
+#include <stdlib.h> |
+#include <string.h> |
+ |
+#ifndef YY_ |
+# if YYENABLE_NLS |
+# if ENABLE_NLS |
+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ |
+# define YY_(msgid) dgettext ("bison-runtime", msgid) |
+# endif |
+# endif |
+# ifndef YY_ |
+# define YY_(msgid) msgid |
+# endif |
+#endif |
+ |
+/* Suppress unused-variable warnings by "using" E. */ |
+#if ! defined lint || defined __GNUC__ |
+# define YYUSE(e) ((void) (e)) |
+#else |
+# define YYUSE(e) /* empty */ |
+#endif |
+ |
+/* Identity function, used to suppress warnings about constant conditions. */ |
+#ifndef lint |
+# define YYID(n) (n) |
+#else |
+]b4_c_function_def([YYID], [static int], [[int i], [i]])[ |
+{ |
+ return i; |
+} |
+#endif |
+ |
+#ifndef YYFREE |
+# define YYFREE free |
+#endif |
+#ifndef YYMALLOC |
+# define YYMALLOC malloc |
+#endif |
+#ifndef YYREALLOC |
+# define YYREALLOC realloc |
+#endif |
+ |
+#define YYSIZEMAX ((size_t) -1) |
+ |
+#ifdef __cplusplus |
+ typedef bool yybool; |
+#else |
+ typedef unsigned char yybool; |
+#endif |
+#define yytrue 1 |
+#define yyfalse 0 |
+ |
+#ifndef YYSETJMP |
+# include <setjmp.h> |
+# define YYJMP_BUF jmp_buf |
+# define YYSETJMP(env) setjmp (env) |
+# define YYLONGJMP(env, val) longjmp (env, val) |
+#endif |
+ |
+/*-----------------. |
+| GCC extensions. | |
+`-----------------*/ |
+ |
+#ifndef __attribute__ |
+/* This feature is available in gcc versions 2.5 and later. */ |
+# if (! defined __GNUC__ || __GNUC__ < 2 \ |
+ || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__) |
+# define __attribute__(Spec) /* empty */ |
+# endif |
+#endif |
+ |
+]b4_locations_if([#define YYOPTIONAL_LOC(Name) Name],[ |
+#ifdef __cplusplus |
+# define YYOPTIONAL_LOC(Name) /* empty */ |
+#else |
+# define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__)) |
+#endif])[ |
+ |
+#ifndef YYASSERT |
+# define YYASSERT(condition) ((void) ((condition) || (abort (), 0))) |
+#endif |
+ |
+/* YYFINAL -- State number of the termination state. */ |
+#define YYFINAL ]b4_final_state_number[ |
+/* YYLAST -- Last index in YYTABLE. */ |
+#define YYLAST ]b4_last[ |
+ |
+/* YYNTOKENS -- Number of terminals. */ |
+#define YYNTOKENS ]b4_tokens_number[ |
+/* YYNNTS -- Number of nonterminals. */ |
+#define YYNNTS ]b4_nterms_number[ |
+/* YYNRULES -- Number of rules. */ |
+#define YYNRULES ]b4_rules_number[ |
+/* YYNRULES -- Number of states. */ |
+#define YYNSTATES ]b4_states_number[ |
+/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ |
+#define YYMAXRHS ]b4_r2_max[ |
+/* YYMAXLEFT -- Maximum number of symbols to the left of a handle |
+ accessed by $0, $-1, etc., in any rule. */ |
+#define YYMAXLEFT ]b4_max_left_semantic_context[ |
+ |
+/* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */ |
+#define YYUNDEFTOK ]b4_undef_token_number[ |
+#define YYMAXUTOK ]b4_user_token_number_max[ |
+ |
+#define YYTRANSLATE(YYX) \ |
+ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
+ |
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
+static const ]b4_int_type_for([b4_translate])[ yytranslate[] = |
+{ |
+ ]b4_translate[ |
+}; |
+ |
+#if YYDEBUG |
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
+ YYRHS. */ |
+static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = |
+{ |
+ ]b4_prhs[ |
+}; |
+ |
+/* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
+static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = |
+{ |
+ ]b4_rhs[ |
+}; |
+ |
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
+static const ]b4_int_type_for([b4_rline])[ yyrline[] = |
+{ |
+ ]b4_rline[ |
+}; |
+#endif |
+ |
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
+static const char *const yytname[] = |
+{ |
+ ]b4_tname[ |
+}; |
+#endif |
+ |
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
+static const ]b4_int_type_for([b4_r1])[ yyr1[] = |
+{ |
+ ]b4_r1[ |
+}; |
+ |
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
+static const ]b4_int_type_for([b4_r2])[ yyr2[] = |
+{ |
+ ]b4_r2[ |
+}; |
+ |
+/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ |
+static const ]b4_int_type_for([b4_dprec])[ yydprec[] = |
+{ |
+ ]b4_dprec[ |
+}; |
+ |
+/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ |
+static const ]b4_int_type_for([b4_merger])[ yymerger[] = |
+{ |
+ ]b4_merger[ |
+}; |
+ |
+/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE |
+ doesn't specify something else to do. Zero means the default is an |
+ error. */ |
+static const ]b4_int_type_for([b4_defact])[ yydefact[] = |
+{ |
+ ]b4_defact[ |
+}; |
+ |
+/* YYPDEFGOTO[NTERM-NUM]. */ |
+static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = |
+{ |
+ ]b4_defgoto[ |
+}; |
+ |
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
+ STATE-NUM. */ |
+#define YYPACT_NINF ]b4_pact_ninf[ |
+static const ]b4_int_type_for([b4_pact])[ yypact[] = |
+{ |
+ ]b4_pact[ |
+}; |
+ |
+/* YYPGOTO[NTERM-NUM]. */ |
+static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = |
+{ |
+ ]b4_pgoto[ |
+}; |
+ |
+/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
+ positive, shift that token. If negative, reduce the rule which |
+ number is the opposite. If zero, do what YYDEFACT says. |
+ If YYTABLE_NINF, syntax error. */ |
+#define YYTABLE_NINF ]b4_table_ninf[ |
+static const ]b4_int_type_for([b4_table])[ yytable[] = |
+{ |
+ ]b4_table[ |
+}; |
+ |
+/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of |
+ list of conflicting reductions corresponding to action entry for |
+ state STATE-NUM in yytable. 0 means no conflicts. The list in |
+ yyconfl is terminated by a rule number of 0. */ |
+static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = |
+{ |
+ ]b4_conflict_list_heads[ |
+}; |
+ |
+/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by |
+ 0, pointed into by YYCONFLP. */ |
+]dnl Do not use b4_int_type_for here, since there are places where |
+dnl pointers onto yyconfl are taken, which type is "short int *". |
+dnl We probably ought to introduce a type for confl. |
+[static const short int yyconfl[] = |
+{ |
+ ]b4_conflicting_rules[ |
+}; |
+ |
+static const ]b4_int_type_for([b4_check])[ yycheck[] = |
+{ |
+ ]b4_check[ |
+}; |
+ |
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
+ symbol of state STATE-NUM. */ |
+static const ]b4_int_type_for([b4_stos])[ yystos[] = |
+{ |
+ ]b4_stos[ |
+}; |
+ |
+ |
+/* Prevent warning if -Wmissing-prototypes. */ |
+]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[ |
+ |
+/* Error token number */ |
+#define YYTERROR 1 |
+ |
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
+ If N is 0, then set CURRENT to the empty location which ends |
+ the previous symbol: RHS[0] (always defined). */ |
+ |
+]b4_locations_if([[ |
+#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) |
+#ifndef YYLLOC_DEFAULT |
+# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
+ do \ |
+ if (YYID (N)) \ |
+ { \ |
+ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ |
+ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ |
+ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ |
+ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ |
+ } \ |
+ else \ |
+ { \ |
+ (Current).first_line = (Current).last_line = \ |
+ YYRHSLOC (Rhs, 0).last_line; \ |
+ (Current).first_column = (Current).last_column = \ |
+ YYRHSLOC (Rhs, 0).last_column; \ |
+ } \ |
+ while (YYID (0)) |
+ |
+/* YY_LOCATION_PRINT -- Print the location on the stream. |
+ This macro was not mandated originally: define only if we know |
+ we won't break user code: when these are the locations we know. */ |
+ |
+# define YY_LOCATION_PRINT(File, Loc) \ |
+ fprintf (File, "%d.%d-%d.%d", \ |
+ (Loc).first_line, (Loc).first_column, \ |
+ (Loc).last_line, (Loc).last_column) |
+#endif |
+]],[ |
+#ifndef YYLLOC_DEFAULT |
+# define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0) |
+#endif |
+])[ |
+ |
+#ifndef YY_LOCATION_PRINT |
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0) |
+#endif |
+ |
+ |
+/* YYLEX -- calling `yylex' with the right arguments. */ |
+#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ |
+ |
+]b4_pure_if( |
+[ |
+#undef yynerrs |
+#define yynerrs (yystackp->yyerrcnt) |
+#undef yychar |
+#define yychar (yystackp->yyrawchar) |
+#undef yylval |
+#define yylval (yystackp->yyval) |
+#undef yylloc |
+#define yylloc (yystackp->yyloc) |
+m4_if(b4_prefix[], [yy], [], |
+[#define b4_prefix[]nerrs yynerrs |
+#define b4_prefix[]char yychar |
+#define b4_prefix[]lval yylval |
+#define b4_prefix[]lloc yylloc])], |
+[YYSTYPE yylval; |
+ |
+YYLTYPE yylloc; |
+ |
+int yynerrs; |
+int yychar;])[ |
+ |
+static const int YYEOF = 0; |
+static const int YYEMPTY = -2; |
+ |
+typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; |
+ |
+#define YYCHK(YYE) \ |
+ do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \ |
+ while (YYID (0)) |
+ |
+#if YYDEBUG |
+ |
+# ifndef YYFPRINTF |
+# define YYFPRINTF fprintf |
+# endif |
+ |
+# define YYDPRINTF(Args) \ |
+do { \ |
+ if (yydebug) \ |
+ YYFPRINTF Args; \ |
+} while (YYID (0)) |
+ |
+]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[ |
+ |
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
+do { \ |
+ if (yydebug) \ |
+ { \ |
+ YYFPRINTF (stderr, "%s ", Title); \ |
+ yy_symbol_print (stderr, Type, \ |
+ Value]b4_locations_if([, Location])[]b4_user_args[); \ |
+ YYFPRINTF (stderr, "\n"); \ |
+ } \ |
+} while (YYID (0)) |
+ |
+/* Nonzero means print parse trace. It is left uninitialized so that |
+ multiple parsers can coexist. */ |
+int yydebug; |
+ |
+#else /* !YYDEBUG */ |
+ |
+# define YYDPRINTF(Args) |
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) |
+ |
+#endif /* !YYDEBUG */ |
+ |
+/* YYINITDEPTH -- initial size of the parser's stacks. */ |
+#ifndef YYINITDEPTH |
+# define YYINITDEPTH ]b4_stack_depth_init[ |
+#endif |
+ |
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
+ if the built-in stack extension method is used). |
+ |
+ Do not make this value too large; the results are undefined if |
+ SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) |
+ evaluated with infinite-precision integer arithmetic. */ |
+ |
+#ifndef YYMAXDEPTH |
+# define YYMAXDEPTH ]b4_stack_depth_max[ |
+#endif |
+ |
+/* Minimum number of free items on the stack allowed after an |
+ allocation. This is to allow allocation and initialization |
+ to be completed by functions that call yyexpandGLRStack before the |
+ stack is expanded, thus insuring that all necessary pointers get |
+ properly redirected to new data. */ |
+#define YYHEADROOM 2 |
+ |
+#ifndef YYSTACKEXPANDABLE |
+# if (! defined __cplusplus \ |
+ || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ |
+ && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)) |
+# define YYSTACKEXPANDABLE 1 |
+# else |
+# define YYSTACKEXPANDABLE 0 |
+# endif |
+#endif |
+ |
+#if YYSTACKEXPANDABLE |
+# define YY_RESERVE_GLRSTACK(Yystack) \ |
+ do { \ |
+ if (Yystack->yyspaceLeft < YYHEADROOM) \ |
+ yyexpandGLRStack (Yystack); \ |
+ } while (YYID (0)) |
+#else |
+# define YY_RESERVE_GLRSTACK(Yystack) \ |
+ do { \ |
+ if (Yystack->yyspaceLeft < YYHEADROOM) \ |
+ yyMemoryExhausted (Yystack); \ |
+ } while (YYID (0)) |
+#endif |
+ |
+ |
+#if YYERROR_VERBOSE |
+ |
+# ifndef yystpcpy |
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE |
+# define yystpcpy stpcpy |
+# else |
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in |
+ YYDEST. */ |
+static char * |
+yystpcpy (char *yydest, const char *yysrc) |
+{ |
+ char *yyd = yydest; |
+ const char *yys = yysrc; |
+ |
+ while ((*yyd++ = *yys++) != '\0') |
+ continue; |
+ |
+ return yyd - 1; |
+} |
+# endif |
+# endif |
+ |
+# ifndef yytnamerr |
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary |
+ quotes and backslashes, so that it's suitable for yyerror. The |
+ heuristic is that double-quoting is unnecessary unless the string |
+ contains an apostrophe, a comma, or backslash (other than |
+ backslash-backslash). YYSTR is taken from yytname. If YYRES is |
+ null, do not copy; instead, return the length of what the result |
+ would have been. */ |
+static size_t |
+yytnamerr (char *yyres, const char *yystr) |
+{ |
+ if (*yystr == '"') |
+ { |
+ size_t yyn = 0; |
+ char const *yyp = yystr; |
+ |
+ for (;;) |
+ switch (*++yyp) |
+ { |
+ case '\'': |
+ case ',': |
+ goto do_not_strip_quotes; |
+ |
+ case '\\': |
+ if (*++yyp != '\\') |
+ goto do_not_strip_quotes; |
+ /* Fall through. */ |
+ default: |
+ if (yyres) |
+ yyres[yyn] = *yyp; |
+ yyn++; |
+ break; |
+ |
+ case '"': |
+ if (yyres) |
+ yyres[yyn] = '\0'; |
+ return yyn; |
+ } |
+ do_not_strip_quotes: ; |
+ } |
+ |
+ if (! yyres) |
+ return strlen (yystr); |
+ |
+ return yystpcpy (yyres, yystr) - yyres; |
+} |
+# endif |
+ |
+#endif /* !YYERROR_VERBOSE */ |
+ |
+/** State numbers, as in LALR(1) machine */ |
+typedef int yyStateNum; |
+ |
+/** Rule numbers, as in LALR(1) machine */ |
+typedef int yyRuleNum; |
+ |
+/** Grammar symbol */ |
+typedef short int yySymbol; |
+ |
+/** Item references, as in LALR(1) machine */ |
+typedef short int yyItemNum; |
+ |
+typedef struct yyGLRState yyGLRState; |
+typedef struct yyGLRStateSet yyGLRStateSet; |
+typedef struct yySemanticOption yySemanticOption; |
+typedef union yyGLRStackItem yyGLRStackItem; |
+typedef struct yyGLRStack yyGLRStack; |
+ |
+struct yyGLRState { |
+ /** Type tag: always true. */ |
+ yybool yyisState; |
+ /** Type tag for yysemantics. If true, yysval applies, otherwise |
+ * yyfirstVal applies. */ |
+ yybool yyresolved; |
+ /** Number of corresponding LALR(1) machine state. */ |
+ yyStateNum yylrState; |
+ /** Preceding state in this stack */ |
+ yyGLRState* yypred; |
+ /** Source position of the first token produced by my symbol */ |
+ size_t yyposn; |
+ union { |
+ /** First in a chain of alternative reductions producing the |
+ * non-terminal corresponding to this state, threaded through |
+ * yynext. */ |
+ yySemanticOption* yyfirstVal; |
+ /** Semantic value for this state. */ |
+ YYSTYPE yysval; |
+ } yysemantics; |
+ /** Source location for this state. */ |
+ YYLTYPE yyloc; |
+}; |
+ |
+struct yyGLRStateSet { |
+ yyGLRState** yystates; |
+ /** During nondeterministic operation, yylookaheadNeeds tracks which |
+ * stacks have actually needed the current lookahead. During deterministic |
+ * operation, yylookaheadNeeds[0] is not maintained since it would merely |
+ * duplicate yychar != YYEMPTY. */ |
+ yybool* yylookaheadNeeds; |
+ size_t yysize, yycapacity; |
+}; |
+ |
+struct yySemanticOption { |
+ /** Type tag: always false. */ |
+ yybool yyisState; |
+ /** Rule number for this reduction */ |
+ yyRuleNum yyrule; |
+ /** The last RHS state in the list of states to be reduced. */ |
+ yyGLRState* yystate; |
+ /** The lookahead for this reduction. */ |
+ int yyrawchar; |
+ YYSTYPE yyval; |
+ YYLTYPE yyloc; |
+ /** Next sibling in chain of options. To facilitate merging, |
+ * options are chained in decreasing order by address. */ |
+ yySemanticOption* yynext; |
+}; |
+ |
+/** Type of the items in the GLR stack. The yyisState field |
+ * indicates which item of the union is valid. */ |
+union yyGLRStackItem { |
+ yyGLRState yystate; |
+ yySemanticOption yyoption; |
+}; |
+ |
+struct yyGLRStack { |
+ int yyerrState; |
+]b4_locations_if([[ /* To compute the location of the error token. */ |
+ yyGLRStackItem yyerror_range[3];]])[ |
+]b4_pure_if( |
+[ |
+ int yyerrcnt; |
+ int yyrawchar; |
+ YYSTYPE yyval; |
+ YYLTYPE yyloc; |
+])[ |
+ YYJMP_BUF yyexception_buffer; |
+ yyGLRStackItem* yyitems; |
+ yyGLRStackItem* yynextFree; |
+ size_t yyspaceLeft; |
+ yyGLRState* yysplitPoint; |
+ yyGLRState* yylastDeleted; |
+ yyGLRStateSet yytops; |
+}; |
+ |
+#if YYSTACKEXPANDABLE |
+static void yyexpandGLRStack (yyGLRStack* yystackp); |
+#endif |
+ |
+static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) |
+ __attribute__ ((__noreturn__)); |
+static void |
+yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) |
+{ |
+ if (yymsg != NULL) |
+ yyerror (]b4_yyerror_args[yymsg); |
+ YYLONGJMP (yystackp->yyexception_buffer, 1); |
+} |
+ |
+static void yyMemoryExhausted (yyGLRStack* yystackp) |
+ __attribute__ ((__noreturn__)); |
+static void |
+yyMemoryExhausted (yyGLRStack* yystackp) |
+{ |
+ YYLONGJMP (yystackp->yyexception_buffer, 2); |
+} |
+ |
+#if YYDEBUG || YYERROR_VERBOSE |
+/** A printable representation of TOKEN. */ |
+static inline const char* |
+yytokenName (yySymbol yytoken) |
+{ |
+ if (yytoken == YYEMPTY) |
+ return ""; |
+ |
+ return yytname[yytoken]; |
+} |
+#endif |
+ |
+/** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting |
+ * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred |
+ * containing the pointer to the next state in the chain. */ |
+static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__)); |
+static void |
+yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) |
+{ |
+ yyGLRState* s; |
+ int i; |
+ s = yyvsp[yylow0].yystate.yypred; |
+ for (i = yylow0-1; i >= yylow1; i -= 1) |
+ { |
+ YYASSERT (s->yyresolved); |
+ yyvsp[i].yystate.yyresolved = yytrue; |
+ yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval; |
+ yyvsp[i].yystate.yyloc = s->yyloc; |
+ s = yyvsp[i].yystate.yypred = s->yypred; |
+ } |
+} |
+ |
+/* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in |
+ * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. |
+ * For convenience, always return YYLOW1. */ |
+static inline int yyfill (yyGLRStackItem *, int *, int, yybool) |
+ __attribute__ ((__unused__)); |
+static inline int |
+yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) |
+{ |
+ if (!yynormal && yylow1 < *yylow) |
+ { |
+ yyfillin (yyvsp, *yylow, yylow1); |
+ *yylow = yylow1; |
+ } |
+ return yylow1; |
+} |
+ |
+/** Perform user action for rule number YYN, with RHS length YYRHSLEN, |
+ * and top stack item YYVSP. YYLVALP points to place to put semantic |
+ * value ($$), and yylocp points to place for location information |
+ * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT, |
+ * yyerr for YYERROR, yyabort for YYABORT. */ |
+/*ARGSUSED*/ static YYRESULTTAG |
+yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, |
+ YYSTYPE* yyvalp, |
+ YYLTYPE* YYOPTIONAL_LOC (yylocp), |
+ yyGLRStack* yystackp |
+ ]b4_user_formals[) |
+{ |
+ yybool yynormal __attribute__ ((__unused__)) = |
+ (yystackp->yysplitPoint == NULL); |
+ int yylow; |
+]b4_parse_param_use[]dnl |
+[# undef yyerrok |
+# define yyerrok (yystackp->yyerrState = 0) |
+# undef YYACCEPT |
+# define YYACCEPT return yyaccept |
+# undef YYABORT |
+# define YYABORT return yyabort |
+# undef YYERROR |
+# define YYERROR return yyerrok, yyerr |
+# undef YYRECOVERING |
+# define YYRECOVERING() (yystackp->yyerrState != 0) |
+# undef yyclearin |
+# define yyclearin (yychar = YYEMPTY) |
+# undef YYFILL |
+# define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal) |
+# undef YYBACKUP |
+# define YYBACKUP(Token, Value) \ |
+ return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \ |
+ yyerrok, yyerr |
+ |
+ yylow = 1; |
+ if (yyrhslen == 0) |
+ *yyvalp = yyval_default; |
+ else |
+ *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval; |
+ YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); |
+]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp; |
+]])[ |
+ switch (yyn) |
+ { |
+ ]b4_user_actions[ |
+ default: break; |
+ } |
+ |
+ return yyok; |
+# undef yyerrok |
+# undef YYABORT |
+# undef YYACCEPT |
+# undef YYERROR |
+# undef YYBACKUP |
+# undef yyclearin |
+# undef YYRECOVERING |
+} |
+ |
+ |
+/*ARGSUSED*/ static void |
+yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) |
+{ |
+ YYUSE (yy0); |
+ YYUSE (yy1); |
+ |
+ switch (yyn) |
+ { |
+ ]b4_mergers[ |
+ default: break; |
+ } |
+} |
+ |
+ /* Bison grammar-table manipulation. */ |
+ |
+]b4_yydestruct_generate([b4_c_ansi_function_def])[ |
+ |
+/** Number of symbols composing the right hand side of rule #RULE. */ |
+static inline int |
+yyrhsLength (yyRuleNum yyrule) |
+{ |
+ return yyr2[yyrule]; |
+} |
+ |
+static void |
+yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) |
+{ |
+ if (yys->yyresolved) |
+ yydestruct (yymsg, yystos[yys->yylrState], |
+ &yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[); |
+ else |
+ { |
+#if YYDEBUG |
+ if (yydebug) |
+ { |
+ if (yys->yysemantics.yyfirstVal) |
+ YYFPRINTF (stderr, "%s unresolved ", yymsg); |
+ else |
+ YYFPRINTF (stderr, "%s incomplete ", yymsg); |
+ yy_symbol_print (stderr, yystos[yys->yylrState], |
+ NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[); |
+ YYFPRINTF (stderr, "\n"); |
+ } |
+#endif |
+ |
+ if (yys->yysemantics.yyfirstVal) |
+ { |
+ yySemanticOption *yyoption = yys->yysemantics.yyfirstVal; |
+ yyGLRState *yyrh; |
+ int yyn; |
+ for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule); |
+ yyn > 0; |
+ yyrh = yyrh->yypred, yyn -= 1) |
+ yydestroyGLRState (yymsg, yyrh]b4_user_args[); |
+ } |
+ } |
+} |
+ |
+/** Left-hand-side symbol for rule #RULE. */ |
+static inline yySymbol |
+yylhsNonterm (yyRuleNum yyrule) |
+{ |
+ return yyr1[yyrule]; |
+} |
+ |
+#define yyis_pact_ninf(yystate) \ |
+ ]m4_if(m4_eval(b4_pact_ninf < b4_pact_min), [1], |
+ [0], |
+ [((yystate) == YYPACT_NINF)])[ |
+ |
+/** True iff LR state STATE has only a default reduction (regardless |
+ * of token). */ |
+static inline yybool |
+yyisDefaultedState (yyStateNum yystate) |
+{ |
+ return yyis_pact_ninf (yypact[yystate]); |
+} |
+ |
+/** The default reduction for STATE, assuming it has one. */ |
+static inline yyRuleNum |
+yydefaultAction (yyStateNum yystate) |
+{ |
+ return yydefact[yystate]; |
+} |
+ |
+#define yyis_table_ninf(yytable_value) \ |
+ ]m4_if(m4_eval(b4_table_ninf < b4_table_min), [1], |
+ [YYID (0)], |
+ [((yytable_value) == YYTABLE_NINF)])[ |
+ |
+/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. |
+ * Result R means |
+ * R < 0: Reduce on rule -R. |
+ * R = 0: Error. |
+ * R > 0: Shift to state R. |
+ * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of |
+ * conflicting reductions. |
+ */ |
+static inline void |
+yygetLRActions (yyStateNum yystate, int yytoken, |
+ int* yyaction, const short int** yyconflicts) |
+{ |
+ int yyindex = yypact[yystate] + yytoken; |
+ if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) |
+ { |
+ *yyaction = -yydefact[yystate]; |
+ *yyconflicts = yyconfl; |
+ } |
+ else if (! yyis_table_ninf (yytable[yyindex])) |
+ { |
+ *yyaction = yytable[yyindex]; |
+ *yyconflicts = yyconfl + yyconflp[yyindex]; |
+ } |
+ else |
+ { |
+ *yyaction = 0; |
+ *yyconflicts = yyconfl + yyconflp[yyindex]; |
+ } |
+} |
+ |
+static inline yyStateNum |
+yyLRgotoState (yyStateNum yystate, yySymbol yylhs) |
+{ |
+ int yyr; |
+ yyr = yypgoto[yylhs - YYNTOKENS] + yystate; |
+ if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) |
+ return yytable[yyr]; |
+ else |
+ return yydefgoto[yylhs - YYNTOKENS]; |
+} |
+ |
+static inline yybool |
+yyisShiftAction (int yyaction) |
+{ |
+ return 0 < yyaction; |
+} |
+ |
+static inline yybool |
+yyisErrorAction (int yyaction) |
+{ |
+ return yyaction == 0; |
+} |
+ |
+ /* GLRStates */ |
+ |
+/** Return a fresh GLRStackItem. Callers should call |
+ * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient |
+ * headroom. */ |
+ |
+static inline yyGLRStackItem* |
+yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) |
+{ |
+ yyGLRStackItem* yynewItem = yystackp->yynextFree; |
+ yystackp->yyspaceLeft -= 1; |
+ yystackp->yynextFree += 1; |
+ yynewItem->yystate.yyisState = yyisState; |
+ return yynewItem; |
+} |
+ |
+/** Add a new semantic action that will execute the action for rule |
+ * RULENUM on the semantic values in RHS to the list of |
+ * alternative actions for STATE. Assumes that RHS comes from |
+ * stack #K of *STACKP. */ |
+static void |
+yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate, |
+ yyGLRState* rhs, yyRuleNum yyrule) |
+{ |
+ yySemanticOption* yynewOption = |
+ &yynewGLRStackItem (yystackp, yyfalse)->yyoption; |
+ yynewOption->yystate = rhs; |
+ yynewOption->yyrule = yyrule; |
+ if (yystackp->yytops.yylookaheadNeeds[yyk]) |
+ { |
+ yynewOption->yyrawchar = yychar; |
+ yynewOption->yyval = yylval; |
+ yynewOption->yyloc = yylloc; |
+ } |
+ else |
+ yynewOption->yyrawchar = YYEMPTY; |
+ yynewOption->yynext = yystate->yysemantics.yyfirstVal; |
+ yystate->yysemantics.yyfirstVal = yynewOption; |
+ |
+ YY_RESERVE_GLRSTACK (yystackp); |
+} |
+ |
+ /* GLRStacks */ |
+ |
+/** Initialize SET to a singleton set containing an empty stack. */ |
+static yybool |
+yyinitStateSet (yyGLRStateSet* yyset) |
+{ |
+ yyset->yysize = 1; |
+ yyset->yycapacity = 16; |
+ yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]); |
+ if (! yyset->yystates) |
+ return yyfalse; |
+ yyset->yystates[0] = NULL; |
+ yyset->yylookaheadNeeds = |
+ (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]); |
+ if (! yyset->yylookaheadNeeds) |
+ { |
+ YYFREE (yyset->yystates); |
+ return yyfalse; |
+ } |
+ return yytrue; |
+} |
+ |
+static void yyfreeStateSet (yyGLRStateSet* yyset) |
+{ |
+ YYFREE (yyset->yystates); |
+ YYFREE (yyset->yylookaheadNeeds); |
+} |
+ |
+/** Initialize STACK to a single empty stack, with total maximum |
+ * capacity for all stacks of SIZE. */ |
+static yybool |
+yyinitGLRStack (yyGLRStack* yystackp, size_t yysize) |
+{ |
+ yystackp->yyerrState = 0; |
+ yynerrs = 0; |
+ yystackp->yyspaceLeft = yysize; |
+ yystackp->yyitems = |
+ (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]); |
+ if (!yystackp->yyitems) |
+ return yyfalse; |
+ yystackp->yynextFree = yystackp->yyitems; |
+ yystackp->yysplitPoint = NULL; |
+ yystackp->yylastDeleted = NULL; |
+ return yyinitStateSet (&yystackp->yytops); |
+} |
+ |
+ |
+#if YYSTACKEXPANDABLE |
+# define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ |
+ &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE |
+ |
+/** If STACK is expandable, extend it. WARNING: Pointers into the |
+ stack from outside should be considered invalid after this call. |
+ We always expand when there are 1 or fewer items left AFTER an |
+ allocation, so that we can avoid having external pointers exist |
+ across an allocation. */ |
+static void |
+yyexpandGLRStack (yyGLRStack* yystackp) |
+{ |
+ yyGLRStackItem* yynewItems; |
+ yyGLRStackItem* yyp0, *yyp1; |
+ size_t yysize, yynewSize; |
+ size_t yyn; |
+ yysize = yystackp->yynextFree - yystackp->yyitems; |
+ if (YYMAXDEPTH - YYHEADROOM < yysize) |
+ yyMemoryExhausted (yystackp); |
+ yynewSize = 2*yysize; |
+ if (YYMAXDEPTH < yynewSize) |
+ yynewSize = YYMAXDEPTH; |
+ yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]); |
+ if (! yynewItems) |
+ yyMemoryExhausted (yystackp); |
+ for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize; |
+ 0 < yyn; |
+ yyn -= 1, yyp0 += 1, yyp1 += 1) |
+ { |
+ *yyp1 = *yyp0; |
+ if (*(yybool *) yyp0) |
+ { |
+ yyGLRState* yys0 = &yyp0->yystate; |
+ yyGLRState* yys1 = &yyp1->yystate; |
+ if (yys0->yypred != NULL) |
+ yys1->yypred = |
+ YYRELOC (yyp0, yyp1, yys0->yypred, yystate); |
+ if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL) |
+ yys1->yysemantics.yyfirstVal = |
+ YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); |
+ } |
+ else |
+ { |
+ yySemanticOption* yyv0 = &yyp0->yyoption; |
+ yySemanticOption* yyv1 = &yyp1->yyoption; |
+ if (yyv0->yystate != NULL) |
+ yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); |
+ if (yyv0->yynext != NULL) |
+ yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); |
+ } |
+ } |
+ if (yystackp->yysplitPoint != NULL) |
+ yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, |
+ yystackp->yysplitPoint, yystate); |
+ |
+ for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) |
+ if (yystackp->yytops.yystates[yyn] != NULL) |
+ yystackp->yytops.yystates[yyn] = |
+ YYRELOC (yystackp->yyitems, yynewItems, |
+ yystackp->yytops.yystates[yyn], yystate); |
+ YYFREE (yystackp->yyitems); |
+ yystackp->yyitems = yynewItems; |
+ yystackp->yynextFree = yynewItems + yysize; |
+ yystackp->yyspaceLeft = yynewSize - yysize; |
+} |
+#endif |
+ |
+static void |
+yyfreeGLRStack (yyGLRStack* yystackp) |
+{ |
+ YYFREE (yystackp->yyitems); |
+ yyfreeStateSet (&yystackp->yytops); |
+} |
+ |
+/** Assuming that S is a GLRState somewhere on STACK, update the |
+ * splitpoint of STACK, if needed, so that it is at least as deep as |
+ * S. */ |
+static inline void |
+yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) |
+{ |
+ if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys) |
+ yystackp->yysplitPoint = yys; |
+} |
+ |
+/** Invalidate stack #K in STACK. */ |
+static inline void |
+yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) |
+{ |
+ if (yystackp->yytops.yystates[yyk] != NULL) |
+ yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; |
+ yystackp->yytops.yystates[yyk] = NULL; |
+} |
+ |
+/** Undelete the last stack that was marked as deleted. Can only be |
+ done once after a deletion, and only when all other stacks have |
+ been deleted. */ |
+static void |
+yyundeleteLastStack (yyGLRStack* yystackp) |
+{ |
+ if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0) |
+ return; |
+ yystackp->yytops.yystates[0] = yystackp->yylastDeleted; |
+ yystackp->yytops.yysize = 1; |
+ YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); |
+ yystackp->yylastDeleted = NULL; |
+} |
+ |
+static inline void |
+yyremoveDeletes (yyGLRStack* yystackp) |
+{ |
+ size_t yyi, yyj; |
+ yyi = yyj = 0; |
+ while (yyj < yystackp->yytops.yysize) |
+ { |
+ if (yystackp->yytops.yystates[yyi] == NULL) |
+ { |
+ if (yyi == yyj) |
+ { |
+ YYDPRINTF ((stderr, "Removing dead stacks.\n")); |
+ } |
+ yystackp->yytops.yysize -= 1; |
+ } |
+ else |
+ { |
+ yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; |
+ /* In the current implementation, it's unnecessary to copy |
+ yystackp->yytops.yylookaheadNeeds[yyi] since, after |
+ yyremoveDeletes returns, the parser immediately either enters |
+ deterministic operation or shifts a token. However, it doesn't |
+ hurt, and the code might evolve to need it. */ |
+ yystackp->yytops.yylookaheadNeeds[yyj] = |
+ yystackp->yytops.yylookaheadNeeds[yyi]; |
+ if (yyj != yyi) |
+ { |
+ YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", |
+ (unsigned long int) yyi, (unsigned long int) yyj)); |
+ } |
+ yyj += 1; |
+ } |
+ yyi += 1; |
+ } |
+} |
+ |
+/** Shift to a new state on stack #K of STACK, corresponding to LR state |
+ * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ |
+static inline void |
+yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, |
+ size_t yyposn, |
+ YYSTYPE* yyvalp, YYLTYPE* yylocp) |
+{ |
+ yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; |
+ |
+ yynewState->yylrState = yylrState; |
+ yynewState->yyposn = yyposn; |
+ yynewState->yyresolved = yytrue; |
+ yynewState->yypred = yystackp->yytops.yystates[yyk]; |
+ yynewState->yysemantics.yysval = *yyvalp; |
+ yynewState->yyloc = *yylocp; |
+ yystackp->yytops.yystates[yyk] = yynewState; |
+ |
+ YY_RESERVE_GLRSTACK (yystackp); |
+} |
+ |
+/** Shift stack #K of YYSTACK, to a new state corresponding to LR |
+ * state YYLRSTATE, at input position YYPOSN, with the (unresolved) |
+ * semantic value of YYRHS under the action for YYRULE. */ |
+static inline void |
+yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, |
+ size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule) |
+{ |
+ yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; |
+ |
+ yynewState->yylrState = yylrState; |
+ yynewState->yyposn = yyposn; |
+ yynewState->yyresolved = yyfalse; |
+ yynewState->yypred = yystackp->yytops.yystates[yyk]; |
+ yynewState->yysemantics.yyfirstVal = NULL; |
+ yystackp->yytops.yystates[yyk] = yynewState; |
+ |
+ /* Invokes YY_RESERVE_GLRSTACK. */ |
+ yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule); |
+} |
+ |
+/** Pop the symbols consumed by reduction #RULE from the top of stack |
+ * #K of STACK, and perform the appropriate semantic action on their |
+ * semantic values. Assumes that all ambiguities in semantic values |
+ * have been previously resolved. Set *VALP to the resulting value, |
+ * and *LOCP to the computed location (if any). Return value is as |
+ * for userAction. */ |
+static inline YYRESULTTAG |
+yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, |
+ YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
+{ |
+ int yynrhs = yyrhsLength (yyrule); |
+ |
+ if (yystackp->yysplitPoint == NULL) |
+ { |
+ /* Standard special case: single stack. */ |
+ yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; |
+ YYASSERT (yyk == 0); |
+ yystackp->yynextFree -= yynrhs; |
+ yystackp->yyspaceLeft += yynrhs; |
+ yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; |
+ return yyuserAction (yyrule, yynrhs, rhs, |
+ yyvalp, yylocp, yystackp]b4_user_args[); |
+ } |
+ else |
+ { |
+ /* At present, doAction is never called in nondeterministic |
+ * mode, so this branch is never taken. It is here in |
+ * anticipation of a future feature that will allow immediate |
+ * evaluation of selected actions in nondeterministic mode. */ |
+ int yyi; |
+ yyGLRState* yys; |
+ yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; |
+ yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred |
+ = yystackp->yytops.yystates[yyk];]b4_locations_if([[ |
+ if (yynrhs == 0) |
+ /* Set default location. */ |
+ yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ |
+ for (yyi = 0; yyi < yynrhs; yyi += 1) |
+ { |
+ yys = yys->yypred; |
+ YYASSERT (yys); |
+ } |
+ yyupdateSplit (yystackp, yys); |
+ yystackp->yytops.yystates[yyk] = yys; |
+ return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, |
+ yyvalp, yylocp, yystackp]b4_user_args[); |
+ } |
+} |
+ |
+#if !YYDEBUG |
+# define YY_REDUCE_PRINT(Args) |
+#else |
+# define YY_REDUCE_PRINT(Args) \ |
+do { \ |
+ if (yydebug) \ |
+ yy_reduce_print Args; \ |
+} while (YYID (0)) |
+ |
+/*----------------------------------------------------------. |
+| Report that the RULE is going to be reduced on stack #K. | |
+`----------------------------------------------------------*/ |
+ |
+/*ARGSUSED*/ static inline void |
+yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, |
+ YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
+{ |
+ int yynrhs = yyrhsLength (yyrule); |
+ yybool yynormal __attribute__ ((__unused__)) = |
+ (yystackp->yysplitPoint == NULL); |
+ yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; |
+ int yylow = 1; |
+ int yyi; |
+ YYUSE (yyvalp); |
+ YYUSE (yylocp); |
+]b4_parse_param_use[]dnl |
+[ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", |
+ (unsigned long int) yyk, yyrule - 1, |
+ (unsigned long int) yyrline[yyrule]); |
+ /* The symbols being reduced. */ |
+ for (yyi = 0; yyi < yynrhs; yyi++) |
+ { |
+ YYFPRINTF (stderr, " $%d = ", yyi + 1); |
+ yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
+ &]b4_rhs_value(yynrhs, yyi + 1)[ |
+ ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl |
+ b4_user_args[); |
+ YYFPRINTF (stderr, "\n"); |
+ } |
+} |
+#endif |
+ |
+/** Pop items off stack #K of STACK according to grammar rule RULE, |
+ * and push back on the resulting nonterminal symbol. Perform the |
+ * semantic action associated with RULE and store its value with the |
+ * newly pushed state, if FORCEEVAL or if STACK is currently |
+ * unambiguous. Otherwise, store the deferred semantic action with |
+ * the new state. If the new state would have an identical input |
+ * position, LR state, and predecessor to an existing state on the stack, |
+ * it is identified with that existing state, eliminating stack #K from |
+ * the STACK. In this case, the (necessarily deferred) semantic value is |
+ * added to the options for the existing state's semantic value. |
+ */ |
+static inline YYRESULTTAG |
+yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, |
+ yybool yyforceEval]b4_user_formals[) |
+{ |
+ size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn; |
+ |
+ if (yyforceEval || yystackp->yysplitPoint == NULL) |
+ { |
+ YYSTYPE yysval; |
+ YYLTYPE yyloc; |
+ |
+ YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval, &yyloc]b4_user_args[)); |
+ YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval, |
+ &yyloc]b4_user_args[)); |
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); |
+ yyglrShift (yystackp, yyk, |
+ yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, |
+ yylhsNonterm (yyrule)), |
+ yyposn, &yysval, &yyloc); |
+ } |
+ else |
+ { |
+ size_t yyi; |
+ int yyn; |
+ yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk]; |
+ yyStateNum yynewLRState; |
+ |
+ for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); |
+ 0 < yyn; yyn -= 1) |
+ { |
+ yys = yys->yypred; |
+ YYASSERT (yys); |
+ } |
+ yyupdateSplit (yystackp, yys); |
+ yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); |
+ YYDPRINTF ((stderr, |
+ "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n", |
+ (unsigned long int) yyk, yyrule - 1, yynewLRState)); |
+ for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) |
+ if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL) |
+ { |
+ yyGLRState* yyp, *yysplit = yystackp->yysplitPoint; |
+ yyp = yystackp->yytops.yystates[yyi]; |
+ while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) |
+ { |
+ if (yyp->yylrState == yynewLRState && yyp->yypred == yys) |
+ { |
+ yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); |
+ yymarkStackDeleted (yystackp, yyk); |
+ YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", |
+ (unsigned long int) yyk, |
+ (unsigned long int) yyi)); |
+ return yyok; |
+ } |
+ yyp = yyp->yypred; |
+ } |
+ } |
+ yystackp->yytops.yystates[yyk] = yys; |
+ yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule); |
+ } |
+ return yyok; |
+} |
+ |
+static size_t |
+yysplitStack (yyGLRStack* yystackp, size_t yyk) |
+{ |
+ if (yystackp->yysplitPoint == NULL) |
+ { |
+ YYASSERT (yyk == 0); |
+ yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; |
+ } |
+ if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity) |
+ { |
+ yyGLRState** yynewStates; |
+ yybool* yynewLookaheadNeeds; |
+ |
+ yynewStates = NULL; |
+ |
+ if (yystackp->yytops.yycapacity |
+ > (YYSIZEMAX / (2 * sizeof yynewStates[0]))) |
+ yyMemoryExhausted (yystackp); |
+ yystackp->yytops.yycapacity *= 2; |
+ |
+ yynewStates = |
+ (yyGLRState**) YYREALLOC (yystackp->yytops.yystates, |
+ (yystackp->yytops.yycapacity |
+ * sizeof yynewStates[0])); |
+ if (yynewStates == NULL) |
+ yyMemoryExhausted (yystackp); |
+ yystackp->yytops.yystates = yynewStates; |
+ |
+ yynewLookaheadNeeds = |
+ (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, |
+ (yystackp->yytops.yycapacity |
+ * sizeof yynewLookaheadNeeds[0])); |
+ if (yynewLookaheadNeeds == NULL) |
+ yyMemoryExhausted (yystackp); |
+ yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; |
+ } |
+ yystackp->yytops.yystates[yystackp->yytops.yysize] |
+ = yystackp->yytops.yystates[yyk]; |
+ yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize] |
+ = yystackp->yytops.yylookaheadNeeds[yyk]; |
+ yystackp->yytops.yysize += 1; |
+ return yystackp->yytops.yysize-1; |
+} |
+ |
+/** True iff Y0 and Y1 represent identical options at the top level. |
+ * That is, they represent the same rule applied to RHS symbols |
+ * that produce the same terminal symbols. */ |
+static yybool |
+yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) |
+{ |
+ if (yyy0->yyrule == yyy1->yyrule) |
+ { |
+ yyGLRState *yys0, *yys1; |
+ int yyn; |
+ for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, |
+ yyn = yyrhsLength (yyy0->yyrule); |
+ yyn > 0; |
+ yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) |
+ if (yys0->yyposn != yys1->yyposn) |
+ return yyfalse; |
+ return yytrue; |
+ } |
+ else |
+ return yyfalse; |
+} |
+ |
+/** Assuming identicalOptions (Y0,Y1), destructively merge the |
+ * alternative semantic values for the RHS-symbols of Y1 and Y0. */ |
+static void |
+yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) |
+{ |
+ yyGLRState *yys0, *yys1; |
+ int yyn; |
+ for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, |
+ yyn = yyrhsLength (yyy0->yyrule); |
+ yyn > 0; |
+ yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) |
+ { |
+ if (yys0 == yys1) |
+ break; |
+ else if (yys0->yyresolved) |
+ { |
+ yys1->yyresolved = yytrue; |
+ yys1->yysemantics.yysval = yys0->yysemantics.yysval; |
+ } |
+ else if (yys1->yyresolved) |
+ { |
+ yys0->yyresolved = yytrue; |
+ yys0->yysemantics.yysval = yys1->yysemantics.yysval; |
+ } |
+ else |
+ { |
+ yySemanticOption** yyz0p; |
+ yySemanticOption* yyz1; |
+ yyz0p = &yys0->yysemantics.yyfirstVal; |
+ yyz1 = yys1->yysemantics.yyfirstVal; |
+ while (YYID (yytrue)) |
+ { |
+ if (yyz1 == *yyz0p || yyz1 == NULL) |
+ break; |
+ else if (*yyz0p == NULL) |
+ { |
+ *yyz0p = yyz1; |
+ break; |
+ } |
+ else if (*yyz0p < yyz1) |
+ { |
+ yySemanticOption* yyz = *yyz0p; |
+ *yyz0p = yyz1; |
+ yyz1 = yyz1->yynext; |
+ (*yyz0p)->yynext = yyz; |
+ } |
+ yyz0p = &(*yyz0p)->yynext; |
+ } |
+ yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; |
+ } |
+ } |
+} |
+ |
+/** Y0 and Y1 represent two possible actions to take in a given |
+ * parsing state; return 0 if no combination is possible, |
+ * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ |
+static int |
+yypreference (yySemanticOption* y0, yySemanticOption* y1) |
+{ |
+ yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; |
+ int p0 = yydprec[r0], p1 = yydprec[r1]; |
+ |
+ if (p0 == p1) |
+ { |
+ if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) |
+ return 0; |
+ else |
+ return 1; |
+ } |
+ if (p0 == 0 || p1 == 0) |
+ return 0; |
+ if (p0 < p1) |
+ return 3; |
+ if (p1 < p0) |
+ return 2; |
+ return 0; |
+} |
+ |
+static YYRESULTTAG yyresolveValue (yyGLRState* yys, |
+ yyGLRStack* yystackp]b4_user_formals[); |
+ |
+ |
+/** Resolve the previous N states starting at and including state S. If result |
+ * != yyok, some states may have been left unresolved possibly with empty |
+ * semantic option chains. Regardless of whether result = yyok, each state |
+ * has been left with consistent data so that yydestroyGLRState can be invoked |
+ * if necessary. */ |
+static YYRESULTTAG |
+yyresolveStates (yyGLRState* yys, int yyn, |
+ yyGLRStack* yystackp]b4_user_formals[) |
+{ |
+ if (0 < yyn) |
+ { |
+ YYASSERT (yys->yypred); |
+ YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[)); |
+ if (! yys->yyresolved) |
+ YYCHK (yyresolveValue (yys, yystackp]b4_user_args[)); |
+ } |
+ return yyok; |
+} |
+ |
+/** Resolve the states for the RHS of OPT, perform its user action, and return |
+ * the semantic value and location. Regardless of whether result = yyok, all |
+ * RHS states have been destroyed (assuming the user action destroys all RHS |
+ * semantic values if invoked). */ |
+static YYRESULTTAG |
+yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, |
+ YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
+{ |
+ yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; |
+ int yynrhs; |
+ int yychar_current; |
+ YYSTYPE yylval_current; |
+ YYLTYPE yylloc_current; |
+ YYRESULTTAG yyflag; |
+ |
+ yynrhs = yyrhsLength (yyopt->yyrule); |
+ yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[); |
+ if (yyflag != yyok) |
+ { |
+ yyGLRState *yys; |
+ for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1) |
+ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); |
+ return yyflag; |
+ } |
+ |
+ yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[ |
+ if (yynrhs == 0) |
+ /* Set default location. */ |
+ yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ |
+ yychar_current = yychar; |
+ yylval_current = yylval; |
+ yylloc_current = yylloc; |
+ yychar = yyopt->yyrawchar; |
+ yylval = yyopt->yyval; |
+ yylloc = yyopt->yyloc; |
+ yyflag = yyuserAction (yyopt->yyrule, yynrhs, |
+ yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, |
+ yyvalp, yylocp, yystackp]b4_user_args[); |
+ yychar = yychar_current; |
+ yylval = yylval_current; |
+ yylloc = yylloc_current; |
+ return yyflag; |
+} |
+ |
+#if YYDEBUG |
+static void |
+yyreportTree (yySemanticOption* yyx, int yyindent) |
+{ |
+ int yynrhs = yyrhsLength (yyx->yyrule); |
+ int yyi; |
+ yyGLRState* yys; |
+ yyGLRState* yystates[1 + YYMAXRHS]; |
+ yyGLRState yyleftmost_state; |
+ |
+ for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) |
+ yystates[yyi] = yys; |
+ if (yys == NULL) |
+ { |
+ yyleftmost_state.yyposn = 0; |
+ yystates[0] = &yyleftmost_state; |
+ } |
+ else |
+ yystates[0] = yys; |
+ |
+ if (yyx->yystate->yyposn < yys->yyposn + 1) |
+ YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n", |
+ yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), |
+ yyx->yyrule - 1); |
+ else |
+ YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n", |
+ yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), |
+ yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1), |
+ (unsigned long int) yyx->yystate->yyposn); |
+ for (yyi = 1; yyi <= yynrhs; yyi += 1) |
+ { |
+ if (yystates[yyi]->yyresolved) |
+ { |
+ if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) |
+ YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "", |
+ yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1])); |
+ else |
+ YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "", |
+ yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]), |
+ (unsigned long int) (yystates[yyi - 1]->yyposn + 1), |
+ (unsigned long int) yystates[yyi]->yyposn); |
+ } |
+ else |
+ yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); |
+ } |
+} |
+#endif |
+ |
+/*ARGSUSED*/ static YYRESULTTAG |
+yyreportAmbiguity (yySemanticOption* yyx0, |
+ yySemanticOption* yyx1]b4_pure_formals[) |
+{ |
+ YYUSE (yyx0); |
+ YYUSE (yyx1); |
+ |
+#if YYDEBUG |
+ YYFPRINTF (stderr, "Ambiguity detected.\n"); |
+ YYFPRINTF (stderr, "Option 1,\n"); |
+ yyreportTree (yyx0, 2); |
+ YYFPRINTF (stderr, "\nOption 2,\n"); |
+ yyreportTree (yyx1, 2); |
+ YYFPRINTF (stderr, "\n"); |
+#endif |
+ |
+ yyerror (]b4_yyerror_args[YY_("syntax is ambiguous")); |
+ return yyabort; |
+} |
+ |
+/** Starting at and including state S1, resolve the location for each of the |
+ * previous N1 states that is unresolved. The first semantic option of a state |
+ * is always chosen. */ |
+static void |
+yyresolveLocations (yyGLRState* yys1, int yyn1, |
+ yyGLRStack *yystackp]b4_user_formals[) |
+{ |
+ if (0 < yyn1) |
+ { |
+ yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); |
+ if (!yys1->yyresolved) |
+ { |
+ yySemanticOption *yyoption; |
+ yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; |
+ int yynrhs; |
+ int yychar_current; |
+ YYSTYPE yylval_current; |
+ YYLTYPE yylloc_current; |
+ yyoption = yys1->yysemantics.yyfirstVal; |
+ YYASSERT (yyoption != NULL); |
+ yynrhs = yyrhsLength (yyoption->yyrule); |
+ if (yynrhs > 0) |
+ { |
+ yyGLRState *yys; |
+ int yyn; |
+ yyresolveLocations (yyoption->yystate, yynrhs, |
+ yystackp]b4_user_args[); |
+ for (yys = yyoption->yystate, yyn = yynrhs; |
+ yyn > 0; |
+ yys = yys->yypred, yyn -= 1) |
+ yyrhsloc[yyn].yystate.yyloc = yys->yyloc; |
+ } |
+ else |
+ { |
+ /* Both yyresolveAction and yyresolveLocations traverse the GSS |
+ in reverse rightmost order. It is only necessary to invoke |
+ yyresolveLocations on a subforest for which yyresolveAction |
+ would have been invoked next had an ambiguity not been |
+ detected. Thus the location of the previous state (but not |
+ necessarily the previous state itself) is guaranteed to be |
+ resolved already. */ |
+ yyGLRState *yyprevious = yyoption->yystate; |
+ yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; |
+ } |
+ yychar_current = yychar; |
+ yylval_current = yylval; |
+ yylloc_current = yylloc; |
+ yychar = yyoption->yyrawchar; |
+ yylval = yyoption->yyval; |
+ yylloc = yyoption->yyloc; |
+ YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); |
+ yychar = yychar_current; |
+ yylval = yylval_current; |
+ yylloc = yylloc_current; |
+ } |
+ } |
+} |
+ |
+/** Resolve the ambiguity represented in state S, perform the indicated |
+ * actions, and set the semantic value of S. If result != yyok, the chain of |
+ * semantic options in S has been cleared instead or it has been left |
+ * unmodified except that redundant options may have been removed. Regardless |
+ * of whether result = yyok, S has been left with consistent data so that |
+ * yydestroyGLRState can be invoked if necessary. */ |
+static YYRESULTTAG |
+yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) |
+{ |
+ yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; |
+ yySemanticOption* yybest; |
+ yySemanticOption** yypp; |
+ yybool yymerge; |
+ YYSTYPE yysval; |
+ YYRESULTTAG yyflag; |
+ YYLTYPE *yylocp = &yys->yyloc; |
+ |
+ yybest = yyoptionList; |
+ yymerge = yyfalse; |
+ for (yypp = &yyoptionList->yynext; *yypp != NULL; ) |
+ { |
+ yySemanticOption* yyp = *yypp; |
+ |
+ if (yyidenticalOptions (yybest, yyp)) |
+ { |
+ yymergeOptionSets (yybest, yyp); |
+ *yypp = yyp->yynext; |
+ } |
+ else |
+ { |
+ switch (yypreference (yybest, yyp)) |
+ { |
+ case 0: |
+ yyresolveLocations (yys, 1, yystackp]b4_user_args[); |
+ return yyreportAmbiguity (yybest, yyp]b4_pure_args[); |
+ break; |
+ case 1: |
+ yymerge = yytrue; |
+ break; |
+ case 2: |
+ break; |
+ case 3: |
+ yybest = yyp; |
+ yymerge = yyfalse; |
+ break; |
+ default: |
+ /* This cannot happen so it is not worth a YYASSERT (yyfalse), |
+ but some compilers complain if the default case is |
+ omitted. */ |
+ break; |
+ } |
+ yypp = &yyp->yynext; |
+ } |
+ } |
+ |
+ if (yymerge) |
+ { |
+ yySemanticOption* yyp; |
+ int yyprec = yydprec[yybest->yyrule]; |
+ yyflag = yyresolveAction (yybest, yystackp, &yysval, |
+ yylocp]b4_user_args[); |
+ if (yyflag == yyok) |
+ for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) |
+ { |
+ if (yyprec == yydprec[yyp->yyrule]) |
+ { |
+ YYSTYPE yysval_other; |
+ YYLTYPE yydummy; |
+ yyflag = yyresolveAction (yyp, yystackp, &yysval_other, |
+ &yydummy]b4_user_args[); |
+ if (yyflag != yyok) |
+ { |
+ yydestruct ("Cleanup: discarding incompletely merged value for", |
+ yystos[yys->yylrState], |
+ &yysval]b4_locations_if([, yylocp])[]b4_user_args[); |
+ break; |
+ } |
+ yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); |
+ } |
+ } |
+ } |
+ else |
+ yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[); |
+ |
+ if (yyflag == yyok) |
+ { |
+ yys->yyresolved = yytrue; |
+ yys->yysemantics.yysval = yysval; |
+ } |
+ else |
+ yys->yysemantics.yyfirstVal = NULL; |
+ return yyflag; |
+} |
+ |
+static YYRESULTTAG |
+yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) |
+{ |
+ if (yystackp->yysplitPoint != NULL) |
+ { |
+ yyGLRState* yys; |
+ int yyn; |
+ |
+ for (yyn = 0, yys = yystackp->yytops.yystates[0]; |
+ yys != yystackp->yysplitPoint; |
+ yys = yys->yypred, yyn += 1) |
+ continue; |
+ YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp |
+ ]b4_user_args[)); |
+ } |
+ return yyok; |
+} |
+ |
+static void |
+yycompressStack (yyGLRStack* yystackp) |
+{ |
+ yyGLRState* yyp, *yyq, *yyr; |
+ |
+ if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL) |
+ return; |
+ |
+ for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL; |
+ yyp != yystackp->yysplitPoint; |
+ yyr = yyp, yyp = yyq, yyq = yyp->yypred) |
+ yyp->yypred = yyr; |
+ |
+ yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; |
+ yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1; |
+ yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; |
+ yystackp->yysplitPoint = NULL; |
+ yystackp->yylastDeleted = NULL; |
+ |
+ while (yyr != NULL) |
+ { |
+ yystackp->yynextFree->yystate = *yyr; |
+ yyr = yyr->yypred; |
+ yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate; |
+ yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate; |
+ yystackp->yynextFree += 1; |
+ yystackp->yyspaceLeft -= 1; |
+ } |
+} |
+ |
+static YYRESULTTAG |
+yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, |
+ size_t yyposn]b4_pure_formals[) |
+{ |
+ int yyaction; |
+ const short int* yyconflicts; |
+ yyRuleNum yyrule; |
+ |
+ while (yystackp->yytops.yystates[yyk] != NULL) |
+ { |
+ yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; |
+ YYDPRINTF ((stderr, "Stack %lu Entering state %d\n", |
+ (unsigned long int) yyk, yystate)); |
+ |
+ YYASSERT (yystate != YYFINAL); |
+ |
+ if (yyisDefaultedState (yystate)) |
+ { |
+ yyrule = yydefaultAction (yystate); |
+ if (yyrule == 0) |
+ { |
+ YYDPRINTF ((stderr, "Stack %lu dies.\n", |
+ (unsigned long int) yyk)); |
+ yymarkStackDeleted (yystackp, yyk); |
+ return yyok; |
+ } |
+ YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[)); |
+ } |
+ else |
+ { |
+ yySymbol yytoken; |
+ yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; |
+ if (yychar == YYEMPTY) |
+ { |
+ YYDPRINTF ((stderr, "Reading a token: ")); |
+ yychar = YYLEX; |
+ } |
+ |
+ if (yychar <= YYEOF) |
+ { |
+ yychar = yytoken = YYEOF; |
+ YYDPRINTF ((stderr, "Now at end of input.\n")); |
+ } |
+ else |
+ { |
+ yytoken = YYTRANSLATE (yychar); |
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
+ } |
+ |
+ yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); |
+ |
+ while (*yyconflicts != 0) |
+ { |
+ size_t yynewStack = yysplitStack (yystackp, yyk); |
+ YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n", |
+ (unsigned long int) yynewStack, |
+ (unsigned long int) yyk)); |
+ YYCHK (yyglrReduce (yystackp, yynewStack, |
+ *yyconflicts, yyfalse]b4_user_args[)); |
+ YYCHK (yyprocessOneStack (yystackp, yynewStack, |
+ yyposn]b4_pure_args[)); |
+ yyconflicts += 1; |
+ } |
+ |
+ if (yyisShiftAction (yyaction)) |
+ break; |
+ else if (yyisErrorAction (yyaction)) |
+ { |
+ YYDPRINTF ((stderr, "Stack %lu dies.\n", |
+ (unsigned long int) yyk)); |
+ yymarkStackDeleted (yystackp, yyk); |
+ break; |
+ } |
+ else |
+ YYCHK (yyglrReduce (yystackp, yyk, -yyaction, |
+ yyfalse]b4_user_args[)); |
+ } |
+ } |
+ return yyok; |
+} |
+ |
+/*ARGSUSED*/ static void |
+yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) |
+{ |
+ if (yystackp->yyerrState == 0) |
+ { |
+#if YYERROR_VERBOSE |
+ int yyn; |
+ yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; |
+ if (YYPACT_NINF < yyn && yyn <= YYLAST) |
+ { |
+ yySymbol yytoken = YYTRANSLATE (yychar); |
+ size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken)); |
+ size_t yysize = yysize0; |
+ size_t yysize1; |
+ yybool yysize_overflow = yyfalse; |
+ char* yymsg = NULL; |
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; |
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; |
+ int yyx; |
+ char *yyfmt; |
+ char const *yyf; |
+ static char const yyunexpected[] = "syntax error, unexpected %s"; |
+ static char const yyexpecting[] = ", expecting %s"; |
+ static char const yyor[] = " or %s"; |
+ char yyformat[sizeof yyunexpected |
+ + sizeof yyexpecting - 1 |
+ + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) |
+ * (sizeof yyor - 1))]; |
+ char const *yyprefix = yyexpecting; |
+ |
+ /* Start YYX at -YYN if negative to avoid negative indexes in |
+ YYCHECK. */ |
+ int yyxbegin = yyn < 0 ? -yyn : 0; |
+ |
+ /* Stay within bounds of both yycheck and yytname. */ |
+ int yychecklim = YYLAST - yyn + 1; |
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; |
+ int yycount = 1; |
+ |
+ yyarg[0] = yytokenName (yytoken); |
+ yyfmt = yystpcpy (yyformat, yyunexpected); |
+ |
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
+ { |
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) |
+ { |
+ yycount = 1; |
+ yysize = yysize0; |
+ yyformat[sizeof yyunexpected - 1] = '\0'; |
+ break; |
+ } |
+ yyarg[yycount++] = yytokenName (yyx); |
+ yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx)); |
+ yysize_overflow |= yysize1 < yysize; |
+ yysize = yysize1; |
+ yyfmt = yystpcpy (yyfmt, yyprefix); |
+ yyprefix = yyor; |
+ } |
+ |
+ yyf = YY_(yyformat); |
+ yysize1 = yysize + strlen (yyf); |
+ yysize_overflow |= yysize1 < yysize; |
+ yysize = yysize1; |
+ |
+ if (!yysize_overflow) |
+ yymsg = (char *) YYMALLOC (yysize); |
+ |
+ if (yymsg) |
+ { |
+ char *yyp = yymsg; |
+ int yyi = 0; |
+ while ((*yyp = *yyf)) |
+ { |
+ if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) |
+ { |
+ yyp += yytnamerr (yyp, yyarg[yyi++]); |
+ yyf += 2; |
+ } |
+ else |
+ { |
+ yyp++; |
+ yyf++; |
+ } |
+ } |
+ yyerror (]b4_lyyerror_args[yymsg); |
+ YYFREE (yymsg); |
+ } |
+ else |
+ { |
+ yyerror (]b4_lyyerror_args[YY_("syntax error")); |
+ yyMemoryExhausted (yystackp); |
+ } |
+ } |
+ else |
+#endif /* YYERROR_VERBOSE */ |
+ yyerror (]b4_lyyerror_args[YY_("syntax error")); |
+ yynerrs += 1; |
+ } |
+} |
+ |
+/* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP, |
+ yylval, and yylloc are the syntactic category, semantic value, and location |
+ of the lookahead. */ |
+/*ARGSUSED*/ static void |
+yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) |
+{ |
+ size_t yyk; |
+ int yyj; |
+ |
+ if (yystackp->yyerrState == 3) |
+ /* We just shifted the error token and (perhaps) took some |
+ reductions. Skip tokens until we can proceed. */ |
+ while (YYID (yytrue)) |
+ { |
+ yySymbol yytoken; |
+ if (yychar == YYEOF) |
+ yyFail (yystackp][]b4_lpure_args[, NULL); |
+ if (yychar != YYEMPTY) |
+ {]b4_locations_if([[ |
+ /* We throw away the lookahead, but the error range |
+ of the shifted error token must take it into account. */ |
+ yyGLRState *yys = yystackp->yytops.yystates[0]; |
+ yyGLRStackItem yyerror_range[3]; |
+ yyerror_range[1].yystate.yyloc = yys->yyloc; |
+ yyerror_range[2].yystate.yyloc = yylloc; |
+ YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ |
+ yytoken = YYTRANSLATE (yychar); |
+ yydestruct ("Error: discarding", |
+ yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); |
+ } |
+ YYDPRINTF ((stderr, "Reading a token: ")); |
+ yychar = YYLEX; |
+ if (yychar <= YYEOF) |
+ { |
+ yychar = yytoken = YYEOF; |
+ YYDPRINTF ((stderr, "Now at end of input.\n")); |
+ } |
+ else |
+ { |
+ yytoken = YYTRANSLATE (yychar); |
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
+ } |
+ yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; |
+ if (yyis_pact_ninf (yyj)) |
+ return; |
+ yyj += yytoken; |
+ if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) |
+ { |
+ if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) |
+ return; |
+ } |
+ else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj])) |
+ return; |
+ } |
+ |
+ /* Reduce to one stack. */ |
+ for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) |
+ if (yystackp->yytops.yystates[yyk] != NULL) |
+ break; |
+ if (yyk >= yystackp->yytops.yysize) |
+ yyFail (yystackp][]b4_lpure_args[, NULL); |
+ for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1) |
+ yymarkStackDeleted (yystackp, yyk); |
+ yyremoveDeletes (yystackp); |
+ yycompressStack (yystackp); |
+ |
+ /* Now pop stack until we find a state that shifts the error token. */ |
+ yystackp->yyerrState = 3; |
+ while (yystackp->yytops.yystates[0] != NULL) |
+ { |
+ yyGLRState *yys = yystackp->yytops.yystates[0]; |
+ yyj = yypact[yys->yylrState]; |
+ if (! yyis_pact_ninf (yyj)) |
+ { |
+ yyj += YYTERROR; |
+ if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR |
+ && yyisShiftAction (yytable[yyj])) |
+ { |
+ /* Shift the error token having adjusted its location. */ |
+ YYLTYPE yyerrloc;]b4_locations_if([[ |
+ yystackp->yyerror_range[2].yystate.yyloc = yylloc; |
+ YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ |
+ YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], |
+ &yylval, &yyerrloc); |
+ yyglrShift (yystackp, 0, yytable[yyj], |
+ yys->yyposn, &yylval, &yyerrloc); |
+ yys = yystackp->yytops.yystates[0]; |
+ break; |
+ } |
+ } |
+]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ |
+ if (yys->yypred != NULL) |
+ yydestroyGLRState ("Error: popping", yys]b4_user_args[); |
+ yystackp->yytops.yystates[0] = yys->yypred; |
+ yystackp->yynextFree -= 1; |
+ yystackp->yyspaceLeft += 1; |
+ } |
+ if (yystackp->yytops.yystates[0] == NULL) |
+ yyFail (yystackp][]b4_lpure_args[, NULL); |
+} |
+ |
+#define YYCHK1(YYE) \ |
+ do { \ |
+ switch (YYE) { \ |
+ case yyok: \ |
+ break; \ |
+ case yyabort: \ |
+ goto yyabortlab; \ |
+ case yyaccept: \ |
+ goto yyacceptlab; \ |
+ case yyerr: \ |
+ goto yyuser_error; \ |
+ default: \ |
+ goto yybuglab; \ |
+ } \ |
+ } while (YYID (0)) |
+ |
+ |
+/*----------. |
+| yyparse. | |
+`----------*/ |
+ |
+]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[ |
+{ |
+ int yyresult; |
+ yyGLRStack yystack; |
+ yyGLRStack* const yystackp = &yystack; |
+ size_t yyposn; |
+ |
+ YYDPRINTF ((stderr, "Starting parse\n")); |
+ |
+ yychar = YYEMPTY; |
+ yylval = yyval_default; |
+]b4_locations_if([ |
+#if YYLTYPE_IS_TRIVIAL |
+ yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[; |
+ yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[; |
+#endif |
+]) |
+m4_ifdef([b4_initial_action], [ |
+m4_pushdef([b4_at_dollar], [yylloc])dnl |
+m4_pushdef([b4_dollar_dollar], [yylval])dnl |
+ /* User initialization code. */ |
+ b4_user_initial_action |
+m4_popdef([b4_dollar_dollar])dnl |
+m4_popdef([b4_at_dollar])])dnl |
+[ |
+ if (! yyinitGLRStack (yystackp, YYINITDEPTH)) |
+ goto yyexhaustedlab; |
+ switch (YYSETJMP (yystack.yyexception_buffer)) |
+ { |
+ case 0: break; |
+ case 1: goto yyabortlab; |
+ case 2: goto yyexhaustedlab; |
+ default: goto yybuglab; |
+ } |
+ yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc); |
+ yyposn = 0; |
+ |
+ while (YYID (yytrue)) |
+ { |
+ /* For efficiency, we have two loops, the first of which is |
+ specialized to deterministic operation (single stack, no |
+ potential ambiguity). */ |
+ /* Standard mode */ |
+ while (YYID (yytrue)) |
+ { |
+ yyRuleNum yyrule; |
+ int yyaction; |
+ const short int* yyconflicts; |
+ |
+ yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; |
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
+ if (yystate == YYFINAL) |
+ goto yyacceptlab; |
+ if (yyisDefaultedState (yystate)) |
+ { |
+ yyrule = yydefaultAction (yystate); |
+ if (yyrule == 0) |
+ { |
+]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ |
+ yyreportSyntaxError (&yystack]b4_user_args[); |
+ goto yyuser_error; |
+ } |
+ YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); |
+ } |
+ else |
+ { |
+ yySymbol yytoken; |
+ if (yychar == YYEMPTY) |
+ { |
+ YYDPRINTF ((stderr, "Reading a token: ")); |
+ yychar = YYLEX; |
+ } |
+ |
+ if (yychar <= YYEOF) |
+ { |
+ yychar = yytoken = YYEOF; |
+ YYDPRINTF ((stderr, "Now at end of input.\n")); |
+ } |
+ else |
+ { |
+ yytoken = YYTRANSLATE (yychar); |
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
+ } |
+ |
+ yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); |
+ if (*yyconflicts != 0) |
+ break; |
+ if (yyisShiftAction (yyaction)) |
+ { |
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
+ yychar = YYEMPTY; |
+ yyposn += 1; |
+ yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc); |
+ if (0 < yystack.yyerrState) |
+ yystack.yyerrState -= 1; |
+ } |
+ else if (yyisErrorAction (yyaction)) |
+ { |
+]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ |
+ yyreportSyntaxError (&yystack]b4_user_args[); |
+ goto yyuser_error; |
+ } |
+ else |
+ YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); |
+ } |
+ } |
+ |
+ while (YYID (yytrue)) |
+ { |
+ yySymbol yytoken_to_shift; |
+ size_t yys; |
+ |
+ for (yys = 0; yys < yystack.yytops.yysize; yys += 1) |
+ yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; |
+ |
+ /* yyprocessOneStack returns one of three things: |
+ |
+ - An error flag. If the caller is yyprocessOneStack, it |
+ immediately returns as well. When the caller is finally |
+ yyparse, it jumps to an error label via YYCHK1. |
+ |
+ - yyok, but yyprocessOneStack has invoked yymarkStackDeleted |
+ (&yystack, yys), which sets the top state of yys to NULL. Thus, |
+ yyparse's following invocation of yyremoveDeletes will remove |
+ the stack. |
+ |
+ - yyok, when ready to shift a token. |
+ |
+ Except in the first case, yyparse will invoke yyremoveDeletes and |
+ then shift the next token onto all remaining stacks. This |
+ synchronization of the shift (that is, after all preceding |
+ reductions on all stacks) helps prevent double destructor calls |
+ on yylval in the event of memory exhaustion. */ |
+ |
+ for (yys = 0; yys < yystack.yytops.yysize; yys += 1) |
+ YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); |
+ yyremoveDeletes (&yystack); |
+ if (yystack.yytops.yysize == 0) |
+ { |
+ yyundeleteLastStack (&yystack); |
+ if (yystack.yytops.yysize == 0) |
+ yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); |
+ YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); |
+ YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); |
+]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ |
+ yyreportSyntaxError (&yystack]b4_user_args[); |
+ goto yyuser_error; |
+ } |
+ |
+ /* If any yyglrShift call fails, it will fail after shifting. Thus, |
+ a copy of yylval will already be on stack 0 in the event of a |
+ failure in the following loop. Thus, yychar is set to YYEMPTY |
+ before the loop to make sure the user destructor for yylval isn't |
+ called twice. */ |
+ yytoken_to_shift = YYTRANSLATE (yychar); |
+ yychar = YYEMPTY; |
+ yyposn += 1; |
+ for (yys = 0; yys < yystack.yytops.yysize; yys += 1) |
+ { |
+ int yyaction; |
+ const short int* yyconflicts; |
+ yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState; |
+ yygetLRActions (yystate, yytoken_to_shift, &yyaction, |
+ &yyconflicts); |
+ /* Note that yyconflicts were handled by yyprocessOneStack. */ |
+ YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys)); |
+ YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); |
+ yyglrShift (&yystack, yys, yyaction, yyposn, |
+ &yylval, &yylloc); |
+ YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", |
+ (unsigned long int) yys, |
+ yystack.yytops.yystates[yys]->yylrState)); |
+ } |
+ |
+ if (yystack.yytops.yysize == 1) |
+ { |
+ YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); |
+ YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); |
+ yycompressStack (&yystack); |
+ break; |
+ } |
+ } |
+ continue; |
+ yyuser_error: |
+ yyrecoverSyntaxError (&yystack]b4_user_args[); |
+ yyposn = yystack.yytops.yystates[0]->yyposn; |
+ } |
+ |
+ yyacceptlab: |
+ yyresult = 0; |
+ goto yyreturn; |
+ |
+ yybuglab: |
+ YYASSERT (yyfalse); |
+ goto yyabortlab; |
+ |
+ yyabortlab: |
+ yyresult = 1; |
+ goto yyreturn; |
+ |
+ yyexhaustedlab: |
+ yyerror (]b4_lyyerror_args[YY_("memory exhausted")); |
+ yyresult = 2; |
+ goto yyreturn; |
+ |
+ yyreturn: |
+ if (yychar != YYEMPTY) |
+ yydestruct ("Cleanup: discarding lookahead", |
+ YYTRANSLATE (yychar), |
+ &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); |
+ |
+ /* If the stack is well-formed, pop the stack until it is empty, |
+ destroying its entries as we go. But free the stack regardless |
+ of whether it is well-formed. */ |
+ if (yystack.yyitems) |
+ { |
+ yyGLRState** yystates = yystack.yytops.yystates; |
+ if (yystates) |
+ { |
+ size_t yysize = yystack.yytops.yysize; |
+ size_t yyk; |
+ for (yyk = 0; yyk < yysize; yyk += 1) |
+ if (yystates[yyk]) |
+ { |
+ while (yystates[yyk]) |
+ { |
+ yyGLRState *yys = yystates[yyk]; |
+]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] |
+)[ if (yys->yypred != NULL) |
+ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); |
+ yystates[yyk] = yys->yypred; |
+ yystack.yynextFree -= 1; |
+ yystack.yyspaceLeft += 1; |
+ } |
+ break; |
+ } |
+ } |
+ yyfreeGLRStack (&yystack); |
+ } |
+ |
+ /* Make sure YYID is used. */ |
+ return YYID (yyresult); |
+} |
+ |
+/* DEBUGGING ONLY */ |
+#if YYDEBUG |
+static void yypstack (yyGLRStack* yystackp, size_t yyk) |
+ __attribute__ ((__unused__)); |
+static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__)); |
+ |
+static void |
+yy_yypstack (yyGLRState* yys) |
+{ |
+ if (yys->yypred) |
+ { |
+ yy_yypstack (yys->yypred); |
+ YYFPRINTF (stderr, " -> "); |
+ } |
+ YYFPRINTF (stderr, "%d@@%lu", yys->yylrState, |
+ (unsigned long int) yys->yyposn); |
+} |
+ |
+static void |
+yypstates (yyGLRState* yyst) |
+{ |
+ if (yyst == NULL) |
+ YYFPRINTF (stderr, "<null>"); |
+ else |
+ yy_yypstack (yyst); |
+ YYFPRINTF (stderr, "\n"); |
+} |
+ |
+static void |
+yypstack (yyGLRStack* yystackp, size_t yyk) |
+{ |
+ yypstates (yystackp->yytops.yystates[yyk]); |
+} |
+ |
+#define YYINDEX(YYX) \ |
+ ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) |
+ |
+ |
+static void |
+yypdumpstack (yyGLRStack* yystackp) |
+{ |
+ yyGLRStackItem* yyp; |
+ size_t yyi; |
+ for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) |
+ { |
+ YYFPRINTF (stderr, "%3lu. ", |
+ (unsigned long int) (yyp - yystackp->yyitems)); |
+ if (*(yybool *) yyp) |
+ { |
+ YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", |
+ yyp->yystate.yyresolved, yyp->yystate.yylrState, |
+ (unsigned long int) yyp->yystate.yyposn, |
+ (long int) YYINDEX (yyp->yystate.yypred)); |
+ if (! yyp->yystate.yyresolved) |
+ YYFPRINTF (stderr, ", firstVal: %ld", |
+ (long int) YYINDEX (yyp->yystate |
+ .yysemantics.yyfirstVal)); |
+ } |
+ else |
+ { |
+ YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld", |
+ yyp->yyoption.yyrule - 1, |
+ (long int) YYINDEX (yyp->yyoption.yystate), |
+ (long int) YYINDEX (yyp->yyoption.yynext)); |
+ } |
+ YYFPRINTF (stderr, "\n"); |
+ } |
+ YYFPRINTF (stderr, "Tops:"); |
+ for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) |
+ YYFPRINTF (stderr, "%lu: %ld; ", (unsigned long int) yyi, |
+ (long int) YYINDEX (yystackp->yytops.yystates[yyi])); |
+ YYFPRINTF (stderr, "\n"); |
+} |
+#endif |
+] |
+ |
+b4_epilogue |
+dnl |
+dnl glr.cc produces its own header. |
+dnl |
+m4_if(b4_skeleton, ["glr.c"], |
+[b4_defines_if( |
+[@output(b4_spec_defines_file@) |
+b4_copyright([Skeleton interface for Bison GLR parsers in C], |
+ [2002, 2003, 2004, 2005, 2006]) |
+ |
+b4_shared_declarations |
+ |
+b4_pure_if([], |
+[[extern YYSTYPE ]b4_prefix[lval;]]) |
+ |
+b4_locations_if([b4_pure_if([], |
+[extern YYLTYPE ]b4_prefix[lloc;]) |
+]) |
+])]) |
+m4_divert_pop(0) |
Property changes on: bison\src\bison\2.4.1\bison-2.4.1-src\data\glr.c |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |