X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/2352216441907f86d2df858c49948ab7bd5d7874..f3a4495d67a3c6692c963c7a7dcd46fd6bdafb7b:/data/push.c diff --git a/data/push.c b/data/push.c index 954d65c2..b0cbeb32 100644 --- a/data/push.c +++ b/data/push.c @@ -1,24 +1,40 @@ -m4_divert(-1) -*- C -*- + -*- C -*- # Yacc compatible skeleton for Bison -# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 -# Free Software Foundation, Inc. +# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, +# 2007 Free Software Foundation, Inc. -# This program is free software; you can redistribute it and/or modify +# 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 2 of the License, or +# 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, write to the Free Software -# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -# 02110-1301 USA +# 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]]]]) +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]]), + [pull], [m4_define([b4_push_flag], [[0]])], + [push], [m4_define([b4_pull_flag], [[0]])]) + +# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing +# tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's +# behavior at all when push parsing is already requested. +b4_define_flag_if([use_push_for_pull]) +b4_use_push_for_pull_if([ + b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], + [m4_define([b4_push_flag], [[1]])])]) m4_include(b4_pkgdatadir/[c.m4]) @@ -35,6 +51,10 @@ m4_define_default([b4_stack_depth_init], [200]) ## Pure/impure interfaces. ## ## ------------------------ ## +b4_percent_define_default([[api.pure]], [[false]]) +b4_define_flag_if([pure]) +m4_define([b4_pure_flag], + [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])]) # b4_yacc_pure_if(IF-TRUE, IF-FALSE) # ---------------------------------- @@ -63,7 +83,6 @@ b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl m4_ifdef([b4_lex_param], b4_lex_param))) - ## ------------ ## ## Data Types. ## ## ------------ ## @@ -133,8 +152,8 @@ m4_define([b4_rhs_location], # We do want M4 expansion after # for CPP macros. m4_changecom() -m4_divert(0)dnl -@output b4_parser_file_name +m4_divert_push(0)dnl +@output(b4_parser_file_name@) b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl ' [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])[ @@ -149,20 +168,23 @@ b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl ' USER NAME SPACE" below. */ ]b4_identification + +b4_percent_code_get([[top]])[]dnl m4_if(b4_prefix, [yy], [], -[/* Substitute the variable and function names. */ -]b4_push_if([#define yypush_parse b4_prefix[]push_parse -#define yypstate_new b4_prefix[]pstate_new -#define yypstate_delete b4_prefix[]pstate_delete -#define yypstate b4_prefix[]pstate], -[#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 -b4_locations_if([#define yylloc b4_prefix[]lloc])])[ +[[/* 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 yyerror ]b4_prefix[error +#define yylval ]b4_prefix[lval +#define yychar ]b4_prefix[char +#define yydebug ]b4_prefix[debug +#define yynerrs ]b4_prefix[nerrs +]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[ /* Copy the first part of user declarations. */ ]b4_user_pre_prologue[ @@ -185,17 +207,16 @@ b4_locations_if([#define yylloc b4_prefix[]lloc])])[ # define YYTOKEN_TABLE ]b4_token_table[ #endif -]m4_ifdef([b4_requires], -[[/* Copy the %requires blocks. */ -]b4_user_requires])[]dnl +]b4_percent_code_get([[requires]])[]dnl b4_token_enums_defines(b4_tokens)[ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED ]m4_ifdef([b4_stype], [[typedef union ]b4_union_name[ +{ ]b4_user_stype[ - YYSTYPE; +} YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1]], [m4_if(b4_tag_seen_flag, 0, [[typedef int YYSTYPE; @@ -222,25 +243,29 @@ b4_push_if([[#ifndef YYPUSH_DECLS struct yypstate; typedef struct yypstate yypstate; enum { YYPUSH_MORE = 4 }; -]b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []]) + +]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param) +])b4_c_function_decl([[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_pull_if([b4_c_function_decl([[yypull_parse]], [[int]], + [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, + b4_parse_param]))]) +b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []]) b4_c_function_decl([[yypstate_delete]], [[void]], - [[[yypstate *yyps]], [[yyps]]]) -b4_c_function_decl([[yypush_parse]], [[int]], - [[[yypstate *yyps]], [[yyps]]], - [[[int yynchar]], [[yynchar]]], - [[[YYSTYPE const *yynlval]], [[yynlval]]]b4_locations_if([, - [[[YYLTYPE const *yynlloc]], [[yynlloc]]]])m4_ifset([b4_parse_param], [, - b4_parse_param]))[ + [[[yypstate *yyps]], [[yyps]]])[ #endif ]]) -m4_ifdef([b4_provides], -[[/* Copy the %provides blocks. */ -]b4_user_provides])[]dnl +b4_percent_code_get([[provides]])[]dnl [/* Copy the second part of user declarations. */ -]b4_user_post_prologue[ +]b4_user_post_prologue +b4_percent_code_get[]dnl -#ifdef short +[#ifdef short # undef short #endif @@ -316,7 +341,8 @@ typedef short int yytype_int16; #if ! defined yyoverflow || YYERROR_VERBOSE -/* The parser invokes alloca or malloc; define the necessary symbols. */ +]b4_push_if([], +[[/* The parser invokes alloca or malloc; define the necessary symbols. */ # ifdef YYSTACK_USE_ALLOCA # if YYSTACK_USE_ALLOCA @@ -341,7 +367,8 @@ typedef short int yytype_int16; # endif # endif -# ifdef YYSTACK_ALLOC +]])dnl +[# ifdef YYSTACK_ALLOC /* Pacify GCC's `empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) # ifndef YYSTACK_ALLOC_MAXIMUM @@ -732,12 +759,12 @@ do { \ /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { - fprintf (stderr, " $%d = ", yyi + 1); + 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[); - fprintf (stderr, "\n"); + YYFPRINTF (stderr, "\n"); } } @@ -994,30 +1021,25 @@ int yychar; /* The semantic value of the lookahead symbol. */ YYSTYPE yylval; - -/* Number of syntax errors so far. */ -]b4_push_if([],[ -int yynerrs;])b4_locations_if([[ +]b4_locations_if([[ /* Location data for the lookahead symbol. */ -YYLTYPE yylloc;]]) -]) - -m4_define([b4_yyssa],b4_push_if([yyps->yyssa],[yyssa])) -m4_define([b4_yyerror_range],b4_push_if([yyps->yyerror_range],[yyerror_range])) +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; - int yyn; - int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; - /* Look-ahead token as an internal (translated) token number. */ - int yytoken]b4_push_if([], [[ = 0]])[; /* Three stacks and their tools: `yyss': related to states, @@ -1029,25 +1051,24 @@ m4_define([b4_declare_parser_state_variables], /* The state stack. */ yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss]b4_push_if([], [[ = yyssa]])[; + yytype_int16 *yyss; yytype_int16 *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs]b4_push_if([], [[ = yyvsa]])[; - YYSTYPE *yyvsp;]b4_locations_if([[ + YYSTYPE *yyvs; + YYSTYPE *yyvsp; +]b4_locations_if([[ /* The location stack. */ YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls]b4_push_if([], [[ = yylsa]])[; + YYLTYPE *yyls; YYLTYPE *yylsp; + /* The locations where the error started and ended. */ - YYLTYPE yyerror_range[2];]])[ - YYSIZE_T yystacksize]b4_push_if([], [[ = YYINITDEPTH]])[; - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval;]b4_locations_if([[ - YYLTYPE yyloc;]]) -]) + YYLTYPE yyerror_range[2]; +]])[ + YYSIZE_T yystacksize; +]]) m4_divert_pop([KILL])dnl# ====================== End of M4 code. @@ -1062,63 +1083,103 @@ b4_push_if( int yynew; }; -/* Initialize the parser data structure. */ -]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ +]b4_pull_if([b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ { - yypstate *yyps = (yypstate *) malloc (sizeof *yyps); - yyps->yystate = 0; - yyps->yyresult = -1; - yyps->yyerrstatus = 0; - yyps->yytoken = 0; - - yyps->yyss = yyps->yyssa; - yyps->yyvs = yyps->yyvsa; - - ]b4_locations_if([ - yyps->yyls = yyps->yylsa;])[ - yyps->yystacksize = YYINITDEPTH; + return yypull_parse (0]m4_ifset([b4_parse_param], + [[, ]b4_c_args(b4_parse_param)])[); +}]b4_pure_if([], [[ - yyps->yyssp = yyps->yyss; - yyps->yyvsp = yyps->yyvs; - - yyps->yynew = 1; - -]b4_locations_if([ yyps->yylsp = yyps->yyls;])[ +static char yypstate_allocated = 0;]])[ +]b4_c_function_def([[yypull_parse]], [[int]], + [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, + b4_parse_param]))[ +{ + int yystatus; + yypstate *yyps_local; +]b4_pure_if([[ int yychar; + YYSTYPE yylval; +]b4_locations_if([[ YYLTYPE yylloc; +]])])[ + if (yyps == 0) + { + yyps_local = yypstate_new (); + if (!yyps_local) + {]b4_pure_if([[ + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[ + if (!yypstate_allocated) + yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[ + return 2; + } + } + else + yyps_local = yyps; + do { + yychar = YYLEX; + yystatus = + yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[); + } while (yystatus == YYPUSH_MORE); + if (yyps == 0) + yypstate_delete (yyps_local); + return yystatus; +} +]])[ +/* Initialize the parser data structure. */ +]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ +{ + yypstate *yyps;]b4_pure_if([], [[ + if (yypstate_allocated) + { + yyerror (]b4_yyerror_args[YY_("cannot allocate multiple impure push-parser instances")); + return 0; + }]])[ + yyps = (yypstate *) malloc (sizeof *yyps); + if (!yyps) + return 0; + yyps->yynew = 1;]b4_pure_if([], [[ + yypstate_allocated = 1;]])[ return yyps; } ]b4_c_function_def([[yypstate_delete]], [[void]], [[[yypstate *yyps]], [[yyps]]])[ { - free (yyps); +#ifndef yyoverflow + /* If the stack was reallocated but the parse did not complete, then the + stack still needs to be freed. */ + if (!yyps->yynew && yyps->yyss != yyps->yyssa) + YYSTACK_FREE (yyps->yyss); +#endif + free (yyps);]b4_pure_if([], [[ + yypstate_allocated = 0;]])[ } -#define yystate yyps->yystate -#define yyn yyps->yyn -#define yyresult yyps->yyresult +]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs +]])[#define yystate yyps->yystate #define yyerrstatus yyps->yyerrstatus -#define yytoken yyps->yytoken +#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 yyls yyps->yyls +]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 -#define yyval yyps->yyval -]b4_locations_if([[#define yyloc yyps->yyloc -]])])[ +]])[ /*-------------------------. | yyparse or yypush_parse. | `-------------------------*/ ]b4_push_if([ -b4_c_function_def([[yypush_parse]], [[int]], [[[yypstate *yyps]], [[yyps]]], - [[[int yynchar]], [[yynchar]]], - [[[YYSTYPE const *yynlval]], [[yynlval]]]b4_locations_if([, - [[[YYLTYPE const *yynlloc]], [[yynlloc]]]])m4_ifset([b4_parse_param], [, +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]))], [ #ifdef YYPARSE_PARAM b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]]) @@ -1126,9 +1187,21 @@ b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]]) b4_c_function_def([yyparse], [int], b4_parse_param) #endif])[ { - ]b4_pure_if([b4_declare_scanner_communication_variables]) - b4_push_if([], [b4_declare_parser_state_variables])[ - +]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; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; +]b4_locations_if([[ YYLTYPE yyloc; +]])[ #if YYERROR_VERBOSE /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; @@ -1141,19 +1214,26 @@ b4_c_function_def([yyparse], [int], b4_parse_param) /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ int yylen = 0; +]b4_push_if([[ + if (!yyps->yynew) + { + yyn = yypact[yystate]; + goto yyread_pushed_token; + } +]])[ + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; +]b4_locations_if([[ yyls = yylsa; +]])[ + yystacksize = YYINITDEPTH; YYDPRINTF ((stderr, "Starting parse\n")); -]b4_push_if([ yychar = yynchar; - if (yynlval) - yylval = *yynlval; -]b4_locations_if([ if (yynlloc) - yylloc = *yynlloc;])[],[yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */])[ - -]b4_push_if([],[[ yystate = 0; yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack @@ -1162,22 +1242,17 @@ b4_c_function_def([yyparse], [int], b4_parse_param) yyssp = yyss; yyvsp = yyvs; ]b4_locations_if([[ yylsp = yyls; + #if YYLTYPE_IS_TRIVIAL /* Initialize the default location before parsing starts. */ yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[; yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[; -#endif]]) -]) -[ ]b4_push_if([ - if (yyps->yynew == 0) - { - goto gottoken; - } - yyps->yynew= 0;]) +#endif +]]) m4_ifdef([b4_initial_action], [ m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl - /* User initialization code. */ +/* User initialization code. */ b4_user_initial_action m4_popdef([b4_dollar_dollar])dnl m4_popdef([b4_at_dollar])])dnl @@ -1247,7 +1322,7 @@ m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; YYSTACK_RELOCATE (yyvs_alloc, yyvs); ]b4_locations_if([ YYSTACK_RELOCATE (yyls_alloc, yyls);])[ # undef YYSTACK_RELOCATE - if (yyss1 != ]b4_yyssa[) + if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif @@ -1289,14 +1364,32 @@ yybackup: /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ if (yychar == YYEMPTY) { - ]b4_push_if([ - YYDPRINTF ((stderr, "Return for a new token:\n")); - yyresult = YYPUSH_MORE; - goto yypushreturn; -gottoken:])[ - YYDPRINTF ((stderr, "Reading a token: ")); - ]b4_push_if([], [yychar = YYLEX;])[ - } +]b4_push_if([[ if (!yyps->yynew) + { +]b4_use_push_for_pull_if([], +[[ YYDPRINTF ((stderr, "Return for a new token:\n")); +]])[ yyresult = YYPUSH_MORE; + goto yypushreturn; + } + yyps->yynew = 0; +]b4_pure_if([], [[ + /* Restoring the pushed token is only necessary for the first + yypush_parse invocation since subsequent invocations don't overwrite + it before jumping to yyread_pushed_token. */ + yychar = yypushed_char; + yylval = yypushed_val; + ]b4_locations_if([[yylloc = yypushed_loc; +]])])[ +yyread_pushed_token: +]])[ YYDPRINTF ((stderr, "Reading a token: ")); +]b4_push_if([b4_pure_if([[ yychar = yypushed_char; + if (yypushed_val) + yylval = *yypushed_val; +]b4_locations_if([[ if (yypushed_loc) + yylloc = *yypushed_loc; +]])])], +[[ yychar = YYLEX; +]])[ } if (yychar <= YYEOF) { @@ -1407,7 +1500,7 @@ yyerrlab: /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { -]b4_push_if([],[ ++yynerrs;])[ + ++yynerrs; #if ! YYERROR_VERBOSE yyerror (]b4_yyerror_args[YY_("syntax error")); #else @@ -1445,7 +1538,7 @@ yyerrlab: #endif } -]b4_locations_if([[ ]b4_yyerror_range[[0] = yylloc;]])[ +]b4_locations_if([[ yyerror_range[0] = yylloc;]])[ if (yyerrstatus == 3) { @@ -1482,7 +1575,7 @@ yyerrorlab: if (/*CONSTCOND*/ 0) goto yyerrorlab; -]b4_locations_if([[ ]b4_yyerror_range[[0] = yylsp[1-yylen]; +]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen]; ]])[ /* Do not reclaim the symbols of the rule which action triggered this YYERROR. */ YYPOPSTACK (yylen); @@ -1516,7 +1609,7 @@ yyerrlab1: if (yyssp == yyss) YYABORT; -]b4_locations_if([[ ]b4_yyerror_range[[0] = *yylsp;]])[ +]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[ yydestruct ("Error: popping", yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); YYPOPSTACK (1); @@ -1526,10 +1619,10 @@ yyerrlab1: *++yyvsp = yylval; ]b4_locations_if([[ - ]b4_yyerror_range[[1] = yylloc; + yyerror_range[1] = yylloc; /* Using YYLLOC is tempting, but would change the location of the lookahead. YYLOC is available though. */ - YYLLOC_DEFAULT (yyloc, (]b4_yyerror_range[- 1), 2); + YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); *++yylsp = yyloc;]])[ /* Shift the error token. */ @@ -1578,35 +1671,37 @@ yyreturn: YYPOPSTACK (1); } #ifndef yyoverflow - if (yyss != ]b4_yyssa[) + if (yyss != yyssa) YYSTACK_FREE (yyss); #endif -]b4_push_if([yypushreturn:])[ -#if YYERROR_VERBOSE +]b4_push_if([[ yyps->yynew = 1; + +yypushreturn: +]])[#if YYERROR_VERBOSE if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); #endif /* Make sure YYID is used. */ return YYID (yyresult); -]} +} -b4_epilogue + +]b4_epilogue b4_defines_if( -[@output b4_spec_defines_file +[@output(b4_spec_defines_file@) b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],dnl ' [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006]) -m4_ifdef([b4_requires], -[[/* Copy the %requires blocks. */ -]b4_user_requires])[]dnl +b4_percent_code_get([[requires]])[]dnl b4_token_enums_defines(b4_tokens) [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED ]m4_ifdef([b4_stype], [[typedef union ]b4_union_name[ +{ ]b4_user_stype[ - YYSTYPE; +} YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1]], [m4_if(b4_tag_seen_flag, 0, [[typedef int YYSTYPE; @@ -1615,8 +1710,7 @@ b4_token_enums_defines(b4_tokens) # define YYSTYPE_IS_DECLARED 1 #endif -]b4_pure_if([], -[extern YYSTYPE b4_prefix[]lval;]) +]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]]) b4_locations_if( [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED @@ -1632,8 +1726,7 @@ typedef struct YYLTYPE # define YYLTYPE_IS_TRIVIAL 1 #endif -]b4_pure_if([], - [extern YYLTYPE b4_prefix[]lloc;]) +]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]]) )dnl b4_locations_if b4_push_if([[#ifndef YYPUSH_DECLS @@ -1641,19 +1734,22 @@ b4_push_if([[#ifndef YYPUSH_DECLS struct ]b4_prefix[pstate; typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; enum { YYPUSH_MORE = 4 }; -]b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]], +]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param) +])b4_c_function_decl([b4_prefix[push_parse]], [[int]], + [[b4_prefix[pstate *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_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]], + [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, + b4_parse_param]))]) +b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]], [[[void]], []]) b4_c_function_decl([b4_prefix[pstate_delete]], [[void]], - [[b4_prefix[pstate *yyps]], [[yyps]]]) -b4_c_function_decl([b4_prefix[push_parse]], [[int]], - [[b4_prefix[pstate *yyps]], [[yyps]]], - [[[int yynchar]], [[yynchar]]], - [[[YYSTYPE const *yynlval]], [[yynlval]]]b4_locations_if([, - [[[YYLTYPE const *yynlloc]], [[yynlloc]]]])m4_ifset([b4_parse_param], [, - b4_parse_param]))[ + [[b4_prefix[pstate *yyps]], [[yyps]]])[ #endif ]]) -m4_ifdef([b4_provides], -[[/* Copy the %provides blocks. */ -]b4_user_provides])[] +b4_percent_code_get([[provides]])[]dnl ])dnl b4_defines_if +m4_divert_pop(0)