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_token_defines(TOKEN-NAME, TOKEN-NUMBER)
-# ------------------------------------------
+# 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],
+[semantic_stack_@<:@m4_eval([$1 - $2])@:>@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],
+[location_stack_@<:@m4_eval([$1 - $2])@:>@])
+
+
+# b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
+# -----------------------------------------
# Output the definition of this token as #define.
m4_define([b4_token_define],
[#define $1 $2
/* Using locations. */
#define YYLSP_NEEDED b4_locations_flag
-b4_prologue
+/* Copy the first part of user declarations. */
+b4_pre_prologue
/* Tokens. */
b4_token_defines(b4_tokens)
# define YYSTYPE yystype
#endif
+/* Copy the second part of user declarations. */
+b4_post_prologue
+
#line __oline__ "__ofile__"
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
template < >
struct Traits< b4_name >
{
- typedef b4_uint_type(b4_token_number_max) TokenNumberType;
- typedef b4_sint_type(b4_rhs_number_max) RhsNumberType;
+ typedef b4_uint_type(b4_translate_max) TokenNumberType;
+ typedef b4_sint_type(b4_rhs_max) RhsNumberType;
typedef int StateType;
typedef yystype SemanticType;
typedef b4_ltype LocationType;
static const short defgoto_[[]];
static const short table_[[]];
static const short check_[[]];
- static const short r1_[[]];
- static const short r2_[[]];
+ static const b4_uint_type(b4_r1_max) r1_[[]];
+ static const b4_uint_type(b4_r2_max) r2_[[]];
#if YYDEBUG || YYERROR_VERBOSE
static const char* const name_[[]];
/* More tables, for debugging. */
#if YYDEBUG
static const RhsNumberType rhs_[[]];
- static const short prhs_[[]];
- static const short rline_[[]];
+ static const b4_uint_type(b4_prhs_max) prhs_[[]];
+ static const b4_uint_type(b4_rline_max) rline_[[]];
#endif
/* Even more tables. */
static const int errcode_;
static const int ntokens_;
static const int initdepth_;
- static const unsigned maxtok_;
+ static const unsigned user_token_number_max_;
+ static const TokenNumberType undef_token_;
/* State. */
int n_;
semantic_stack_ = SemanticStack (1);
location_stack_ = LocationStack (1);
- /* Reserve initial space. The C parser needed that, but is it really
- useful here? */
- state_stack_.reserve (initdepth_);
- semantic_stack_.reserve (initdepth_);
- location_stack_.reserve (initdepth_);
-
/* Start. */
state_ = 0;
looka_ = empty_;
len_ = r2_[[n_]];
if (len_)
{
- yyval = semantic_stack_[[1 - len_]];
- yyloc = location_stack_[[1 - len_]];
+ yyval = semantic_stack_[[len_ - 1]];
+ yyloc = location_stack_[[len_ - 1]];
}
else
{
if (debug_)
{
YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n_ - 1, rline_[[n_]]);
- for (unsigned i = prhs_[[n_]];
+ for (b4_uint_type(b4_prhs_max) i = prhs_[[n_]];
rhs_[[i]] >= 0; ++i)
YYFPRINTF (stderr, "%s ", name_[[rhs_[i]]]);
YYFPRINTF (stderr, "-> %s\n", name_[[r1_[n_]]]);
YYLLOC_DEFAULT (yyloc, slice, len_);
}
- {
- SemanticStack& yyvsp (semantic_stack_);
- LocationStack& yylsp (location_stack_);
-
- switch (n_)
- {
- b4_actions
- }
- }
+ switch (n_)
+ {
+ b4_actions
+ }
/* Line __line__ of __file__. */
#line __oline__ "__ofile__"
};
/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */
-const short
+const b4_uint_type(b4_r1_max)
yy::b4_name::r1_[[]] =
{
b4_r1
};
/* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN. */
-const short
+const b4_uint_type(b4_r2_max)
yy::b4_name::r2_[[]] =
{
b4_r2
/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
-const short
+const b4_uint_type(b4_prhs_max)
yy::b4_name::prhs_[[]] =
{
b4_prhs
};
/* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */
-const short
+const b4_uint_type(b4_rline_max)
yy::b4_name::rline_[[]] =
{
b4_rline
{
b4_translate
};
- return (unsigned)(token) <= maxtok_ ? translate_[[token]] : nsym_;
+ if ((unsigned) token <= user_token_number_max_)
+ return translate_[[token]];
+ else
+ return undef_token_;
}
const int yy::b4_name::eof_ = 0;
const int yy::b4_name::ntokens_ = b4_ntokens;
const int yy::b4_name::initdepth_ = b4_initdepth;
-const unsigned yy::b4_name::maxtok_ = b4_maxtok;
+const unsigned yy::b4_name::user_token_number_max_ = b4_user_token_number_max;
+const yy::b4_name::TokenNumberType yy::b4_name::undef_token_ = b4_undef_token_number;
b4_epilogue
#ifndef BISON_STACK_HH
# define BISON_STACK_HH
-#include <vector>
+#include <deque>
namespace yy
{
- template < class T, class S = std::vector< T > >
+ template < class T, class S = std::deque< T > >
class Stack
{
public:
inline
T&
- operator [[]] (int index)
+ operator [[]] (unsigned index)
{
- return seq_[[height () - 1 + index]];
+ return seq_[[index]];
}
inline
const T&
- operator [[]] (int index) const
+ operator [[]] (unsigned index) const
{
- return seq_[[height () - 1 + index]];
+ return seq_[[index]];
}
inline
void
push (const T& t)
{
- seq_.push_back (t);
+ seq_.push_front (t);
}
inline
pop (unsigned n = 1)
{
for (; n; --n)
- seq_.pop_back ();
- }
-
- inline
- void
- reserve (unsigned n)
- {
- seq_.reserve (n);
+ seq_.pop_front ();
}
inline
const T&
operator [[]] (unsigned index) const
{
- return stack_[[index - range_]];
+ return stack_[[range_ - index]];
}
private:
projects / bison.git / blobdiff