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
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. */
+
/* Written by Richard Stallman by simplifying the original so called
``semantic'' parser. */
#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
((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
};
#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
};
};
#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
};
/* 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[[]] =
+#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
};
\f
+#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. */
+
+
+/*----------------------------------------------------------.
+| yyreport_parse_error -- report a parse error in YYSTATE. |
+`----------------------------------------------------------*/
+
+b4_c_function([yyreport_parse_error],
+ [static void],
+ [[int], [yystate]],
+ [[int], [yychar]],
+ [[YYSTYPE], [yyvalue]]b4_location_if([,
+ [[YYLTYPE], [yylloc]]]))
+[{
+#if YYERROR_VERBOSE
+ int yyn = yypact[yystate];
+
+ if (YYPACT_NINF < yyn && yyn < YYLAST)
+ {
+ YYSIZE_T yysize = 0;
+ int yytype = YYTRANSLATE (yychar);
+ char *yymsg;
+ int yyx, yycount;
+
+ yycount = 0;
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ for (yyx = yyn < 0 ? -yyn : 0;
+ yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+ yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+ yysize += yystrlen ("parse error, unexpected ") + 1;
+ yysize += yystrlen (yytname[yytype]);
+ yymsg = (char *) YYSTACK_ALLOC (yysize);
+ if (yymsg != 0)
+ {
+ char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+ yyp = yystpcpy (yyp, yytname[yytype]);
+
+ if (yycount < 5)
+ {
+ yycount = 0;
+ for (yyx = yyn < 0 ? -yyn : 0;
+ yyx < (int) (sizeof (yytname) / sizeof (char *));
+ yyx++)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+ {
+ const char *yyq = ! yycount ? ", expecting " : " or ";
+ yyp = yystpcpy (yyp, yyq);
+ yyp = yystpcpy (yyp, yytname[yyx]);
+ yycount++;
+ }
+ }
+ yyerror (yymsg);
+ YYSTACK_FREE (yymsg);
+ }
+ else
+ yyerror ("parse error; also virtual memory exhausted");
+ }
+ else
+#endif /* YYERROR_VERBOSE */
+ yyerror ("parse error");
+
+ /* Pacify ``unused variable'' warnings. */
+ (void) yystate;
+ (void) yychar;
+ (void) yyvalue;
+ ]b4_location_if([(void) yylloc;])[
+}]
+
+
+/*-----------------------------------------------.
+| 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;
+ }
+}
+
+\f
+
/* 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.
# 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
# ---------------------------
/* 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. */
}
yyn += yychar1;
- if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
goto yydefault;
yyn = yytable[yyn];
if (yyn < 0)
{
- if (yyn == YYFLAG)
+ if (yyn == YYTABLE_NINF)
goto yyerrlab;
yyn = -yyn;
goto 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. */
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];
if (!yyerrstatus)
{
++yynerrs;
-
-#if YYERROR_VERBOSE
- yyn = yypact[yystate];
-
- if (yyn > YYFLAG && yyn < YYLAST)
- {
- YYSIZE_T yysize = 0;
- char *yymsg;
- int yyx, yycount;
-
- yycount = 0;
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. */
- for (yyx = yyn < 0 ? -yyn : 0;
- yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
- if (yycheck[yyx + yyn] == yyx)
- yysize += yystrlen (yytname[yyx]) + 15, yycount++;
- yysize += yystrlen ("parse error, unexpected ") + 1;
- yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
- yymsg = (char *) YYSTACK_ALLOC (yysize);
- if (yymsg != 0)
- {
- char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
- yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
-
- if (yycount < 5)
- {
- yycount = 0;
- for (yyx = yyn < 0 ? -yyn : 0;
- yyx < (int) (sizeof (yytname) / sizeof (char *));
- yyx++)
- if (yycheck[yyx + yyn] == yyx)
- {
- const char *yyq = ! yycount ? ", expecting " : " or ";
- yyp = yystpcpy (yyp, yyq);
- yyp = yystpcpy (yyp, yytname[yyx]);
- yycount++;
- }
- }
- yyerror (yymsg);
- YYSTACK_FREE (yymsg);
- }
- else
- yyerror ("parse error; also virtual memory exhausted");
- }
- else
-#endif /* YYERROR_VERBOSE */
- yyerror ("parse error");
+ yyreport_parse_error (yystate, yychar, yylval]b4_location_if([, yylloc])[);
}
goto yyerrlab1;
for (;;)
{
yyn = yypact[yystate];
- if (yyn != YYFLAG)
+ if (yyn != YYPACT_NINF)
{
yyn += YYTERROR;
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
]}
-/*-----------------------------------------------.
-| Release the memory associated to this symbol. |
-`-----------------------------------------------*/
-
-static void
-yydestruct (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;
- }
-}
-
-
-#if YYDEBUG
-/*-----------------------------.
-| Print this symbol on YYOUT. |
-`-----------------------------*/
-
-static void
-yysymprint (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. */
-
b4_epilogue
m4_if(b4_defines_flag, 0, [],
-[b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
- [1984, 1989, 1990, 2000, 2001, 2002])
-#output "b4_output_header_name"
+[#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
projects / bison.git / blobdiff