| 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
|
|
|
|
|
Chromium Code Reviews
Issue 10807020:
Add native Windows binary for bison. (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/