X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/60aa04a236004d3d03f00aeaf07b643a52ef0760..57597927ef1b9cc751df4314764a6edd575ffc8b:/data/glr.c?ds=inline diff --git a/data/glr.c b/data/glr.c index 37cf1a4a..7ab38235 100644 --- a/data/glr.c +++ b/data/glr.c @@ -2,7 +2,7 @@ # GLR skeleton for Bison -# Copyright (C) 2002-2012 Free Software Foundation, Inc. +# Copyright (C) 2002-2013 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 @@ -52,17 +52,7 @@ m4_ifndef([b4_pure_flag], # 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))) +[m4_ifset([b4_parse_param], [, b4_formals(b4_parse_param)])]) # b4_yyerror_args @@ -71,7 +61,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))) # 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), ])]) +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) # b4_lyyerror_args @@ -79,7 +69,7 @@ m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) # 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), ])]) +m4_ifset([b4_parse_param], [b4_args(b4_parse_param), ])]) # b4_pure_args @@ -172,28 +162,26 @@ m4_define([b4_rhs_location], # b4_shared_declarations # ---------------------- # Declaration that might either go into the header (if --defines) -# or open coded in the parser body. -m4_define([b4_shared_declarations], +# or open coded in the parser body. glr.cc has its own definition. +m4_if(b4_skeleton, ["glr.c"], +[m4_define([b4_shared_declarations], [b4_declare_yydebug[ ]b4_percent_code_get([[requires]])[ -]b4_token_enums(b4_tokens)[ +]b4_token_enums[ ]b4_declare_yylstype[ -]b4_c_ansi_function_decl(b4_prefix[parse], [int], b4_parse_param)[ +]b4_function_declare(b4_prefix[parse], [int], b4_parse_param)[ ]b4_percent_code_get([[provides]])[]dnl ]) - +]) ## -------------- ## ## Output files. ## ## -------------- ## -# We do want M4 expansion after # for CPP macros. -m4_changecom() -m4_divert_push(0)dnl -@output(b4_parser_file_name@)@ +b4_output_begin([b4_parser_file_name]) b4_copyright([Skeleton implementation for Bison GLR parsers in C], - [2002-2012]) -[ + [2002-2013])[ + /* C GLR parser skeleton written by Paul Hilfinger. */ ]b4_identification @@ -208,19 +196,20 @@ b4_percent_code_get([[top]])[ #define yyparse ]b4_prefix[parse #define yylex ]b4_prefix[lex #define yyerror ]b4_prefix[error +#define yydebug ]b4_prefix[debug +]]b4_pure_if([], [[ #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]])])[ +#define yylloc ]b4_prefix[lloc]])]))[ -/* Copy the first part of user declarations. */ +/* First part of user declarations. */ ]b4_user_pre_prologue[ ]b4_null_define[ ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], - [b4_shared_declarations])[ + [b4_shared_declarations])[ /* Enabling verbose error messages. */ #ifdef YYERROR_VERBOSE @@ -231,11 +220,11 @@ b4_percent_code_get([[top]])[ #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; + 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;]b4_locations_if([[ +static YYLTYPE yyloc_default][]b4_yyloc_default;])[ /* Copy the second part of user declarations. */ ]b4_user_post_prologue @@ -249,29 +238,19 @@ b4_percent_code_get[]dnl # if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include /* INFRINGES ON USER NAME SPACE */ -# define YY_(msgid) dgettext ("bison-runtime", msgid) +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) # endif # endif # ifndef YY_ -# define YY_(msgid) msgid +# 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) +#ifdef __GNUC__ +# define YYUSE(E) ((void) (E)) #else -]b4_c_function_def([YYID], [static int], [[int i], [i]])[ -{ - return i; -} +# define YYUSE(E) /* empty */ #endif #ifndef YYFREE @@ -297,8 +276,9 @@ b4_percent_code_get[]dnl #ifndef YYSETJMP # include # define YYJMP_BUF jmp_buf -# define YYSETJMP(env) setjmp (env) -# define YYLONGJMP(env, val) longjmp (env, val) +# define YYSETJMP(Env) setjmp (Env) +/* Pacify clang. */ +# define YYLONGJMP(Env, Val) (longjmp (Env, Val), YYASSERT (0)) #endif /*-----------------. @@ -313,15 +293,8 @@ b4_percent_code_get[]dnl # 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))) +# define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0))) #endif /* YYFINAL -- State number of the termination state. */ @@ -409,42 +382,20 @@ static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = /* 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 pointers onto yyconfl are taken, whose type is "short int *". dnl We probably ought to introduce a type for confl. [static const short int yyconfl[] = { ]b4_conflicting_rules[ }; - + /* Error token number */ #define YYTERROR 1 ]b4_locations_if([[ -#ifndef YYLLOC_DEFAULT ]b4_yylloc_default_define[ # define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) - -/* 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( [ @@ -477,7 +428,7 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; YYRESULTTAG yychk_flag = YYE; \ if (yychk_flag != yyok) \ return yychk_flag; \ - } while (YYID (0)) + } while (0) #if ]b4_api_PREFIX[DEBUG @@ -485,13 +436,15 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; # define YYFPRINTF fprintf # endif +]b4_yy_location_print_define[ + # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ - } while (YYID (0)) + } while (0) -]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[ +]b4_yy_symbol_print_define[ # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ do { \ @@ -501,12 +454,18 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \ YYFPRINTF (stderr, "\n"); \ } \ - } while (YYID (0)) + } while (0) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; +struct yyGLRStack; +static void yypstack (struct yyGLRStack* yystackp, size_t yyk) + __attribute__ ((__unused__)); +static void yypdumpstack (struct yyGLRStack* yystackp) + __attribute__ ((__unused__)); + #else /* !]b4_api_PREFIX[DEBUG */ # define YYDPRINTF(Args) @@ -546,13 +505,13 @@ int yydebug; do { \ if (Yystack->yyspaceLeft < YYHEADROOM) \ yyexpandGLRStack (Yystack); \ - } while (YYID (0)) + } while (0) #else # define YY_RESERVE_GLRSTACK(Yystack) \ do { \ if (Yystack->yyspaceLeft < YYHEADROOM) \ yyMemoryExhausted (Yystack); \ - } while (YYID (0)) + } while (0) #endif @@ -804,8 +763,8 @@ yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) * 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, +static YYRESULTTAG +yyuserAction (yyRuleNum yyn, size_t yyrhslen, yyGLRStackItem* yyvsp, yyGLRStack* yystackp, YYSTYPE* yyvalp]b4_locuser_formals[) { @@ -813,7 +772,8 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, (yystackp->yysplitPoint == YY_NULL); int yylow; ]b4_parse_param_use([yyvalp], [yylocp])dnl -[# undef yyerrok +[ YYUSE (yyrhslen); +# undef yyerrok # define yyerrok (yystackp->yyerrState = 0) # undef YYACCEPT # define YYACCEPT return yyaccept @@ -855,9 +815,9 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, # undef yyclearin # undef YYRECOVERING } - -/*ARGSUSED*/ static void + +static void yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) { YYUSE (yy0); @@ -865,14 +825,14 @@ yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) switch (yyn) { - ]b4_mergers[ +]b4_mergers[ default: break; } } /* Bison grammar-table manipulation. */ -]b4_yydestruct_generate([b4_c_ansi_function_def])[ +]b4_yydestruct_define[ /** Number of symbols composing the right hand side of rule #RULE. */ static inline int @@ -922,8 +882,8 @@ yylhsNonterm (yyRuleNum yyrule) return yyr1[yyrule]; } -#define yypact_value_is_default(yystate) \ - ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[ +#define yypact_value_is_default(Yystate) \ + ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[ /** True iff LR state YYSTATE has only a default reduction (regardless * of token). */ @@ -940,8 +900,8 @@ yydefaultAction (yyStateNum yystate) return yydefact[yystate]; } -#define yytable_value_is_error(yytable_value) \ - ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[ +#define yytable_value_is_error(Yytable_value) \ + ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[ /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. * Result R means @@ -1277,13 +1237,13 @@ yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, do { \ if (yydebug) \ yy_reduce_print Args; \ -} while (YYID (0)) +} while (0) /*----------------------------------------------------------------------. | Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. | `----------------------------------------------------------------------*/ -/*ARGSUSED*/ static inline void +static inline void yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk, yyRuleNum yyrule]b4_user_formals[) { @@ -1533,7 +1493,7 @@ yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) { yySemanticOption** yyz0p = &yys0->yysemantics.yyfirstVal; yySemanticOption* yyz1 = yys1->yysemantics.yyfirstVal; - while (YYID (yytrue)) + while (yytrue) { if (yyz1 == *yyz0p || yyz1 == YY_NULL) break; @@ -1694,7 +1654,7 @@ yyreportTree (yySemanticOption* yyx, int yyindent) } #endif -/*ARGSUSED*/ static YYRESULTTAG +static YYRESULTTAG yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1]b4_pure_formals[) { @@ -1955,7 +1915,7 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; + yychar = ]b4_lex[; } if (yychar <= YYEOF) @@ -2025,7 +1985,7 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, return yyok; } -/*ARGSUSED*/ static void +static void yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) { if (yystackp->yyerrState != 0) @@ -2033,10 +1993,10 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) #if ! YYERROR_VERBOSE yyerror (]b4_lyyerror_args[YY_("syntax error")); #else + { yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); size_t yysize0 = yytnamerr (YY_NULL, yytokenName (yytoken)); size_t yysize = yysize0; - size_t yysize1; yybool yysize_overflow = yyfalse; char* yymsg = YY_NULL; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; @@ -2096,9 +2056,11 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) break; } yyarg[yycount++] = yytokenName (yyx); - yysize1 = yysize + yytnamerr (YY_NULL, yytokenName (yyx)); - yysize_overflow |= yysize1 < yysize; - yysize = yysize1; + { + size_t yysz = yysize + yytnamerr (YY_NULL, yytokenName (yyx)); + yysize_overflow |= yysz < yysize; + yysize = yysz; + } } } } @@ -2118,9 +2080,11 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) #undef YYCASE_ } - yysize1 = yysize + strlen (yyformat); - yysize_overflow |= yysize1 < yysize; - yysize = yysize1; + { + size_t yysz = yysize + strlen (yyformat); + yysize_overflow |= yysz < yysize; + yysize = yysz; + } if (!yysize_overflow) yymsg = (char *) YYMALLOC (yysize); @@ -2150,6 +2114,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) yyerror (]b4_lyyerror_args[YY_("syntax error")); yyMemoryExhausted (yystackp); } + } #endif /* YYERROR_VERBOSE */ yynerrs += 1; } @@ -2157,7 +2122,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) /* 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 +static void yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) { size_t yyk; @@ -2166,7 +2131,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) if (yystackp->yyerrState == 3) /* We just shifted the error token and (perhaps) took some reductions. Skip tokens until we can proceed. */ - while (YYID (yytrue)) + while (yytrue) { yySymbol yytoken; if (yychar == YYEOF) @@ -2185,7 +2150,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) yytoken, &yylval]b4_locuser_args([&yylloc])[); } YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; + yychar = ]b4_lex[; if (yychar <= YYEOF) { yychar = yytoken = YYEOF; @@ -2270,13 +2235,13 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) default: \ goto yybuglab; \ } \ - } while (YYID (0)) + } while (0) /*----------. | yyparse. | `----------*/ -]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[ +]b4_function_define([yyparse], [int], b4_parse_param)[ { int yyresult; yyGLRStack yystack; @@ -2286,20 +2251,13 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) YYDPRINTF ((stderr, "Starting parse\n")); yychar = YYEMPTY; - yylval = yyval_default; -]b4_locations_if([ -#if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_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 + yylval = yyval_default;]b4_locations_if([ + yylloc = yyloc_default;])[ +]m4_ifdef([b4_initial_action], [ +b4_dollar_pushdef([yylval], [], [yylloc])dnl /* User initialization code. */ b4_user_initial_action -m4_popdef([b4_dollar_dollar])dnl -m4_popdef([b4_at_dollar])])dnl +b4_dollar_popdef])[]dnl [ if (! yyinitGLRStack (yystackp, YYINITDEPTH)) goto yyexhaustedlab; @@ -2313,13 +2271,13 @@ m4_popdef([b4_at_dollar])])dnl yyglrShift (&yystack, 0, 0, 0, &yylval]b4_locations_if([, &yylloc])[); yyposn = 0; - while (YYID (yytrue)) + while (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)) + while (yytrue) { yyRuleNum yyrule; int yyaction; @@ -2346,7 +2304,7 @@ m4_popdef([b4_at_dollar])])dnl if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; + yychar = ]b4_lex[; } if (yychar <= YYEOF) @@ -2383,7 +2341,7 @@ m4_popdef([b4_at_dollar])])dnl } } - while (YYID (yytrue)) + while (yytrue) { yySymbol yytoken_to_shift; size_t yys; @@ -2515,16 +2473,11 @@ m4_popdef([b4_at_dollar])])dnl yyfreeGLRStack (&yystack); } - /* Make sure YYID is used. */ - return YYID (yyresult); + return yyresult; } /* DEBUGGING ONLY */ #if ]b4_api_PREFIX[DEBUG -static void yypstack (yyGLRStack* yystackp, size_t yyk) - __attribute__ ((__unused__)); -static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__)); - static void yy_yypstack (yyGLRState* yys) { @@ -2593,18 +2546,35 @@ yypdumpstack (yyGLRStack* yystackp) YYFPRINTF (stderr, "\n"); } #endif + +#undef yylval +#undef yychar +#undef yynerrs]b4_locations_if([ +#undef yylloc]) + +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]b4_locations_if([[ +#define yylloc ]b4_prefix[lloc]])])[ + ]b4_epilogue[]dnl -dnl -dnl glr.cc produces its own header. -dnl +b4_output_end() + +# glr.cc produces its own header. m4_if(b4_skeleton, ["glr.c"], [b4_defines_if( -[@output(b4_spec_defines_file@)@ +[b4_output_begin([b4_spec_defines_file]) b4_copyright([Skeleton interface for Bison GLR parsers in C], - [2002-2012])[ + [2002-2013])[ ]b4_cpp_guard_open([b4_spec_defines_file])[ ]b4_shared_declarations[ ]b4_cpp_guard_close([b4_spec_defines_file])[ -]])]) -m4_divert_pop(0) +]b4_output_end() +])])