X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/60491a948b9339a6f68fafb63b51e9899d4e6aad..c19988b766d542b4d4c83b1b27579ee83cb5f930:/data/yacc.c diff --git a/data/yacc.c b/data/yacc.c index 3b885221..35e8da4f 100644 --- a/data/yacc.c +++ b/data/yacc.c @@ -1,7 +1,9 @@ m4_divert(-1) -*- C -*- +m4_include([c.m4]) # Yacc compatible skeleton for Bison -# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. +# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 +# 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 @@ -18,24 +20,6 @@ m4_divert(-1) -*- C -*- # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA # 02111-1307 USA -# b4_sint_type(MAX) -# ----------------- -# Return the smallest signed int type able to handle the number MAX. -m4_define([b4_sint_type], -[m4_if(m4_eval([$1 <= 127]), [1], [signed char], - m4_eval([$1 <= 32767]), [1], [signed short], - [signed int])]) - - -# b4_uint_type(MAX) -# ----------------- -# Return the smallest unsigned int type able to handle the number MAX. -m4_define([b4_uint_type], -[m4_if(m4_eval([$1 <= 255]), [1], [unsigned char], - m4_eval([$1 <= 65535]), [1], [unsigned short], - [unsigned int])]) - - # b4_lhs_value([TYPE]) # -------------------- # Expansion of $$. @@ -118,48 +102,6 @@ m4_define_default([b4_header_guard], [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])]) -## ------------------------- ## -## Assigning token numbers. ## -## ------------------------- ## - -# b4_token_define(TOKEN-NAME, TOKEN-NUMBER) -# ----------------------------------------- -# Output the definition of this token as #define. -m4_define([b4_token_define], -[#define $1 $2 -]) - - -# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) -# --------------------------------------- -# Output the definition of this token as an enum. -m4_define([b4_token_enum], -[$1 = $2]) - - -# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) -# ------------------------------------------------------- -# Output the definition of the tokens (if there are) as enums and #define. -m4_define([b4_token_defines], -[m4_if([$@], [[]], [], -[/* Tokens. */ -#ifndef YYTOKENTYPE -# if defined (__STDC__) || defined (__cplusplus) - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { -m4_map_sep([ b4_token_enum], [, -], - [$@]) - }; -# endif - /* POSIX requires `int' for tokens in interfaces. */ -# define YYTOKENTYPE int -#endif /* !YYTOKENTYPE */ -m4_map([b4_token_define], [$@]) -]) -]) - ## --------------------------------------------------------- ## ## Defining symbol actions, e.g., printers and destructors. ## @@ -185,37 +127,16 @@ m4_popdef([b4_dollar_dollar])dnl m4_divert(0)dnl #output "b4_output_parser_name" -/* A Bison parser, made from b4_filename - by GNU bison b4_version. */ - -/* Skeleton output parser for Bison, - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 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 - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ +b4_copyright([Skeleton parser for Yacc-like parsing with Bison], + [1984, 1989, 1990, 2000, 2001, 2002]) /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. This special exception was added by the Free Software Foundation in version 1.24 of Bison. */ -/* This is the parser code that is written into each bison parser when - the %semantic_parser declaration is not specified in the grammar. - It was written by Richard Stallman by simplifying the original so - called ``semantic'' parser. */ +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local @@ -245,11 +166,11 @@ m4_if(b4_prefix[], [yy], [], #define yynerrs b4_prefix[]nerrs b4_location_if([#define yylloc b4_prefix[]lloc])]) +b4_token_defines(b4_tokens) + /* Copy the first part of user declarations. */ b4_pre_prologue -b4_token_defines(b4_tokens) - /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG b4_debug @@ -386,19 +307,24 @@ b4_location_if( #endif +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + /* YYFINAL -- State number of the termination state. */ -#define YYFINAL b4_final -#define YYFLAG b4_flag +#define YYFINAL b4_final_state_number #define YYLAST b4_last /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS b4_ntokens +#define YYNTOKENS b4_tokens_number /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS b4_nnts +#define YYNNTS b4_nterms_number /* YYNRULES -- Number of rules. */ -#define YYNRULES b4_nrules +#define YYNRULES b4_rules_number /* YYNRULES -- Number of states. */ -#define YYNSTATES b4_nstates +#define YYNSTATES b4_states_number /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK b4_undef_token_number @@ -408,7 +334,7 @@ b4_location_if( ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK) /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX. */ -static const b4_uint_type(b4_translate_max) yytranslate[[]] = +static const b4_int_type_for([b4_translate]) yytranslate[[]] = { b4_translate }; @@ -416,19 +342,19 @@ static const b4_uint_type(b4_translate_max) yytranslate[[]] = #if YYDEBUG /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ -static const b4_uint_type(b4_prhs_max) yyprhs[[]] = +static const b4_int_type_for([b4_prhs]) yyprhs[[]] = { b4_prhs }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const b4_sint_type(b4_rhs_max) yyrhs[[]] = +static const b4_int_type_for([b4_rhs]) yyrhs[[]] = { b4_rhs }; /* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */ -static const b4_uint_type(b4_rline_max) yyrline[[]] = +static const b4_int_type_for([b4_rline]) yyrline[[]] = { b4_rline }; @@ -443,21 +369,23 @@ static const char *const yytname[[]] = }; #endif +# ifdef YYPRINT /* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to token YYLEX-NUM. */ -static const short yytoknum[[]] = +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_uint_type(b4_r1_max) yyr1[[]] = +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_uint_type(b4_r2_max) yyr2[[]] = +static const b4_int_type_for([b4_r2]) yyr2[[]] = { b4_r2 }; @@ -465,46 +393,49 @@ static const b4_uint_type(b4_r2_max) yyr2[[]] = /* 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 short yydefact[[]] = +static const b4_int_type_for([b4_defact]) yydefact[[]] = { b4_defact }; -/* YYPGOTO[[NTERM-NUM]]. */ -static const short yydefgoto[[]] = +/* 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. */ -static const short yypact[[]] = +#define YYPACT_NINF b4_pact_ninf +static const b4_int_type_for([b4_pact]) yypact[[]] = { b4_pact }; /* YYPGOTO[[NTERM-NUM]]. */ -static const short yypgoto[[]] = +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. */ -static const short yytable[[]] = + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, parse error. */ +#define YYTABLE_NINF b4_table_ninf +static const b4_int_type_for([b4_table]) yytable[[]] = { b4_table }; -static const short yycheck[[]] = +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_uint_type(b4_stos_max) yystos[[]] = +static const b4_int_type_for([b4_stos]) yystos[[]] = { b4_stos }; @@ -575,13 +506,14 @@ while (0) /* YYLEX -- calling `yylex' with the right arguments. */ -b4_pure_if( -[#ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]), YYLEX_PARAM) +#ifdef YYLEX_PARAM +# define YYLEX yylex (b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])YYLEX_PARAM) #else -# define YYLEX yylex (&yylval[]b4_location_if([, &yylloc])) -#endif], -[#define YYLEX yylex ()]) +# define YYLEX b4_c_function_call([yylex], [int], + b4_pure_if([[[[]], [[&yylval]]], + b4_location_if([[[], [&yylloc]],])]) + m4_fst(b4_lex_param)) +#endif /* Enable debugging if requested. */ #if YYDEBUG @@ -686,6 +618,69 @@ yystpcpy (yydest, yysrc) +#if YYDEBUG +/*-----------------------------. +| Print this symbol on YYOUT. | +`-----------------------------*/ + +b4_c_function([yysymprint], + [static void], + [[FILE*], [yyout]], + [[int], [yytype]], + [[YYSTYPE], [yyvalue]]b4_location_if([, + [[YYLTYPE], [yylocation]]])) +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; +b4_location_if([ (void) yylocation; +])dnl + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyout, "token %s (", yytname[[yytype]]); +# ifdef YYPRINT + YYPRINT (yyout, yytoknum[[yytype]], yyvalue); +# endif + } + else + YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]); + + switch (yytype) + { +m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl + default: + break; + } + YYFPRINTF (yyout, ")"); +} +#endif /* YYDEBUG. */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +b4_c_function([yydestruct], + [static void], + [[int], [yytype]], + [[YYSTYPE], [yyvalue]]b4_location_if([, + [[YYLTYPE], [yylocation]]])) +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; +b4_location_if([ (void) yylocation; +])dnl + + switch (yytype) + { +m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl + default: + break; + } +} + + + /* The user can define YYPARSE_PARAM as the name of an argument to be passed into yyparse. The argument should have type void *. It should actually point to an object. @@ -714,15 +709,6 @@ int yyparse (void); # endif #endif -#if defined (__STDC__) || defined (__cplusplus) -static void yydestruct (int yytype, - YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation])); -# if YYDEBUG -static void yysymprint (FILE* out, int yytype, - YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation])); -# endif -#endif - m4_divert_push([KILL])# ======================== M4 code. # b4_declare_parser_variables # --------------------------- @@ -905,7 +891,7 @@ yybackup: /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; - if (yyn == YYFLAG) + if (yyn == YYPACT_NINF) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ @@ -939,28 +925,19 @@ yybackup: YYDPRINTF ((stderr, "\n")); } + /* If the proper action on seeing token YYCHAR1 is to reduce or to + detect an error, take that action. */ yyn += yychar1; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) goto yydefault; - yyn = yytable[yyn]; - - /* yyn is what to do for this token type in this state. - Negative => reduce, -yyn is rule number. - Positive => shift, yyn is new state. - New state is final state => don't bother to shift, - just return success. - 0, or most negative number => error. */ - - if (yyn < 0) + if (yyn <= 0) { - if (yyn == YYFLAG) + if (yyn == 0 || yyn == YYTABLE_NINF) goto yyerrlab; yyn = -yyn; goto yyreduce; } - else if (yyn == 0) - goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; @@ -1005,8 +982,8 @@ yyreduce: /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. - Otherwise, the following line sets YYVAL to the semantic value of - the lookahead token. This behavior is undocumented and Bison + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ @@ -1065,7 +1042,7 @@ yyreduce: yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTOKENS]; @@ -1081,13 +1058,13 @@ yyerrlab: if (!yyerrstatus) { ++yynerrs; - #if YYERROR_VERBOSE yyn = yypact[yystate]; - if (yyn > YYFLAG && yyn < YYLAST) + if (YYPACT_NINF < yyn && yyn < YYLAST) { YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); char *yymsg; int yyx, yycount; @@ -1096,15 +1073,15 @@ yyerrlab: YYCHECK. */ for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) - if (yycheck[yyx + yyn] == yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) yysize += yystrlen (yytname[yyx]) + 15, yycount++; yysize += yystrlen ("parse error, unexpected ") + 1; - yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); + yysize += yystrlen (yytname[yytype]); yymsg = (char *) YYSTACK_ALLOC (yysize); if (yymsg != 0) { char *yyp = yystpcpy (yymsg, "parse error, unexpected "); - yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); + yyp = yystpcpy (yyp, yytname[yytype]); if (yycount < 5) { @@ -1112,7 +1089,7 @@ yyerrlab: for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) - if (yycheck[yyx + yyn] == yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { const char *yyq = ! yycount ? ", expecting " : " or "; yyp = yystpcpy (yyp, yyq); @@ -1122,13 +1099,13 @@ yyerrlab: } yyerror (yymsg); YYSTACK_FREE (yymsg); - } - else - yyerror ("parse error; also virtual memory exhausted"); - } + } + else + yyerror ("parse error; also virtual memory exhausted"); + } else #endif /* YYERROR_VERBOSE */ - yyerror ("parse error"); + yyerror ("parse error"); } goto yyerrlab1; @@ -1175,7 +1152,7 @@ yyerrlab1: for (;;) { yyn = yypact[yystate]; - if (yyn != YYFLAG) + if (yyn != YYPACT_NINF) { yyn += YYTERROR; if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) @@ -1257,55 +1234,17 @@ yyreturn: ]} -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -static void -yydestruct (int yytype, - YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation])) -{ - switch (yytype) - { -m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl - default: - break; - } -} - - -#if YYDEBUG -/*-----------------------------. -| Print this symbol on YYOUT. | -`-----------------------------*/ - -static void -yysymprint (FILE* yyout, int yytype, - YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation])) -{ - if (yytype < YYNTOKENS) - { - YYFPRINTF (yyout, "token %s (", yytname[[yytype]]); -# ifdef YYPRINT - YYPRINT (yyout, yytoknum[[yytype]], yyvalue); -# endif - } - else - YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]); - - switch (yytype) - { -m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl - default: - break; - } - YYFPRINTF (yyout, ")"); -} -#endif /* YYDEBUG. */ - b4_epilogue m4_if(b4_defines_flag, 0, [], [#output "b4_output_header_name" +b4_copyright([Skeleton parser for Yacc-like parsing with Bison], + [1984, 1989, 1990, 2000, 2001, 2002]) + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + #ifndef b4_header_guard # define b4_header_guard