X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/bf35c71c5827d735c125ee25b048eabf40960a55..219139f52178b3e020be1952c59b1ba76009c386:/data/yacc.c diff --git a/data/yacc.c b/data/yacc.c index 5ba564e8..1866a66a 100644 --- a/data/yacc.c +++ b/data/yacc.c @@ -1,11 +1,11 @@ -*- C -*- # Yacc compatible skeleton for Bison -# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, -# 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. +# Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, +# Inc. m4_pushdef([b4_copyright_years], - [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010]) + [1984, 1989-1990, 2000-2012]) # 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 @@ -31,18 +31,21 @@ m4_case(b4_percent_define_get([[api.push-pull]]), [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. +# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the +# behavior of Bison 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]])])]) -# Check the value of %define parse.lac, where LAC stands for lookahead -# correction. +# Check the value of %define parse.lac and friends, where LAC stands for +# lookahead correction. b4_percent_define_default([[parse.lac]], [[none]]) -b4_percent_define_default([[parse.lac.es-capacity]], [[20]]) -b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]]) +b4_percent_define_default([[parse.lac.es-capacity-initial]], [[20]]) +b4_percent_define_default([[parse.lac.memory-trace]], [[failures]]) +b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]], + [[[[parse.lac.memory-trace]], + [[failures]], [[full]]]]) b4_define_flag_if([lac]) m4_define([b4_lac_flag], [m4_if(b4_percent_define_get([[parse.lac]]), @@ -73,8 +76,8 @@ m4_define([b4_pure_flag], # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise. m4_define([b4_yacc_pure_if], [b4_pure_if([m4_ifset([b4_parse_param], - [$1], [$2])], - [$2])]) + [$1], [$2])], + [$2])]) # b4_yyerror_args @@ -114,7 +117,7 @@ m4_define([b4_int_type], m4_eval([0 <= $1]), [1], [unsigned int], - [int])]) + [int])]) ## ----------------- ## @@ -217,7 +220,11 @@ m4_define([b4_declare_parser_state_variables], [b4_pure_if([[ /* The locations where the error started and ended. */ YYLTYPE yyerror_range[3];]])[ - YYSIZE_T yystacksize;]]) + YYSIZE_T yystacksize;]b4_lac_if([[ + + yytype_int16 yyesa@{]b4_percent_define_get([[parse.lac.es-capacity-initial]])[@}; + yytype_int16 *yyes; + YYSIZE_T yyes_capacity;]])]) ## --------------------------------------------------------- ## @@ -228,7 +235,7 @@ m4_define([b4_declare_parser_state_variables], [b4_pure_if([[ m4_changecom() m4_divert_push(0)dnl @output(b4_parser_file_name@)@ -b4_copyright([Implementation for Bison's Yacc-like parsers in C])[ +b4_copyright([Bison implementation for Yacc-like parsers in C])[ /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ @@ -411,10 +418,10 @@ typedef short int yytype_int16; } #endif -#if ! defined yyoverflow || YYERROR_VERBOSE +#if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[ -]b4_push_if([], -[[/* The parser invokes alloca or malloc; define the necessary symbols. */ +/* The parser invokes alloca or malloc; define the necessary symbols. */]dnl +b4_push_if([], [b4_lac_if([], [[ # ifdef YYSTACK_USE_ALLOCA # if YYSTACK_USE_ALLOCA @@ -437,10 +444,9 @@ typedef short int yytype_int16; # endif # endif # endif -# endif +# endif]])])[ -]])dnl -[# ifdef YYSTACK_ALLOC +# ifdef YYSTACK_ALLOC /* Pacify GCC's `empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) # ifndef YYSTACK_ALLOC_MAXIMUM @@ -458,7 +464,7 @@ typedef short int yytype_int16; # endif # if (defined __cplusplus && ! defined EXIT_SUCCESS \ && ! ((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) + && (defined YYFREE || defined free))) # include /* INFRINGES ON USER NAME SPACE */ # ifndef EXIT_SUCCESS # define EXIT_SUCCESS 0 @@ -476,14 +482,15 @@ void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif # endif -# endif -#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ +# endif]b4_lac_if([[ +# define YYCOPY_NEEDED 1]])[ +#endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[ #if (! defined yyoverflow \ && (! defined __cplusplus \ - || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ - && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ + && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc @@ -506,6 +513,27 @@ union yyalloc ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + YYSTACK_GAP_MAXIMUM)])[ +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + 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_alloc, Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED /* Copy COUNT objects from FROM to TO. The source and destination do not overlap. */ # ifndef YYCOPY @@ -513,34 +541,17 @@ union yyalloc # define YYCOPY(To, From, Count) \ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) # else -# define YYCOPY(To, From, Count) \ - do \ - { \ - YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ while (YYID (0)) # endif # endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - 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_alloc, Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ - Stack = &yyptr->Stack_alloc; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (YYID (0)) - -#endif +#endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ #define YYFINAL ]b4_final_state_number[ @@ -561,7 +572,7 @@ union yyalloc #define YYUNDEFTOK ]b4_undef_token_number[ #define YYMAXUTOK ]b4_user_token_number_max[ -#define YYTRANSLATE(YYX) \ +#define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM @@ -606,14 +617,14 @@ static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = ]b4_parser_tables_define[ -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) -#define YYEOF 0 +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab /* Like YYERROR except do call yyerror. This remains here temporarily @@ -623,7 +634,7 @@ static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = in Bison 2.4.2's NEWS entry, where a plan to phase it out is discussed. */ -#define YYFAIL goto yyerrlab +#define YYFAIL goto yyerrlab #if defined YYFAIL /* This is here to suppress warnings from the GCC cpp's -Wunused-macros. Normally we don't worry about that warning, but @@ -633,26 +644,26 @@ static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = #define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - YYPOPSTACK (1); \]b4_lac_if([[ - YY_LAC_DISCARD ("YYBACKUP"); \]])[ - goto yybackup; \ - } \ - else \ - { \ +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (1); \]b4_lac_if([[ + YY_LAC_DISCARD ("YYBACKUP"); \]])[ + goto yybackup; \ + } \ + else \ + { \ yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ + YYERROR; \ + } \ while (YYID (0)) -#define YYTERROR 1 -#define YYERRCODE 256 +#define YYTERROR 1 +#define YYERRCODE 256 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. @@ -661,22 +672,22 @@ while (YYID (0)) #define YYRHSLOC(Rhs, K) ((Rhs)[K]) #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ if (YYID (N)) \ - { \ - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = \ - YYRHSLOC (Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = \ - YYRHSLOC (Rhs, 0).last_column; \ - } \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ while (YYID (0)) #endif]b4_locations_if([[ @@ -687,10 +698,10 @@ while (YYID (0)) #ifndef YY_LOCATION_PRINT # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) # else # define YY_LOCATION_PRINT(File, Loc) ((void) 0) # endif @@ -720,21 +731,21 @@ while (YYID (0)) # define YYFPRINTF fprintf # endif -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ } while (YYID (0)) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yy_symbol_print (stderr, \ - Type, Value]b4_locations_if([, Location])[]b4_user_args[); \ - YYFPRINTF (stderr, "\n"); \ - } \ +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value]b4_locations_if([, Location])[]b4_user_args[); \ + YYFPRINTF (stderr, "\n"); \ + } \ } while (YYID (0)) ]b4_yy_symbol_print_generate([b4_c_function_def])[ @@ -745,8 +756,8 @@ do { \ `------------------------------------------------------------------*/ ]b4_c_function_def([yy_stack_print], [static void], - [[yytype_int16 *yybottom], [yybottom]], - [[yytype_int16 *yytop], [yytop]])[ + [[yytype_int16 *yybottom], [yybottom]], + [[yytype_int16 *yytop], [yytop]])[ { YYFPRINTF (stderr, "Stack now"); for (; yybottom <= yytop; yybottom++) @@ -757,10 +768,10 @@ do { \ YYFPRINTF (stderr, "\n"); } -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (yydebug) \ - yy_stack_print ((Bottom), (Top)); \ +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ } while (YYID (0)) @@ -793,9 +804,9 @@ do { \ } } -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (yydebug) \ +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ } while (YYID (0)) @@ -811,7 +822,7 @@ int yydebug; /* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH +#ifndef YYINITDEPTH # define YYINITDEPTH ]b4_stack_depth_init[ #endif @@ -826,6 +837,68 @@ int yydebug; # define YYMAXDEPTH ]b4_stack_depth_max[ #endif]b4_lac_if([[ +/* Given a state stack such that *YYBOTTOM is its bottom, such that + *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty + stack, and such that *YYCAPACITY is the maximum number of elements it + can hold without a reallocation, make sure there is enough room to + store YYADD more elements. If not, allocate a new stack using + YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM, + *YYTOP, and *YYCAPACITY to reflect the new capacity and memory + location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack + using YYSTACK_FREE. Return 0 if successful or if no reallocation is + required. Return 1 if memory is exhausted. */ +static int +yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd, +#if YYDEBUG + char const *yydebug_prefix, + char const *yydebug_suffix, +#endif + yytype_int16 **yybottom, + yytype_int16 *yybottom_no_free, + yytype_int16 **yytop, yytype_int16 *yytop_empty) +{ + YYSIZE_T yysize_old = + *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1; + YYSIZE_T yysize_new = yysize_old + yyadd; + if (*yycapacity < yysize_new) + { + YYSIZE_T yyalloc = 2 * yysize_new; + yytype_int16 *yybottom_new; + /* Use YYMAXDEPTH for maximum stack size given that the stack + should never need to grow larger than the main state stack + needs to grow without LAC. */ + if (YYMAXDEPTH < yysize_new) + { + YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix, + yydebug_suffix)); + return 1; + } + if (YYMAXDEPTH < yyalloc) + yyalloc = YYMAXDEPTH; + yybottom_new = + (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new); + if (!yybottom_new) + { + YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix, + yydebug_suffix)); + return 1; + } + if (*yytop != yytop_empty) + { + YYCOPY (yybottom_new, *yybottom, yysize_old); + *yytop = yybottom_new + (yysize_old - 1); + } + if (*yybottom != yybottom_no_free) + YYSTACK_FREE (*yybottom); + *yybottom = yybottom_new; + *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]), + [full], [[ + YYDPRINTF ((stderr, "%srealloc to %lu%s", yydebug_prefix, + (unsigned long int) yyalloc, yydebug_suffix));]])[ + } + return 0; +} + /* Establish the initial context for the current lookahead if no initial context is currently established. @@ -852,23 +925,23 @@ int yydebug; current lookahead, then check if that lookahead can eventually be shifted if syntactic actions continue from the current context. Report a syntax error if it cannot. */ -#define YY_LAC_ESTABLISH \ -do { \ - if (!yy_lac_established) \ - { \ - YYDPRINTF ((stderr, \ - "LAC: initial context established for %s\n", \ - yytname[yytoken])); \ - yy_lac_established = 1; \ - { \ - int yy_lac_status = \ - yy_lac (yyssp, yytoken); \ - if (yy_lac_status == 2) \ - goto yyexhaustedlab; \ - if (yy_lac_status == 1) \ - goto yyerrlab; \ - } \ - } \ +#define YY_LAC_ESTABLISH \ +do { \ + if (!yy_lac_established) \ + { \ + YYDPRINTF ((stderr, \ + "LAC: initial context established for %s\n", \ + yytname[yytoken])); \ + yy_lac_established = 1; \ + { \ + int yy_lac_status = \ + yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \ + if (yy_lac_status == 2) \ + goto yyexhaustedlab; \ + if (yy_lac_status == 1) \ + goto yyerrlab; \ + } \ + } \ } while (YYID (0)) /* Discard any previous initial lookahead context because of Event, @@ -898,13 +971,18 @@ do { \ #endif /* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can - eventually (after perhaps some reductions) be shifted, and return 1 - if not. Return 2 if memory is exhausted. */ + eventually (after perhaps some reductions) be shifted, return 1 if + not, or return 2 if memory is exhausted. As preconditions and + postconditions: *YYES_CAPACITY is the allocated size of the array to + which *YYES points, and either *YYES = YYESA or *YYES points to an + array allocated with YYSTACK_ALLOC. yy_lac may overwrite the + contents of either array, alter *YYES and *YYES_CAPACITY, and free + any old *YYES other than YYESA. */ static int -yy_lac (yytype_int16 *yyssp, int yytoken) +yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes, + YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken) { yytype_int16 *yyes_prev = yyssp; - yytype_int16 yyes@{]b4_percent_define_get([[parse.lac.es-capacity]])[@}; yytype_int16 *yyesp = yyes_prev; YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken])); if (yytoken == YYUNDEFTOK) @@ -946,7 +1024,7 @@ yy_lac (yytype_int16 *yyssp, int yytoken) YYDPRINTF ((stderr, " R%d", yyrule - 1)); if (yyesp != yyes_prev) { - YYSIZE_T yysize = yyesp - yyes + 1; + YYSIZE_T yysize = yyesp - *yyes + 1; if (yylen < yysize) { yyesp -= yylen; @@ -974,19 +1052,23 @@ yy_lac (yytype_int16 *yyssp, int yytoken) } if (yyesp == yyes_prev) { - yyesp = yyes; + yyesp = *yyes; *yyesp = yystate; } else { - if (yyesp == yyes + (sizeof yyes / sizeof *yyes) - 1) + if (yy_lac_stack_realloc (yyes_capacity, 1, +#if YYDEBUG + " (", ")", +#endif + yyes, yyesa, &yyesp, yyes_prev)) { - YYDPRINTF ((stderr, " (max stack size exceeded)\n")); + YYDPRINTF ((stderr, "\n")); return 2; } *++yyesp = yystate; } - YYDPRINTF ((stderr, " G%d", *yyesp)); + YYDPRINTF ((stderr, " G%d", yystate)); } } }]])[ @@ -1047,27 +1129,27 @@ yytnamerr (char *yyres, const char *yystr) char const *yyp = yystr; for (;;) - switch (*++yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - /* Fall through. */ - default: - if (yyres) - yyres[yyn] = *yyp; - yyn++; - break; - - case '"': - if (yyres) - yyres[yyn] = '\0'; - return yyn; - } + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } do_not_strip_quotes: ; } @@ -1081,7 +1163,7 @@ yytnamerr (char *yyres, const char *yystr) /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message about the unexpected token YYTOKEN for the state stack whose top is YYSSP.]b4_lac_if([[ In order to see if a particular token T is a - valid looakhead, invoke yy_lac (YYSSP, T).]])[ + valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[ Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is not large enough to hold the message. In that case, also set @@ -1090,7 +1172,8 @@ yytnamerr (char *yyres, const char *yystr) yy_lac returned 2]])[. */ static int yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, - yytype_int16 *yyssp, int yytoken) + ]b4_lac_if([[yytype_int16 *yyesa, yytype_int16 **yyes, + YYSIZE_T *yyes_capacity, ]])[yytype_int16 *yyssp, int yytoken) { YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); YYSIZE_T yysize = yysize0; @@ -1156,7 +1239,8 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, if (yyx != YYTERROR && yyx != YYUNDEFTOK) { { - int yy_lac_status = yy_lac (yyssp, yyx); + int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity, + yyssp, yyx); if (yy_lac_status == 2) return 2; if (yy_lac_status == 1) @@ -1321,7 +1405,9 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ stack still needs to be freed. */ if (!yyps->yynew && yyps->yyss != yyps->yyssa) YYSTACK_FREE (yyps->yyss); -#endif +#endif]b4_lac_if([[ + if (!yyps->yynew && yyps->yyes != yyps->yyesa) + YYSTACK_FREE (yyps->yyes);]])[ free (yyps);]b4_pure_if([], [[ yypstate_allocated = 0;]])[ } @@ -1339,7 +1425,10 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ #define yyls yyps->yyls #define yylsp yyps->yylsp #define yyerror_range yyps->yyerror_range]])[ -#define yystacksize yyps->yystacksize +#define yystacksize yyps->yystacksize]b4_lac_if([[ +#define yyesa yyps->yyesa +#define yyes yyps->yyes +#define yyes_capacity yyps->yyes_capacity]])[ /*---------------. @@ -1405,7 +1494,12 @@ b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ yyss = yyssa; yyvs = yyvsa;]b4_locations_if([[ yyls = yylsa;]])[ - yystacksize = YYINITDEPTH; + yystacksize = YYINITDEPTH;]b4_lac_if([[ + + yyes = yyesa; + yyes_capacity = sizeof yyesa / sizeof *yyes; + if (YYMAXDEPTH < yyes_capacity) + yyes_capacity = YYMAXDEPTH;]])[ YYDPRINTF ((stderr, "Starting parse\n")); @@ -1458,26 +1552,26 @@ m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; #ifdef yyoverflow { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE *yyvs1 = yyvs; - yytype_int16 *yyss1 = yyss;]b4_locations_if([ - YYLTYPE *yyls1 = yyls;])[ - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([ - &yyls1, yysize * sizeof (*yylsp),])[ - &yystacksize); + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss;]b4_locations_if([ + YYLTYPE *yyls1 = yyls;])[ + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([ + &yyls1, yysize * sizeof (*yylsp),])[ + &yystacksize); ]b4_locations_if([ - yyls = yyls1;])[ - yyss = yyss1; - yyvs = yyvs1; + yyls = yyls1;])[ + yyss = yyss1; + yyvs = yyvs1; } #else /* no yyoverflow */ # ifndef YYSTACK_RELOCATE @@ -1485,23 +1579,23 @@ m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; # else /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) - goto yyexhaustedlab; + goto yyexhaustedlab; yystacksize *= 2; if (YYMAXDEPTH < yystacksize) - yystacksize = YYMAXDEPTH; + yystacksize = YYMAXDEPTH; { - yytype_int16 *yyss1 = yyss; - union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); - if (! yyptr) - goto yyexhaustedlab; - YYSTACK_RELOCATE (yyss_alloc, yyss); - YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([ - YYSTACK_RELOCATE (yyls_alloc, yyls);])[ + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([ + YYSTACK_RELOCATE (yyls_alloc, yyls);])[ # undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); } # endif #endif /* no yyoverflow */ @@ -1511,10 +1605,10 @@ m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; yylsp = yyls + yysize - 1;])[ YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); + (unsigned long int) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) - YYABORT; + YYABORT; } YYDPRINTF ((stderr, "Entering state %d\n", yystate)); @@ -1709,8 +1803,9 @@ yyerrlab: #if ! YYERROR_VERBOSE yyerror (]b4_yyerror_args[YY_("syntax error")); #else -# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, yyssp, \ - yytoken) +# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[ + yyesa, &yyes, &yyes_capacity, \]])[ + yyssp, yytoken) { char const *yymsgp = YY_("syntax error"); int yysyntax_error_status;]b4_lac_if([[ @@ -1749,20 +1844,20 @@ yyerrlab: if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an - error, discard it. */ + error, discard it. */ if (yychar <= YYEOF) - { - /* Return failure if at end of input. */ - if (yychar == YYEOF) - YYABORT; - } + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } else - { - yydestruct ("Error: discarding", - yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); - yychar = YYEMPTY; - } + { + yydestruct ("Error: discarding", + yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); + yychar = YYEMPTY; + } } /* Else will try to reuse lookahead token after shifting the error @@ -1795,29 +1890,29 @@ yyerrorlab: | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ + yyerrstatus = 3; /* Each real token shifted decrements this. */ for (;;) { yyn = yypact[yystate]; if (!yypact_value_is_default (yyn)) - { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } /* Pop the current state because it cannot handle the error token. */ if (yyssp == yyss) - YYABORT; + YYABORT; ]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[ yydestruct ("Error: popping", - yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); YYPOPSTACK (1); yystate = *yyssp; YY_STACK_PRINT (yyss, yyssp); @@ -1882,13 +1977,15 @@ yyreturn: while (yyssp != yyss) { yydestruct ("Cleanup: popping", - yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); + yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); YYPOPSTACK (1); } #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); -#endif]b4_push_if([[ +#endif]b4_lac_if([[ + if (yyes != yyesa) + YYSTACK_FREE (yyes);]])b4_push_if([[ yyps->yynew = 1; yypushreturn:]])[ @@ -1903,7 +2000,7 @@ yypushreturn:]])[ ]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([Bison interface for Yacc-like parsers in C])dnl b4_percent_code_get([[requires]])[]dnl