X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/9ca7f077a0a5ecdd00c5945c7a7bd3cf46e23c13..07a6e87d46f32a8248c2160ddd2345333f1c84b4:/data/yacc.c?ds=sidebyside diff --git a/data/yacc.c b/data/yacc.c index 7e94146e..6a547fce 100644 --- a/data/yacc.c +++ b/data/yacc.c @@ -1,10 +1,12 @@ -*- C -*- - # Yacc compatible skeleton for Bison # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, # 2007, 2008 Free Software Foundation, Inc. +m4_pushdef([b4_copyright_years], +[1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008]) + # 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 3 of the License, or @@ -114,7 +116,7 @@ m4_define([b4_int_type], # -------------------- # Expansion of $$. m4_define([b4_lhs_value], -[(yyval[]m4_ifval([$1], [.$1]))]) +[b4_symbol_value(yyval, [$1])]) # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) @@ -122,7 +124,7 @@ m4_define([b4_lhs_value], # Expansion of $NUM, where the current rule has RULE-LENGTH # symbols on RHS. m4_define([b4_rhs_value], -[(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))]) + [b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3])]) @@ -142,7 +144,7 @@ m4_define([b4_lhs_location], # Expansion of @NUM, where the current rule has RULE-LENGTH symbols # on RHS. m4_define([b4_rhs_location], -[(yylsp@{($2) - ($1)@})]) + [(yylsp@{b4_subtract([$2], [$1])@})]) @@ -153,9 +155,9 @@ m4_define([b4_rhs_location], # We do want M4 expansion after # for CPP macros. m4_changecom() 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])[ +@output(b4_parser_file_name@)@ +b4_copyright([Implementation for Bison's Yacc-like parsers in C])dnl' +[ /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ @@ -480,41 +482,27 @@ union yyalloc #define YYNNTS ]b4_nterms_number[ /* YYNRULES -- Number of rules. */ #define YYNRULES ]b4_rules_number[ -/* YYNRULES -- Number of states. */ +/* YYNSTATES -- Number of states. */ #define YYNSTATES ]b4_states_number[ -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned + by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK ]b4_undef_token_number[ #define YYMAXUTOK ]b4_user_token_number_max[ #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, without out-of-bounds checking. */ static const ]b4_int_type_for([b4_translate])[ yytranslate[] = { ]b4_translate[ }; #if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = -{ - ]b4_prhs[ -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = -{ - ]b4_rhs[ -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const ]b4_int_type_for([b4_rline])[ yyrline[] = -{ - ]b4_rline[ -}; +]b4_integral_parser_table_define([rline], [b4_rline], + [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[ #endif #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE @@ -527,75 +515,19 @@ static const char *const yytname[] = #endif # ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ +/* YYTOKNUM[NUM] -- (External) token number corresponding to the + (internal) symbol number NUM (which must be that of a token). */ static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = { ]b4_toknum[ }; # endif -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const ]b4_int_type_for([b4_r1])[ yyr1[] = -{ - ]b4_r1[ -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const ]b4_int_type_for([b4_r2])[ yyr2[] = -{ - ]b4_r2[ -}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const ]b4_int_type_for([b4_defact])[ yydefact[] = -{ - ]b4_defact[ -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = -{ - ]b4_defgoto[ -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ #define YYPACT_NINF ]b4_pact_ninf[ -static const ]b4_int_type_for([b4_pact])[ yypact[] = -{ - ]b4_pact[ -}; -/* YYPGOTO[NTERM-NUM]. */ -static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = -{ - ]b4_pgoto[ -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ #define YYTABLE_NINF ]b4_table_ninf[ -static const ]b4_int_type_for([b4_table])[ yytable[] = -{ - ]b4_table[ -}; - -static const ]b4_int_type_for([b4_check])[ yycheck[] = -{ - ]b4_check[ -}; -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const ]b4_int_type_for([b4_stos])[ yystos[] = -{ - ]b4_stos[ -}; +]b4_parser_tables_define[ #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) @@ -744,24 +676,26 @@ do { \ `------------------------------------------------*/ ]b4_c_function_def([yy_reduce_print], [static void], - [[YYSTYPE *yyvsp], [yyvsp]], + [[yytype_int16 *yyssp], [yyssp]], + [[YYSTYPE *yyvsp], [yyvsp]], b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], - ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, - b4_parse_param]))[ + ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, + b4_parse_param]))[ { + unsigned long int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; - unsigned long int yylno = yyrline[yyrule]; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", - yyrule - 1, yylno); + yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { 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[); + yy_symbol_print (stderr, + yystos[yyssp[yyi + 1 - yynrhs]], + &]b4_rhs_value(yynrhs, yyi + 1)[ + ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl + b4_user_args[); YYFPRINTF (stderr, "\n"); } } @@ -769,7 +703,7 @@ do { \ # define YY_REDUCE_PRINT(Rule) \ do { \ if (yydebug) \ - yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ + yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ } while (YYID (0)) /* Nonzero means print parse trace. It is left uninitialized so that @@ -888,14 +822,14 @@ yytnamerr (char *yyres, const char *yystr) # endif /* Copy into YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, + YYTOKEN while in state YYSTATE. Return the number of bytes copied, including the terminating null byte. If YYRESULT is null, do not copy anything; just return the number of bytes that would be copied. As a special case, return 0 if an ordinary "syntax error" message will do. Return YYSIZE_MAXIMUM if overflow occurs during size calculation. */ static YYSIZE_T -yysyntax_error (char *yyresult, int yystate, int yychar) +yysyntax_error (char *yyresult, int yystate, int yytoken) { int yyn = yypact[yystate]; @@ -903,34 +837,15 @@ yysyntax_error (char *yyresult, int yystate, int yychar) return 0; else { - int yytype = YYTRANSLATE (yychar); - YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]); YYSIZE_T yysize = yysize0; YYSIZE_T yysize1; int yysize_overflow = 0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + /* Internationalized format string. */ + const char *yyformat = 0; + /* Arguments of yyformat. */ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - -# if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -# endif - char *yyfmt; - char const *yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected - + sizeof yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof yyor - 1))]; - char const *yyprefix = yyexpecting; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ @@ -939,10 +854,12 @@ yysyntax_error (char *yyresult, int yystate, int yychar) /* Stay within bounds of both yycheck and yytname. */ int yychecklim = YYLAST - yyn + 1; int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yycount = 1; + /* Number of reported tokens (one for the "unexpected", one per + "expected"). */ + int yycount = 0; + int yyx; - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy (yyformat, yyunexpected); + yyarg[yycount++] = yytname[yytoken]; for (yyx = yyxbegin; yyx < yyxend; ++yyx) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) @@ -951,19 +868,29 @@ yysyntax_error (char *yyresult, int yystate, int yychar) { yycount = 1; yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; break; } yyarg[yycount++] = yytname[yyx]; yysize1 = yysize + yytnamerr (0, yytname[yyx]); yysize_overflow |= (yysize1 < yysize); yysize = yysize1; - yyfmt = yystpcpy (yyfmt, yyprefix); - yyprefix = yyor; } - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen (yyf); + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + yysize1 = yysize + yystrlen (yyformat); yysize_overflow |= (yysize1 < yysize); yysize = yysize1; @@ -977,19 +904,17 @@ yysyntax_error (char *yyresult, int yystate, int yychar) produced a string with the wrong number of "%s"s. */ char *yyp = yyresult; int yyi = 0; - while ((*yyp = *yyf) != '\0') - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyformat += 2; + } + else + { + yyp++; + yyformat++; + } } return yysize; } @@ -1079,26 +1004,25 @@ b4_push_if( /* Used to determine if this is the first time this instance has been used. */ int yynew; - }; + };]b4_pure_if([], [[ -]b4_pull_if([b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ +static char yypstate_allocated = 0;]])b4_pull_if([ + +b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ { return yypull_parse (0]m4_ifset([b4_parse_param], [[, ]b4_c_args(b4_parse_param)])[); -}]b4_pure_if([], [[ - -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; -]])])[ + yypstate *yyps_local;]b4_pure_if([[ + int yychar; + YYSTYPE yylval;]b4_locations_if([[ + YYLTYPE yylloc;]])])[ if (yyps == 0) { yyps_local = yypstate_new (); @@ -1120,17 +1044,14 @@ static char yypstate_allocated = 0;]])[ 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; - }]])[ + return 0;]])[ yyps = (yypstate *) malloc (sizeof *yyps); if (!yyps) return 0; @@ -1195,9 +1116,9 @@ b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar; int yytoken; /* The variables used to return semantic value and location from the action routines. */ - YYSTYPE yyval; -]b4_locations_if([[ YYLTYPE yyloc; -]])[ + YYSTYPE yyval;]b4_locations_if([[ + YYLTYPE yyloc;]])[ + #if YYERROR_VERBOSE /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; @@ -1209,19 +1130,18 @@ b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar; /* 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([[ + 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; -]])[ + yyvs = yyvsa;]b4_locations_if([[ + yyls = yylsa;]])[ yystacksize = YYINITDEPTH; YYDPRINTF ((stderr, "Starting parse\n")); @@ -1358,33 +1278,29 @@ yybackup: /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ if (yychar == YYEMPTY) - { -]b4_push_if([[ if (!yyps->yynew) - { -]b4_use_push_for_pull_if([], -[[ YYDPRINTF ((stderr, "Return for a new token:\n")); -]])[ yyresult = YYPUSH_MORE; + {]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([], [[ + 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; + 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; -]])[ } + yylval = *yypushed_val;]b4_locations_if([[ + if (yypushed_loc) + yylloc = *yypushed_loc;]])])], [[ + yychar = YYLEX;]])[ + } if (yychar <= YYEOF) { @@ -1500,7 +1416,7 @@ yyerrlab: yyerror (]b4_yyerror_args[YY_("syntax error")); #else { - YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); + YYSIZE_T yysize = yysyntax_error (0, yystate, yytoken); if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) { YYSIZE_T yyalloc = 2 * yysize; @@ -1520,7 +1436,7 @@ yyerrlab: if (0 < yysize && yysize <= yymsg_alloc) { - (void) yysyntax_error (yymsg, yystate, yychar); + (void) yysyntax_error (yymsg, yystate, yytoken); yyerror (]b4_yyerror_args[yymsg); } else @@ -1680,12 +1596,10 @@ yypushreturn: return YYID (yyresult); } - -]b4_epilogue +]b4_epilogue[]dnl b4_defines_if( -[@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]) +[@output(b4_spec_defines_file@)@ +b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl' b4_percent_code_get([[requires]])[]dnl @@ -1748,3 +1662,4 @@ b4_c_function_decl([b4_prefix[pstate_delete]], [[void]], b4_percent_code_get([[provides]])[]dnl ])dnl b4_defines_if m4_divert_pop(0) +m4_popdef([b4_copyright_years])