X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/bd9d212b13d6ba9678bd55048bd8f5b55fa37e72..8646b6a3fdd5991346314c57257dc8e855e12b2a:/data/push.c?ds=sidebyside diff --git a/data/push.c b/data/push.c index 87a02e78..51d75890 100644 --- a/data/push.c +++ b/data/push.c @@ -151,10 +151,11 @@ b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl ' ]b4_identification m4_if(b4_prefix, [yy], [], [/* Substitute the variable and function names. */ -#define yyparse b4_prefix[]parse ]b4_push_if([#define yypush_parse b4_prefix[]push_parse -#define yypstate_init b4_prefix[]pstate_init -#define yypstate b4_prefix[]pstate])[ +#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 @@ -216,6 +217,22 @@ typedef struct YYLTYPE # define YYLTYPE_IS_TRIVIAL 1 #endif]) +b4_push_if([[#ifndef YYPUSH_DECLS +# define YYPUSH_DECLS +struct yypstate; +typedef struct yypstate yypstate; +enum { YYPUSH_MORE = 4 }; +]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 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]))[ +#endif +]]) m4_ifdef([b4_provides], [[/* Copy the %provides blocks. */ ]b4_user_provides])[]dnl @@ -372,9 +389,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 [}; @@ -414,12 +431,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); \ } \ @@ -705,7 +722,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; @@ -956,35 +973,23 @@ 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 yypstate; -enum { YYPUSH_MORE = 4 }; -]b4_c_function_decl([yypstate_init], [struct yypstate *], [[void], []])[ -]b4_c_function_decl([yypush_parse], [int], - [[struct yypstate *yyps], [yyps]], - [[int yynchar], [yynchar]], - [[YYSTYPE *yynlval], [yynlval]] - b4_locations_if([,[[YYLTYPE *yynlloc], [yynlloc]]]))[ -])[ - -]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. */ @@ -992,20 +997,19 @@ YYSTYPE yylval; /* Number of syntax errors so far. */ ]b4_push_if([],[ -int yynerrs;])[b4_locations_if([ +int yynerrs;])b4_locations_if([[ /* Location data for the lookahead symbol. */ -YYLTYPE yylloc;]) +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])) -# b4_declare_yyparse_variables -# ---------------------------- -# Declare all the variables that are needed local to YYPARSE -m4_define([b4_declare_yyparse_variables], -[[struct yypstate - { +# 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], +[[ int yystate; int yyn; int yyresult; @@ -1030,78 +1034,87 @@ m4_define([b4_declare_yyparse_variables], /* 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[2];]])[ YYSIZE_T yystacksize; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; +]b4_locations_if([[ YYLTYPE yyloc; +]])]) + +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[ /* Used to determine if this is the first time this instance has been used. */ - int yynew;]b4_locations_if([YYLTYPE yyloc;])[ + int yynew; }; /* Initialize the parser data structure. */ -struct yypstate* -yypstate_init (void) +]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ { - struct yypstate *yyps = (struct yypstate *) malloc (sizeof *yyps); - yyps->yystate = 0; + yypstate *yyps = (yypstate *) malloc (sizeof *yyps); 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; - - yyps->yyssp = yyps->yyss; - yyps->yyvsp = yyps->yyvs; - yyps->yynew = 1; - -]b4_locations_if([ yyps->yylsp = yyps->yyls;])[ - return yyps; -}]) -m4_divert_pop([KILL])dnl# ====================== End of M4 code. +} -b4_push_if([],[b4_pure_if([], - [b4_declare_parser_variables])]) +]b4_c_function_def([[yypstate_delete]], [[void]], + [[[yypstate *yyps]], [[yyps]]])[ +{ + free (yyps); +} -b4_push_if([b4_declare_yyparse_variables]) +#define yystate yyps->yystate +#define yyn yyps->yyn +#define yyresult yyps->yyresult +#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 yylsa yyps->yylsa +#define yyls yyps->yyls +#define yylsp yyps->yylsp +]])[#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], [[struct yypstate *yyps], [yyps]], - [[int yynchar], [yynchar]], [[YYSTYPE *yynlval], [yynlval]] - b4_locations_if([,[[YYLTYPE *yynlloc], [yynlloc]]]))],[ +]b4_push_if([ +b4_c_function_def([[yypush_parse]], [[int]], [[[yypstate *yyps]], [[yyps]]], + [[[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([b4_declare_parser_variables])[ - int yystate; - 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; +#endif])[ +{ + ]b4_pure_if([b4_declare_scanner_communication_variables]) + b4_push_if([], [b4_declare_parser_state_variables])[ + #if YYERROR_VERBOSE /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; @@ -1109,76 +1122,47 @@ b4_c_function_def([yyparse], [int], b4_parse_param) 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 *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. */ - ]b4_push_if([],[YYLTYPE yyerror_range[[2]]])[; - ]])[ - #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) + goto yyread_pushed_token; +]])[ + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; +]b4_locations_if([[ yyls = yylsa; +]])[ + yystacksize = YYINITDEPTH; YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; -]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([], [[ yynerrs = 0;]])[ + 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 @@ -1186,32 +1170,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. */ - yystate = yyps->yystate; - yyn = yyps->yyn; - yyresult = yyps->yyresult; - yyerrstatus = yyps->yyerrstatus; - yytoken = yyps->yytoken; - - yyss = yyps->yyss; - yyssp = yyps->yyssp; - - yyvs = yyps->yyvs; - yyvsp = yyps->yyvsp; - - ]b4_locations_if([[ /* The location stack. */ - yyls = yyps->yyls; - yylsp = yyps->yylsp;]])[ - - yystacksize = yyps->yystacksize; - yyval = yyps->yyval; - ]b4_locations_if([yyloc = yyps->yyloc;])[ - if (yyps->yynew == 0) - { - goto gottoken; - } - yyps->yynew= 0;])[ +[ goto yysetstate; /*------------------------------------------------------------. @@ -1269,11 +1228,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 != ]b4_yyssa[) + if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif @@ -1315,33 +1274,23 @@ 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; - /* Initialize the locals to the current context. */ - yyps->yystate = yystate; - yyps->yyn = yyn; - yyps->yyerrstatus = yyerrstatus; - yyps->yytoken = yytoken; - - yyps->yyss = yyss; - yyps->yyssp = yyssp; - - yyps->yyvs = yyvs; - yyps->yyvsp = yyvsp; - - ]b4_locations_if([[ /* The location stack. */ - yyps->yyls = yyls; - yyps->yylsp = yylsp;]])[ - - yyps->yystacksize = yystacksize; - yyps->yyval = yyval; - ]b4_locations_if([yyps->yyloc = yyloc;])[ - goto yypushreturn; -gottoken:])[ - YYDPRINTF ((stderr, "Reading a token: ")); - ]b4_push_if([], [yychar = YYLEX;])[ - } +]b4_push_if([[ if (!yyps->yynew) + { + YYDPRINTF ((stderr, "Return for a new token:\n")); + yyresult = YYPUSH_MORE; + goto yypushreturn; + } + yyps->yynew = 0; + +yyread_pushed_token: +]])[ YYDPRINTF ((stderr, "Reading a token: ")); +]b4_push_if([[ yychar = yypushed_char; + if (yypushed_val) + yylval = *yypushed_val; +]b4_locations_if([[ if (yypushed_loc) + yylloc = *yypushed_loc;]])], +[[ yychar = YYLEX; +]])[ } if (yychar <= YYEOF) { @@ -1623,7 +1572,7 @@ yyreturn: YYPOPSTACK (1); } #ifndef yyoverflow - if (yyss != ]b4_yyssa[) + if (yyss != yyssa) YYSTACK_FREE (yyss); #endif ]b4_push_if([yypushreturn:])[ @@ -1631,7 +1580,6 @@ yyreturn: if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); #endif - ]b4_push_if([yyps->yyresult = YYID (yyresult);])[ /* Make sure YYID is used. */ return YYID (yyresult); ]} @@ -1678,18 +1626,27 @@ typedef struct YYLTYPE # define YYLTYPE_IS_TRIVIAL 1 #endif -]b4_push_if([struct ]b4_prefix[pstate; -]b4_c_function_decl([]b4_prefix[pstate_init], [struct ]b4_prefix[pstate *], [[void], []])[ -]b4_c_function_decl([]b4_prefix[push_parse], [int], - [[struct ]b4_prefix[pstate *]b4_prefix[pstate], []b4_prefix[pstate]], - [[int yynchar], [yynchar]], - [[YYSTYPE *yynlval], [yynlval]] - b4_locations_if([,[[YYLTYPE *yynlloc], [yynlloc]]]))[ -enum { YYPUSH_MORE = 4 };])[ ]b4_pure_if([], [extern YYLTYPE b4_prefix[]lloc;]) )dnl b4_locations_if +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_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 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]))[ +#endif +]]) m4_ifdef([b4_provides], [[/* Copy the %provides blocks. */ ]b4_user_provides])[]