m4_define([b4_sint_type],
[m4_if(m4_eval([$1 <= 127]), [1], [signed char],
m4_eval([$1 <= 32767]), [1], [signed short],
- m4_eval([$1 <= 2147483647]), [1], [signed int],
- [m4_fatal([no signed int type for $1])])])
+ [signed int])])
# b4_uint_type(MAX)
m4_define([b4_uint_type],
[m4_if(m4_eval([$1 <= 255]), [1], [unsigned char],
m4_eval([$1 <= 65535]), [1], [unsigned short],
- m4_eval([$1 <= 4294967295]), [1], [unsigned int],
- [m4_fatal([no unsigned int type for $1])])])
+ [unsigned int])])
+
+
+# b4_lhs_value([TYPE])
+# --------------------
+# Expansion of $<TYPE>$.
+m4_define([b4_lhs_value],
+[yyval[]m4_ifval([$1], [.$1])])
+
+
+# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
+# --------------------------------------
+# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
+# symbols on RHS.
+m4_define([b4_rhs_value],
+[yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
+
+
+# b4_lhs_location()
+# -----------------
+# Expansion of @$.
+m4_define([b4_lhs_location],
+[yyloc])
+
+
+# b4_rhs_location(RULE-LENGTH, NUM)
+# ---------------------------------
+# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
+# on RHS.
+m4_define([b4_rhs_location],
+[yylsp@<:@m4_eval([$2 - $1])@:>@])
m4_define_default([b4_input_suffix], [.y])
[[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
-# b4_token_defines(TOKEN-NAME, TOKEN-NUMBER)
-# ------------------------------------------
+## ------------------------- ##
+## 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 as #define.
+# Output the definition of the tokens (if there are) as enums and #define.
m4_define([b4_token_defines],
-[m4_map([b4_token_define], [$@])])
+[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], [$@])
+])
+])
m4_divert(0)dnl
/* 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 hairy parser
- used when %semantic_parser is specified. */
+ It was 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
/* Copy the first part of user declarations. */
b4_pre_prologue
+b4_token_defines(b4_tokens)
+
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG b4_debug
#endif
#ifndef YYSTYPE
-m4_ifdef([b4_stype_line],
+m4_ifdef([b4_stype],
[#line b4_stype_line "b4_filename"
-])dnl
-typedef b4_stype yystype;
+typedef union b4_stype yystype;
+/* Line __line__ of __file__. */
+#line __oline__ "__ofile__"],
+[typedef int yystype;])
# define YYSTYPE yystype
# define YYSTYPE_IS_TRIVIAL 1
#endif
#endif
-/* Tokens. */
-b4_token_defines(b4_tokens)
-
/* YYFINAL -- State number of the termination state. */
#define YYFINAL b4_final
#define YYFLAG b4_flag
#define YYUNDEFTOK b4_undef_token_number
#define YYMAXUTOK b4_user_token_number_max
-typedef b4_uint_type(b4_token_number_max) yy_token_number_type;
#define YYTRANSLATE(X) \
((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
/* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX. */
-static const yy_token_number_type yytranslate[[]] =
+static const b4_uint_type(b4_translate_max) yytranslate[[]] =
{
b4_translate
};
#if YYDEBUG
/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
-static const short yyprhs[[]] =
+static const b4_uint_type(b4_prhs_max) yyprhs[[]] =
{
b4_prhs
};
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-typedef b4_sint_type(b4_rhs_number_max) yyrhs_t;
-static const yyrhs_t yyrhs[[]] =
+static const b4_sint_type(b4_rhs_max) yyrhs[[]] =
{
b4_rhs
};
/* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */
-static const short yyrline[[]] =
+static const b4_uint_type(b4_rline_max) yyrline[[]] =
{
b4_rline
};
#endif
-#if (YYDEBUG) || YYERROR_VERBOSE
+#if YYDEBUG || YYERROR_VERBOSE
/* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[[]] =
};
#endif
-/* YYTOKNUM[[YYN]] -- Index in YYTNAME corresponding to YYLEX. */
+/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
+ token YYLEX-NUM. */
static const short yytoknum[[]] =
{
b4_toknum
};
/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */
-static const yy_token_number_type yyr1[[]] =
+static const b4_uint_type(b4_r1_max) yyr1[[]] =
{
b4_r1
};
/* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN. */
-static const short yyr2[[]] =
+static const b4_uint_type(b4_r2_max) yyr2[[]] =
{
b4_r2
};
-/* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE
- doesn't specify something else to do. Zero means the default is an
- error. */
+/* 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[[]] =
{
b4_defact
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[[]] =
+{
+ b4_stos
+};
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#define YYERRCODE 256
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
- are run).
-
- When YYLLOC_DEFAULT is run, CURRENT is set the location of the
- first token. By default, to implement support for ranges, extend
- its range to the last symbol. */
+ are run). */
#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N) \
- Current.last_line = Rhs[[N]].last_line; \
- Current.last_column = Rhs[[N]].last_column;
+# define YYLLOC_DEFAULT(Current, Rhs, N) \
+ Current.first_line = Rhs[[1]].first_line; \
+ Current.first_column = Rhs[[1]].first_column; \
+ Current.last_line = Rhs[[N]].last_line; \
+ Current.last_column = Rhs[[N]].last_column;
#endif
/* YYLEX -- calling `yylex' with the right arguments. */
int yyparse (void);
# endif
#endif
+static void yydestructor (int symbol_type, YYSTYPE symbol_value);
/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
variables are global, or local to YYPARSE. */
yyval = yyvsp[1-yylen];
#if YYLSP_NEEDED
- /* Similarly for the default location. Let the user run additional
- commands if for instance locations are ranges. */
- yyloc = yylsp[1-yylen];
+ /* Default location. */
YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
#endif
YYABORT;
YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
yychar, yytname[yychar1]));
+ yydestructor (yychar1, yylval);
yychar = YYEMPTY;
}
yyerrstatus = 3; /* Each real token shifted decrements this. */
- goto yyerrhandle;
-
+ for (;;)
+ {
+ yyn = yypact[yystate];
+ if (yyn != YYFLAG)
+ {
+ yyn += YYTERROR;
+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+ {
+ yyn = yytable[yyn];
+ if (0 < yyn)
+ break;
+ }
+ }
-/*-------------------------------------------------------------------.
-| yyerrdefault -- current state does not do anything special for the |
-| error token. |
-`-------------------------------------------------------------------*/
-yyerrdefault:
-#if 0
- /* This is wrong; only states that explicitly want error tokens
- should shift them. */
+ /* Pop the current state because it cannot handle the error token. */
+ if (yyssp == yyss)
+ YYABORT;
- /* If its default is to accept any token, ok. Otherwise pop it. */
- yyn = yydefact[yystate];
- if (yyn)
- goto yydefault;
+#if YYDEBUG
+ if (yydebug)
+ {
+ if (yystos[yystate] < YYNTOKENS)
+ {
+ YYFPRINTF (stderr, "Error: popping token %d (%s",
+ yytoknum[yystos[yystate]], yytname[yystos[yystate]]);
+# ifdef YYPRINT
+ YYPRINT (stderr, yytoknum[yystos[yystate]], *yyvsp);
+# endif
+ YYFPRINTF (stderr, ")\n");
+ }
+ else
+ {
+ YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n",
+ yytname[yystos[yystate]]);
+ }
+ }
#endif
-
-/*---------------------------------------------------------------.
-| yyerrpop -- pop the current state because it cannot handle the |
-| error token. |
-`---------------------------------------------------------------*/
-yyerrpop:
- if (yyssp == yyss)
- YYABORT;
- yyvsp--;
- yystate = *--yyssp;
+ yydestructor (yystos[yystate], *yyvsp);
+ yyvsp--;
+ yystate = *--yyssp;
#if YYLSP_NEEDED
- yylsp--;
+ yylsp--;
#endif
#if YYDEBUG
- if (yydebug)
- {
- short *yyssp1 = yyss - 1;
- YYFPRINTF (stderr, "Error: state stack now");
- while (yyssp1 != yyssp)
- YYFPRINTF (stderr, " %d", *++yyssp1);
- YYFPRINTF (stderr, "\n");
- }
+ if (yydebug)
+ {
+ short *yyssp1 = yyss - 1;
+ YYFPRINTF (stderr, "Error: state stack now");
+ while (yyssp1 != yyssp)
+ YYFPRINTF (stderr, " %d", *++yyssp1);
+ YYFPRINTF (stderr, "\n");
+ }
#endif
-
-/*--------------.
-| yyerrhandle. |
-`--------------*/
-yyerrhandle:
- yyn = yypact[yystate];
- if (yyn == YYFLAG)
- goto yyerrdefault;
-
- yyn += YYTERROR;
- if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
- goto yyerrdefault;
-
- yyn = yytable[yyn];
- if (yyn < 0)
- {
- if (yyn == YYFLAG)
- goto yyerrpop;
- yyn = -yyn;
- goto yyreduce;
}
- else if (yyn == 0)
- goto yyerrpop;
if (yyn == YYFINAL)
YYACCEPT;
return yyresult;
]}
+/* Release the memory associated to SYMBOL-NUMBER. */
+m4_divert_push([KILL])# M4 code.
+# b4_eval
+# -------
+# FIXME: This is really wrong, we no longer guarantee we don't evaluate
+# the user's input. This demonstrates that decoding actions (BRACED_CODE)
+# ought to be done when output, not when read.
+m4_define([b4_eval],
+[$*])
+
+# b4_symbol_destructor(SYMBOL-NUMBER, DESTRUCTOR, TYPE-NAME)
+# ----------------------------------------------------------
+m4_define([b4_symbol_destructor],
+[m4_pushdef([b4_dollar_dollar], [symbol_value.$3])dnl
+ case $1:
+ b4_eval($2);
+ break;
+m4_popdef([b4_dollar_dollar])])
+
+m4_divert_pop([KILL])dnl# End of M4 code.
+static void
+yydestructor (int symbol_type, YYSTYPE symbol_value)
+{
+ switch (symbol_type)
+ {
+m4_map([b4_symbol_destructor], m4_defn([b4_symbol_destructors]))dnl
+ default:
+ YYDPRINTF ((stderr, "yydestructor: unknown symbol type: %s\n",
+ yytname[[symbol_type]]));
+ break;
+ }
+}
+
b4_epilogue
m4_if(b4_defines_flag, 0, [],
[#output "b4_output_header_name"
b4_token_defines(b4_tokens)
#ifndef YYSTYPE
-m4_ifdef([b4_stype_line],
+m4_ifdef([b4_stype],
[#line b4_stype_line "b4_filename"
-])dnl
-typedef b4_stype
-yystype;
+typedef union b4_stype yystype;
+/* Line __line__ of __file__. */
+#line __oline__ "__ofile__"],
+[typedef int yystype;])
# define YYSTYPE yystype
#endif
projects / bison.git / blobdiff