X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/31c10e38dbf21a29af558c6f5144acd22dbc956e..6afc30cc8763e690a1f9b8aa21fbc7b72244b5c6:/data/push.c diff --git a/data/push.c b/data/push.c index a9651567..1482d471 100644 --- a/data/push.c +++ b/data/push.c @@ -1,9 +1,9 @@ -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 # it under the terms of the GNU General Public License as published by @@ -20,6 +20,18 @@ m4_divert(-1) -*- C -*- # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301 USA +# 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_use_push_for_pull_if([ + b4_push_if([ + m4_define([b4_use_push_for_pull_flag], [[0]]) + b4_define_flag_if([use_push_for_pull]) + ], [ + m4_define([b4_push_flag], [[1]]) + b4_define_flag_if([push]) + ])]) + m4_include(b4_pkgdatadir/[c.m4]) ## ---------------- ## @@ -63,7 +75,6 @@ b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl m4_ifdef([b4_lex_param], b4_lex_param))) - ## ------------ ## ## Data Types. ## ## ------------ ## @@ -133,8 +144,8 @@ m4_define([b4_rhs_location], # We do want M4 expansion after # for CPP macros. m4_changecom() -m4_divert(0)dnl -@output @output_parser_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,26 +160,25 @@ b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl ' USER NAME SPACE" below. */ ]b4_identification +b4_get_percent_code([[top]])[]dnl m4_if(b4_prefix, [yy], [], -[/* Substitute the variable and function names. */ -#define yyparse b4_prefix[]parse -#define yypushparse b4_prefix[]pushparse -#define yypvarsinit b4_prefix[]pvarsinit -#define yypvars b4_prefix[]pvars -#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]) -b4_push_if([#define yyresult_get b4_prefix[]result_get -#define yychar_set b4_prefix[]char_set -#define yylval_set b4_prefix[]lval_set -#define yylloc_set b4_prefix[]lloc_set])])[ +[[/* 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_pre_prologue[ +]b4_user_pre_prologue[ /* Enabling traces. */ #ifndef YYDEBUG @@ -188,9 +198,7 @@ b4_push_if([#define yyresult_get b4_prefix[]result_get # define YYTOKEN_TABLE ]b4_token_table[ #endif -]m4_ifdef([b4_start_header], -[[/* Copy the %start-header blocks. */ -]b4_start_header])[]dnl +]b4_get_percent_code([[requires]])[]dnl b4_token_enums_defines(b4_tokens)[ @@ -220,14 +228,34 @@ typedef struct YYLTYPE # define YYLTYPE_IS_TRIVIAL 1 #endif]) -m4_ifdef([b4_end_header], -[[/* Copy the %end-header blocks. */ -]b4_end_header])[]dnl +b4_push_if([[#ifndef YYPUSH_DECLS +# define YYPUSH_DECLS +struct yypstate; +typedef struct yypstate yypstate; +enum { YYPUSH_MORE = 4 }; + +]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]]])[ +#endif +]]) +b4_get_percent_code([[provides]])[]dnl [/* Copy the second part of user declarations. */ -]b4_user_post_prologue[ +]b4_user_post_prologue +b4_get_percent_code[]dnl -#ifdef short +[#ifdef short # undef short #endif @@ -376,9 +404,9 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ /* A type that is properly aligned for any stack member. */ union yyalloc { - yytype_int16 yyss; - YYSTYPE yyvs; - ]b4_locations_if([ YYLTYPE yyls; + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; + ]b4_locations_if([ YYLTYPE yyls_alloc; ])dnl [}; @@ -418,12 +446,12 @@ union yyalloc elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ -# define YYSTACK_RELOCATE(Stack) \ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ do \ { \ YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ @@ -709,7 +737,7 @@ do { \ [[YYSTYPE *yyvsp], [yyvsp]], b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, - ])b4_parse_param)[ + b4_parse_param]))[ { int yynrhs = yyr2[yyrule]; int yyi; @@ -960,70 +988,46 @@ yysyntax_error (char *yyresult, int yystate, int yychar) ]b4_yydestruct_generate([b4_c_function_def])[ - - -/* Prevent warnings from -Wmissing-prototypes. */ +]b4_push_if([], +[[/* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM ]b4_c_function_decl([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ #else /* ! YYPARSE_PARAM */ ]b4_c_function_decl([yyparse], [int], b4_parse_param)[ -#endif /* ! YYPARSE_PARAM */ +#endif /* ! YYPARSE_PARAM */]]) -]b4_push_if([ -struct yypvars; -]b4_c_function_decl([yyresult_get], [int], [[struct yypvars *YYPVARS], [YYPVARS]])[ -]b4_c_function_decl([yychar_set], [void], [[struct yypvars *YYPVARS], [YYPVARS]], [[int yychar], [yychar]])[ -]b4_c_function_decl([yylval_set], [void], [[struct yypvars *YYPVARS], [YYPVARS]], [[YYSTYPE yylval], [yylval]])[ -#ifdef YYLTYPE_IS_TRIVIAL -]b4_c_function_decl([yylloc_set], [void], [[struct yypvars *YYPVARS], [YYPVARS]], [[YYLTYPE yylloc], [yylloc]])[ -#endif -]b4_c_function_decl([yypvarsinit], [void *], [[void], []])[ -]b4_c_function_decl([yypushparse], [void], - [[struct yypvars *YYPVARS], [YYPVARS]])[ -])[ - -]m4_divert_push([KILL])# ======================== M4 code. -# b4_declare_parser_variables -# --------------------------- +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_parser_variables], -[/* The lookahead symbol. */ +m4_define([b4_declare_scanner_communication_variables], +[[/* The lookahead symbol. */ int yychar; /* The semantic value of the lookahead symbol. */ YYSTYPE yylval; - -/* Number of syntax errors so far. */ -int yynerrs;b4_locations_if([ +]b4_locations_if([[ /* Location data for the lookahead symbol. */ -YYLTYPE yylloc;]) -]) - -# b4_declare_yyparse_variables -# ---------------------------- -# Declare all the variables that are needed local to YYPARSE -m4_define([b4_declare_yyparse_variables], -[[struct yypvars - { -]]b4_declare_parser_variables[[ +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; - -#if YYERROR_VERBOSE - /* Buffer for error messages, and its allocated size. */ - char yymsgbuf[128]; - char *yymsgbuf_ptr; - char *yymsg; - YYSIZE_T yymsg_alloc; -#endif /* Three stacks and their tools: `yyss': related to states, @@ -1035,208 +1039,181 @@ m4_define([b4_declare_yyparse_variables], /* The state stack. */ yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyssa_ptr; yytype_int16 *yyss; yytype_int16 *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs; - YYSTYPE *yyvsp;]]b4_locations_if([[[ + 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]; - YYLTYPE *yyerror_range_ptr;]]])[ +]])[ YYSIZE_T yystacksize; - int yylen; - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; - /* Used to determine if this is the first time this instance has - been used. */ - int yynew;]b4_locations_if([YYLTYPE yyloc;])[ - }; - -/* Init the parser data structure. Use malloc, should perhaps use a - system dependent equivalent function. */ -void* -yypvarsinit (void) -{ - struct yypvars *pv; - pv= (struct yypvars *) malloc(sizeof(struct yypvars)); - pv->yystate = 0; - pv->yyresult = -1; - pv->yyerrstatus = 0; - pv->yytoken = 0; - -#if YYERROR_VERBOSE - pv->yymsgbuf_ptr = pv->yymsgbuf; - pv->yymsg = pv->yymsgbuf; - pv->yymsg_alloc = sizeof pv->yymsgbuf; -#endif - - pv->yyssa_ptr = pv->yyssa; - pv->yyss = pv->yyssa; - pv->yyvs = pv->yyvsa; - - ]b4_locations_if([ - pv->yyls = pv->yylsa;])[ - pv->yystacksize = YYINITDEPTH; - - pv->yyssp = pv->yyss; - pv->yyvsp = pv->yyvs; +]]) -#if YYLTYPE_IS_TRIVIAL - /* Initialize the default location before parsing starts. */ - pv->yylloc.first_line = pv->yylloc.last_line = ]b4_location_initial_line[; - pv->yylloc.first_column = pv->yylloc.last_column = ]b4_location_initial_column[; -#endif +m4_divert_pop([KILL])dnl# ====================== End of M4 code. - pv->yynew = 1; +b4_pure_if([], [b4_declare_scanner_communication_variables]) -]b4_locations_if([ pv->yylsp = pv->yyls;])[ - /* Init parser variables */ - - return (void*) pv; -} +b4_push_if( +[[struct yypstate + { + ]b4_declare_parser_state_variables[ + /* Used to determine if this is the first time this instance has + been used. */ + int yynew; + }; -int -yyresult_get (struct yypvars *YYPVARS) +]b4_pull_if([b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ { - return YYPVARS->yyresult; + return yypull_parse (0]m4_ifset([b4_parse_param], + [[, ]b4_c_args(b4_parse_param)])[); } -void -yychar_set (struct yypvars *YYPVARS, int yychar) +]b4_c_function_def([[yypull_parse]], [[int]], + [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, + b4_parse_param]))[ { - if (YYPVARS) - YYPVARS->yychar = yychar; + int yystatus; + yypstate *yyps_local; +]b4_pure_if([[ int yychar; + YYSTYPE yylval; +]b4_locations_if([[ YYLTYPE yylloc; +]])])[ + if (yyps == 0) + yyps_local = yypstate_new (); + 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; } - -void -yylval_set (struct yypvars *YYPVARS, YYSTYPE yylval) +]])[ +/* Initialize the parser data structure. */ +]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ { - if (YYPVARS) - YYPVARS->yylval = yylval; + yypstate *yyps = (yypstate *) malloc (sizeof *yyps); + yyps->yynew = 1; + return yyps; } -#ifdef YYLTYPE_IS_TRIVIAL -void -yylloc_set (struct yypvars *YYPVARS, YYLTYPE yylloc) +]b4_c_function_def([[yypstate_delete]], [[void]], + [[[yypstate *yyps]], [[yyps]]])[ { - if (YYPVARS) - YYPVARS->yylloc = yylloc; + free (yyps); } -#endif]) -m4_divert_pop([KILL])dnl# ====================== End of M4 code. - -b4_pure_if([], - [b4_declare_parser_variables]) -b4_push_if([b4_declare_yyparse_variables]) +]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 yyls yyps->yyls +#define yylsp yyps->yylsp +#define yyerror_range yyps->yyerror_range +]])[#define yystacksize yyps->yystacksize +]])[ /*-------------------------. -| yyparse or yypushparse. | +| yyparse or yypush_parse. | `-------------------------*/ -b4_push_if([ -b4_c_function_def([yypushparse], [void], [[struct yypvars *YYPVARS], [YYPVARS]])],[ +]b4_push_if([ +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]]) #else /* ! YYPARSE_PARAM */ b4_c_function_def([yyparse], [int], b4_parse_param) -#endif]) -{[ - ]b4_pure_if([b4_declare_parser_variables])[ - ]b4_push_if([struct yypvars *pv;])[ - int yystate; +#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; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Lookahead token as an internal (translated) token number. */ - int yytoken = 0; + /* 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]; - char *yymsgbuf_ptr = yymsgbuf; char *yymsg = yymsgbuf; YYSIZE_T yymsg_alloc = sizeof yymsgbuf; #endif - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `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 *yyssa_ptr = yyssa; - yytype_int16 *yyss = yyssa; - yytype_int16 *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - YYSTYPE *yyvsp; - -]b4_locations_if( -[[ /* The location stack. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp; - /* The locations where the error started and ended. */ - YYLTYPE yyerror_range[2]; - YYLTYPE *yyerror_range_ptr = yyerror_range; - ]])[ - #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[) - YYSIZE_T yystacksize = YYINITDEPTH; - - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; -]b4_locations_if([ YYLTYPE yyloc;])[ - /* 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([pv = YYPVARS;])[ - yystate = 0; yyerrstatus = 0; yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ + yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ - yyssp = yyss; yyvsp = yyvs; ]b4_locations_if([[ yylsp = yyls; -]b4_push_if([],[ + #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])[ +#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 @@ -1244,46 +1221,7 @@ m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; ]])dnl m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; ]])dnl -[ ]b4_push_if([ - /* Initialize the locals to the current context. */ - yychar = pv->yychar; - yylval = pv->yylval; - yynerrs = pv->yynerrs; - ]b4_locations_if([ - yylloc = pv->yylloc;])[ - - yystate = pv->yystate; - yyn = pv->yyn; - yyresult = pv->yyresult; - yyerrstatus = pv->yyerrstatus; - yytoken = pv->yytoken; -#if YYERROR_VERBOSE - yymsgbuf_ptr = pv->yymsgbuf_ptr; - yymsg = pv->yymsg;; - yymsg_alloc = pv->yymsg_alloc; -#endif - yyssa_ptr = pv->yyssa_ptr; - yyss = pv->yyss; - yyssp = pv->yyssp; - - yyvs = pv->yyvs; - yyvsp = pv->yyvsp; - - ]b4_locations_if([[ /* The location stack. */ - yyls = pv->yyls; - yylsp = pv->yylsp; - - yyerror_range_ptr = pv->yyerror_range_ptr;]])[ - - yystacksize = pv->yystacksize; - yylen = pv->yylen; - yyval = pv->yyval; - ]b4_locations_if([yyloc = pv->yyloc;])[ - if (pv->yynew == 0) - { - goto gottoken; - } - pv->yynew= 0;])[ +[ goto yysetstate; /*------------------------------------------------------------. @@ -1341,11 +1279,11 @@ m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyexhaustedlab; - YYSTACK_RELOCATE (yyss); - YYSTACK_RELOCATE (yyvs); -]b4_locations_if([ YYSTACK_RELOCATE (yyls);])[ + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +]b4_locations_if([ YYSTACK_RELOCATE (yyls_alloc, yyls);])[ # undef YYSTACK_RELOCATE - if (yyss1 != yyssa_ptr) + if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif @@ -1387,48 +1325,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= 4; - /* Initialize the locals to the current context. */ - pv->yychar = yychar; - pv->yylval = yylval; - pv->yynerrs = yynerrs; - ]b4_locations_if([ - pv->yylloc = yylloc;])[ - - pv->yystate = yystate; - pv->yyn = yyn; - pv->yyresult = yyresult; - pv->yyerrstatus = yyerrstatus; - pv->yytoken = yytoken; -#if YYERROR_VERBOSE - pv->yymsgbuf_ptr = yymsgbuf_ptr; - pv->yymsg = yymsg;; - pv->yymsg_alloc = yymsg_alloc; -#endif - pv->yyssa_ptr = yyssa_ptr; - pv->yyss = yyss; - pv->yyssp = yyssp; - - pv->yyvs = yyvs; - pv->yyvsp = yyvsp; - - ]b4_locations_if([[ /* The location stack. */ - pv->yyls = yyls; - pv->yylsp = yylsp; - pv->yyerror_range_ptr = yyerror_range_ptr;]])[ - - pv->yystacksize = yystacksize; - pv->yylen = yylen; - pv->yyval = yyval; - ]b4_locations_if([pv->yyloc = yyloc;])[ - return; -gottoken: - YYDPRINTF((stderr, "Reading a token: "));],[ - YYDPRINTF ((stderr, "Reading a token: ")); - 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) { @@ -1550,14 +1472,14 @@ yyerrlab: YYSIZE_T yyalloc = 2 * yysize; if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) yyalloc = YYSTACK_ALLOC_MAXIMUM; - if (yymsg != yymsgbuf_ptr) + if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); yymsg = (char *) YYSTACK_ALLOC (yyalloc); if (yymsg) yymsg_alloc = yyalloc; else { - yymsg = yymsgbuf_ptr; + yymsg = yymsgbuf; yymsg_alloc = sizeof yymsgbuf; } } @@ -1661,7 +1583,7 @@ yyerrlab1: yyerror_range[1] = yylloc; /* Using YYLLOC is tempting, but would change the location of the lookahead. YYLOC is available though. */ - YYLLOC_DEFAULT (yyloc, (yyerror_range- 1), 2); + YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); *++yylsp = yyloc;]])[ /* Shift the error token. */ @@ -1710,51 +1632,28 @@ yyreturn: YYPOPSTACK (1); } #ifndef yyoverflow - if (yyss != yyssa_ptr) + if (yyss != yyssa) YYSTACK_FREE (yyss); #endif -#if YYERROR_VERBOSE - if (yymsg != yymsgbuf_ptr) - YYSTACK_FREE (yymsg); -#endif - ]b4_push_if([pv->yyresult = YYID (yyresult);],[ - /* Make sure YYID is used. */ - return YYID (yyresult); - ])[ -]} +]b4_push_if([[ yyps->yynew = 1; -b4_push_if([ -#ifdef 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 -{[ - struct yypvars *ctx = yypvarsinit (); - int status; - do { - yychar_set (ctx, yylex ()); - yylval_set (ctx, yylval); -#ifdef YYLTYPE_IS_TRIVIAL - yylloc_set (ctx, yylloc); +yypushreturn: +]])[#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); #endif - yypushparse (ctx); - status = yyresult_get (ctx); - } while (status == 4); - free (ctx); - return status; -]}]) + /* Make sure YYID is used. */ + return YYID (yyresult); +} -b4_epilogue +]b4_epilogue b4_defines_if( -[@output @output_header_name@ +[@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_start_header], -[[/* Copy the %start-header blocks. */ -]b4_start_header])[]dnl +b4_get_percent_code([[requires]])[]dnl b4_token_enums_defines(b4_tokens) @@ -1771,8 +1670,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 @@ -1788,12 +1686,30 @@ typedef struct YYLTYPE # define YYLTYPE_IS_TRIVIAL 1 #endif -]b4_push_if([struct ]b4_prefix[pvars;])[ -]b4_pure_if([], - [extern YYLTYPE b4_prefix[]lloc;]) +]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]]) )dnl b4_locations_if -m4_ifdef([b4_end_header], -[[/* Copy the %end-header blocks. */ -]b4_end_header])[]dnl +b4_push_if([[#ifndef YYPUSH_DECLS +# define YYPUSH_DECLS +struct ]b4_prefix[pstate; +typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; +enum { YYPUSH_MORE = 4 }; +]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]]])[ +#endif +]]) +b4_get_percent_code([[provides]])[]dnl ])dnl b4_defines_if +m4_divert_pop(0)