X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/bd187d7b6573a60ad56c3fbcaccb5c768bc8d7ba..45319f1365eb8d125424f31401d9d33cc02ff4ad:/data/yacc.c?ds=inline diff --git a/data/yacc.c b/data/yacc.c index 872e63f1..ea2ae147 100644 --- a/data/yacc.c +++ b/data/yacc.c @@ -2,10 +2,11 @@ # Yacc compatible skeleton for Bison # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, -# 2007, 2008 Free Software Foundation, Inc. +# 2007, 2008, 2009 Free Software Foundation, Inc. m4_pushdef([b4_copyright_years], -[1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008]) + [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, + 2007, 2008, 2009]) # 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 @@ -20,13 +21,13 @@ m4_pushdef([b4_copyright_years], # You should have received a copy of the GNU General Public License # along with this program. If not, see . -# Check the value of %define api.push_pull. -b4_percent_define_default([[api.push_pull]], [[pull]]) -b4_percent_define_check_values([[[[api.push_pull]], - [[pull]], [[push]], [[both]]]]) +# Check the value of %define api.push-pull. +b4_percent_define_default([[api.push-pull]], [[pull]]) +b4_percent_define_check_values([[[[api.push-pull]], + [[pull]], [[push]], [[both]]]]) b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) -m4_case(b4_percent_define_get([[api.push_pull]]), +m4_case(b4_percent_define_get([[api.push-pull]]), [pull], [m4_define([b4_push_flag], [[0]])], [push], [m4_define([b4_pull_flag], [[0]])]) @@ -147,6 +148,68 @@ m4_define([b4_rhs_location], [(yylsp@{b4_subtract([$2], [$1])@})]) +## ------------------ ## +## Parser variables. ## +## ------------------ ## + +# b4_declare_scanner_communication_variables +# ------------------------------------------ +# Declare the variables that are global, or local to YYPARSE if +# pure-parser. +m4_define([b4_declare_scanner_communication_variables], [[ +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval;]b4_locations_if([[ + +/* Location data for the lookahead symbol. */ +YYLTYPE yylloc;]])b4_pure_if([], [[ + +/* Number of syntax errors so far. */ +int yynerrs;]])]) + + +# b4_declare_parser_state_variables +# --------------------------------- +# Declare all the variables that are needed to maintain the parser state +# between calls to yypush_parse. +m4_define([b4_declare_parser_state_variables], [b4_pure_if([[ + /* Number of syntax errors so far. */ + int yynerrs; +]])[ + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values.]b4_locations_if([[ + `yyls': related to locations.]])[ + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp;]b4_locations_if([[ + + /* The location stack. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls; + YYLTYPE *yylsp; + + /* The locations where the error started and ended. */ + YYLTYPE yyerror_range[2];]])[ + + YYSIZE_T yystacksize;]]) + ## --------------------------------------------------------- ## ## Defining symbol actions, e.g., printers and destructors. ## @@ -156,8 +219,7 @@ m4_define([b4_rhs_location], m4_changecom() m4_divert_push(0)dnl @output(b4_parser_file_name@)@ -b4_copyright([Implementation for Bison's Yacc-like parsers in C])dnl' -[ +b4_copyright([Implementation for Bison's Yacc-like parsers in C])[ /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ @@ -172,14 +234,14 @@ b4_copyright([Implementation for Bison's Yacc-like parsers in C])dnl' ]b4_identification b4_percent_code_get([[top]])[]dnl m4_if(b4_prefix, [yy], [], -[[/* Substitute the variable and function names. */ -]b4_pull_if([[#define yyparse ]b4_prefix[parse -]])b4_push_if([[#define yypush_parse ]b4_prefix[push_parse -]b4_pull_if([[#define yypull_parse ]b4_prefix[pull_parse -]])[#define yypstate_new ]b4_prefix[pstate_new +[[/* Substitute the variable and function names. */]b4_pull_if([[ +#define yyparse ]b4_prefix[parse]])b4_push_if([[ +#define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[ +#define yypull_parse ]b4_prefix[pull_parse]])[ +#define yypstate_new ]b4_prefix[pstate_new #define yypstate_delete ]b4_prefix[pstate_delete -#define yypstate ]b4_prefix[pstate -]])[#define yylex ]b4_prefix[lex +#define yypstate ]b4_prefix[pstate]])[ +#define yylex ]b4_prefix[lex #define yyerror ]b4_prefix[error #define yylval ]b4_prefix[lval #define yychar ]b4_prefix[char @@ -192,7 +254,7 @@ m4_if(b4_prefix, [yy], [], /* Enabling traces. */ #ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ +# define YYDEBUG ]b4_parse_trace_if([1], [0])[ #endif /* Enabling verbose error messages. */ @@ -200,7 +262,7 @@ m4_if(b4_prefix, [yy], [], # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else -# define YYERROR_VERBOSE ]b4_error_verbose_flag[ +# define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[ #endif /* Enabling the token table. */ @@ -501,24 +563,8 @@ static const ]b4_int_type_for([b4_translate])[ yytranslate[] = }; #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[ -}; +]b4_integral_parser_table_define([rline], [b4_rline], + [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[ #endif #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE @@ -539,67 +585,17 @@ static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = }; # 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[ -}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM 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[ -}; - -/* YYDEFGOTO[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[ -}; +#define yypact_value_is_default(yystate) \ + ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[ -/* 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[ -}; -static const ]b4_int_type_for([b4_check])[ yycheck[] = -{ - ]b4_check[ -}; +#define yytable_value_is_error(yytable_value) \ + ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[ -/* 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[ -}; +]b4_parser_tables_define[ #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) @@ -748,24 +744,26 @@ do { \ `------------------------------------------------*/ ]b4_c_function_def([yy_reduce_print], [static void], - [[YYSTYPE *yyvsp], [yyvsp]], + [[yytype_int16 *yyssp], [yyssp]], + [[YYSTYPE *yyvsp], [yyvsp]], b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], - ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, - b4_parse_param]))[ + ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, + b4_parse_param]))[ { + unsigned long int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; - unsigned long int yylno = yyrline[yyrule]; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", - yyrule - 1, yylno); + yyrule - 1, yylno); /* 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[); + yy_symbol_print (stderr, + yystos[yyssp[yyi + 1 - yynrhs]], + &]b4_rhs_value(yynrhs, yyi + 1)[ + ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); YYFPRINTF (stderr, "\n"); } } @@ -773,7 +771,7 @@ do { \ # define YY_REDUCE_PRINT(Rule) \ do { \ if (yydebug) \ - yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ + yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ } while (YYID (0)) /* Nonzero means print parse trace. It is left uninitialized so that @@ -891,195 +889,142 @@ yytnamerr (char *yyres, const char *yystr) } # endif -/* Copy into YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, - including the terminating null byte. If YYRESULT is null, do not - copy anything; just return the number of bytes that would be - copied. As a special case, return 0 if an ordinary "syntax error" - message will do. Return YYSIZE_MAXIMUM if overflow occurs during - size calculation. */ -static YYSIZE_T -yysyntax_error (char *yyresult, int yystate, int yychar) +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN while in state YYSTATE. + + Return 0 if *YYMSG was successfully written. Return 1 if an ordinary + "syntax error" message will suffice instead. Return 2 if *YYMSG is + not large enough to hold the message. In the last case, also set + *YYMSG_ALLOC to either (a) the required number of bytes or (b) zero + if the required number of bytes is too large to store. */ +static int +yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, + int yystate, int yytoken) { int yyn = yypact[yystate]; if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) - return 0; + return 1; else { - int yytype = YYTRANSLATE (yychar); - YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); YYSIZE_T yysize = yysize0; YYSIZE_T yysize1; - int yysize_overflow = 0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = 0; + /* Arguments of yyformat. */ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - -# if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -# endif - 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. */ + YYCHECK. In other words, skip the first -YYN actions for this + state because they are default actions. */ 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; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + int yyx; - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy (yyformat, yyunexpected); + yyarg[yycount++] = yytname[yytoken]; for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR + && !yytable_value_is_error (yytable[yyx + yyn])) { if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) { yycount = 1; yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; break; } yyarg[yycount++] = yytname[yyx]; yysize1 = yysize + yytnamerr (0, yytname[yyx]); - yysize_overflow |= (yysize1 < yysize); + if (! (yysize <= yysize1 + && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + { + /* Overflow. */ + *yymsg_alloc = 0; + return 2; + } yysize = yysize1; - yyfmt = yystpcpy (yyfmt, yyprefix); - yyprefix = yyor; } - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen (yyf); - yysize_overflow |= (yysize1 < yysize); + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + yysize1 = yysize + yystrlen (yyformat); + if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) + { + /* Overflow. */ + *yymsg_alloc = 0; + return 2; + } yysize = yysize1; - if (yysize_overflow) - return YYSIZE_MAXIMUM; + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return 2; + } - if (yyresult) - { - /* Avoid sprintf, as that infringes on the user's name space. - Don't have undefined behavior even if the translation - produced a string with the wrong number of "%s"s. */ - char *yyp = yyresult; - int yyi = 0; - while ((*yyp = *yyf) != '\0') - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } - } - return yysize; + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } + } + return 0; } } #endif /* YYERROR_VERBOSE */ -]b4_yydestruct_generate([b4_c_function_def])[ +]b4_yydestruct_generate([b4_c_function_def])b4_push_if([], [[ -]b4_push_if([], -[[/* Prevent warnings from -Wmissing-prototypes. */ + +/* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM ]b4_c_function_decl([yyparse], [int], - [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ + [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ #else /* ! YYPARSE_PARAM */ ]b4_c_function_decl([yyparse], [int], b4_parse_param)[ -#endif /* ! YYPARSE_PARAM */]]) - -m4_divert_push([KILL])# ======================== M4 code. -# b4_declare_scanner_communication_variables -# ------------------------------------------ -# Declare the variables that are global, or local to YYPARSE if -# pure-parser. -m4_define([b4_declare_scanner_communication_variables], -[[/* The lookahead symbol. */ -int yychar; +#endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [ -/* The semantic value of the lookahead symbol. */ -YYSTYPE yylval; -]b4_locations_if([[ -/* Location data for the lookahead symbol. */ -YYLTYPE yylloc; -]])b4_pure_if([], [[ -/* Number of syntax errors so far. */ -int yynerrs; -]])]) - -# b4_declare_parser_state_variables -# --------------------------------- -# Declare all the variables that are needed to maintain the parser state -# between calls to yypush_parse. -m4_define([b4_declare_parser_state_variables], -[b4_pure_if([[ /* Number of syntax errors so far. */ - int yynerrs; -]])[ - int yystate; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; +b4_declare_scanner_communication_variables])[]b4_push_if([[ - /* The stacks and their tools: - `yyss': related to states. - `yyvs': related to semantic values.]b4_locations_if([[ - `yyls': related to locations.]])[ - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss; - yytype_int16 *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs; - YYSTYPE *yyvsp; -]b4_locations_if([[ - /* The location stack. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls; - YYLTYPE *yylsp; - - /* The locations where the error started and ended. */ - YYLTYPE yyerror_range[2]; -]])[ - YYSIZE_T yystacksize; -]]) - -m4_divert_pop([KILL])dnl# ====================== End of M4 code. - -b4_pure_if([], [b4_declare_scanner_communication_variables]) - -b4_push_if( -[[struct yypstate - { - ]b4_declare_parser_state_variables[ +struct yypstate + {]b4_declare_parser_state_variables[ /* Used to determine if this is the first time this instance has been used. */ int yynew; @@ -1151,44 +1096,53 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ free (yyps);]b4_pure_if([], [[ yypstate_allocated = 0;]])[ } - -]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs -]])[#define yystate yyps->yystate +]b4_pure_if([[ +#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[ +#define yystate yyps->yystate #define yyerrstatus yyps->yyerrstatus #define yyssa yyps->yyssa #define yyss yyps->yyss #define yyssp yyps->yyssp #define yyvsa yyps->yyvsa #define yyvs yyps->yyvs -#define yyvsp yyps->yyvsp -]b4_locations_if([[#define yylsa yyps->yylsa +#define yyvsp yyps->yyvsp]b4_locations_if([[ +#define yylsa yyps->yylsa #define yyls yyps->yyls #define yylsp yyps->yylsp -#define yyerror_range yyps->yyerror_range -]])[#define yystacksize yyps->yystacksize -]])[ -/*-------------------------. -| yyparse or yypush_parse. | -`-------------------------*/ -]b4_push_if([ -b4_c_function_def([[yypush_parse]], [[int]], +#define yyerror_range yyps->yyerror_range]])[ +#define yystacksize yyps->yystacksize + + +/*---------------. +| yypush_parse. | +`---------------*/ + +]b4_c_function_def([[yypush_parse]], [[int]], [[[yypstate *yyps]], [[yyps]]]b4_pure_if([, [[[int yypushed_char]], [[yypushed_char]]], [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [, - b4_parse_param]))], [ + b4_parse_param]))], [[ + + +/*----------. +| yyparse. | +`----------*/ + #ifdef YYPARSE_PARAM -b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]]) +]b4_c_function_def([yyparse], [int], + [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ #else /* ! YYPARSE_PARAM */ -b4_c_function_def([yyparse], [int], b4_parse_param) -#endif])[ -{ -]b4_pure_if([b4_declare_scanner_communication_variables]) -b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar; - YYSTYPE yypushed_val = yylval; - ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc; -]])])], - [b4_declare_parser_state_variables])[ +]b4_c_function_def([yyparse], [int], b4_parse_param)[ +#endif]])[ +{]b4_pure_if([b4_declare_scanner_communication_variables +])b4_push_if([b4_pure_if([], [[ + int yypushed_char = yychar; + YYSTYPE yypushed_val = yylval;]b4_locations_if([[ + YYLTYPE yypushed_loc = yylloc;]]) +])], + [b4_declare_parser_state_variables +])[ int yyn; int yyresult; /* Lookahead token as an internal (translated) token number. */ @@ -1350,7 +1304,7 @@ yybackup: /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) + if (yypact_value_is_default (yyn)) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ @@ -1400,7 +1354,7 @@ yyread_pushed_token:]])[ yyn = yytable[yyn]; if (yyn <= 0) { - if (yyn == 0 || yyn == YYTABLE_NINF) + if (yytable_value_is_error (yyn)) goto yyerrlab; yyn = -yyn; goto yyreduce; @@ -1494,37 +1448,28 @@ yyerrlab: #if ! YYERROR_VERBOSE yyerror (]b4_yyerror_args[YY_("syntax error")); #else - { - YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); - if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) - { - YYSIZE_T yyalloc = 2 * yysize; - if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) - yyalloc = YYSTACK_ALLOC_MAXIMUM; - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC (yyalloc); - if (yymsg) - yymsg_alloc = yyalloc; - else - { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - } - } - - if (0 < yysize && yysize <= yymsg_alloc) - { - (void) yysyntax_error (yymsg, yystate, yychar); - yyerror (]b4_yyerror_args[yymsg); - } - else - { - yyerror (]b4_yyerror_args[YY_("syntax error")); - if (yysize != 0) - goto yyexhaustedlab; - } - } + while (1) + { + int yysyntax_error_status = + yysyntax_error (&yymsg_alloc, &yymsg, yystate, yytoken); + if (yysyntax_error_status == 2 && 0 < yymsg_alloc) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); + if (yymsg) + continue; + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + } + if (yysyntax_error_status == 0) + yyerror (]b4_yyerror_args[yymsg); + else + yyerror (]b4_yyerror_args[YY_("syntax error")); + if (yysyntax_error_status == 2) + goto yyexhaustedlab; + break; + } #endif } @@ -1584,7 +1529,7 @@ yyerrlab1: for (;;) { yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) + if (!yypact_value_is_default (yyn)) { yyn += YYTERROR; if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) @@ -1663,11 +1608,11 @@ yyreturn: #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); -#endif -]b4_push_if([[ yyps->yynew = 1; +#endif]b4_push_if([[ + yyps->yynew = 1; -yypushreturn: -]])[#if YYERROR_VERBOSE +yypushreturn:]])[ +#if YYERROR_VERBOSE if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); #endif @@ -1675,11 +1620,10 @@ yypushreturn: return YYID (yyresult); } - -]b4_epilogue +]b4_epilogue[]dnl b4_defines_if( [@output(b4_spec_defines_file@)@ -b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl' +b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl b4_percent_code_get([[requires]])[]dnl