# YYTYPE.
m4_define([b4_symbol_variant],
[m4_pushdef([b4_dollar_dollar],
- [$2.$3< $][3 >(m4_shift3($@))])dnl
+ [$2.$3< $][3 > (m4_shift3($@))])dnl
switch ($1)
{
b4_type_foreach([b4_type_action_])[]dnl
[b4_symbol_if([$1], [has_type],
[
m4_map([ b4_symbol_tag_comment], [$@])dnl
- char _b4_char_sizeof_dummy@{sizeof([b4_symbol([$1], [type])])@};
+ char _b4_char_sizeof_dummy@{sizeof(b4_symbol([$1], [type]))@};
])])
/// Empty construction.
variant ()]b4_parse_assert_if([
- : built (false)
- , tname (YY_NULL)])[
+ : yytname_ (YY_NULL)])[
{}
/// Construct and fill.
template <typename T>
variant (const T& t)]b4_parse_assert_if([
- : built (true)
- , tname (typeid (T).name ())])[
+ : yytname_ (typeid (T).name ())])[
{
YYASSERT (sizeof (T) <= S);
- new (buffer.raw) T (t);
+ new (yyas_<T> ()) T (t);
}
/// Destruction, allowed only if empty.
~variant ()
{]b4_parse_assert_if([
- YYASSERT (!built);
+ YYASSERT (!yytname_);
])[}
/// Instantiate an empty \a T in here.
T&
build ()
{]b4_parse_assert_if([
- YYASSERT (!built);
- YYASSERT (!tname);
+ YYASSERT (!yytname_);
YYASSERT (sizeof (T) <= S);
- built = true;
- tname = typeid (T).name ();])[
- return *new (buffer.raw) T;
+ yytname_ = typeid (T).name ();])[
+ return *new (yyas_<T> ()) T;
}
/// Instantiate a \a T in here from \a t.
T&
build (const T& t)
{]b4_parse_assert_if([
- YYASSERT (!built);
- YYASSERT (!tname);
+ YYASSERT (!yytname_);
YYASSERT (sizeof (T) <= S);
- built = true;
- tname = typeid (T).name ();])[
- return *new (buffer.raw) T (t);
+ yytname_ = typeid (T).name ();])[
+ return *new (yyas_<T> ()) T (t);
}
/// Accessor to a built \a T.
T&
as ()
{]b4_parse_assert_if([
- YYASSERT (built);
- YYASSERT (tname == typeid (T).name ());
+ YYASSERT (yytname_ == typeid (T).name ());
YYASSERT (sizeof (T) <= S);])[
- return reinterpret_cast<T&> (buffer.raw);
+ return *yyas_<T> ();
}
/// Const accessor to a built \a T (for %printer).
const T&
as () const
{]b4_parse_assert_if([
- YYASSERT (built);
- YYASSERT (tname == typeid (T).name ());
+ YYASSERT (yytname_ == typeid (T).name ());
YYASSERT (sizeof (T) <= S);])[
- return reinterpret_cast<const T&> (buffer.raw);
+ return *yyas_<T> ();
}
/// Swap the content with \a other, of same type.
/// variant::move ().
template <typename T>
void
- swap (variant<S>& other)
+ swap (self_type& other)
{]b4_parse_assert_if([
- YYASSERT (built);
- YYASSERT (other.built);
- YYASSERT (tname == other.tname);])[
- std::swap (as<T>(), other.as<T>());
+ YYASSERT (yytname_);
+ YYASSERT (yytname_ == other.yytname_);])[
+ std::swap (as<T> (), other.as<T> ());
}
/// Move the content of \a other to this.
/// Destroys \a other.
template <typename T>
void
- move (variant<S>& other)
+ move (self_type& other)
{]b4_parse_assert_if([
- YYASSERT (! built);])[
- build<T>();
- swap<T>(other);
- other.destroy<T>();
+ YYASSERT (!yytname_);])[
+ build<T> ();
+ swap<T> (other);
+ other.destroy<T> ();
}
/// Copy the content of \a other to this.
template <typename T>
void
- copy (const variant<S>& other)
+ copy (const self_type& other)
{
build<T> (other.as<T> ());
}
destroy ()
{
as<T> ().~T ();]b4_parse_assert_if([
- built = false;
- tname = YY_NULL;])[
+ yytname_ = YY_NULL;])[
}
private:
self_type& operator=(const self_type&);
variant (const self_type&);
- /// A buffer large enough to store any of the semantic values.
- /// Long double is chosen as it has the strongest alignment
- /// constraints.
+ /// Accessor to raw memory as \a T.
+ template <typename T>
+ T*
+ yyas_ ()
+ {
+ void *yyp = yybuffer_.yyraw;
+ return static_cast<T*> (yyp);
+ }
+
+ /// Const accessor to raw memory as \a T.
+ template <typename T>
+ const T*
+ yyas_ () const
+ {
+ const void *yyp = yybuffer_.yyraw;
+ return static_cast<const T*> (yyp);
+ }
+
union
{
- long double align_me;
- char raw[S];
- } buffer;]b4_parse_assert_if([
-
- /// Whether the content is built.
- bool built;
- /// If defined, the name of the stored type.
- const char* tname;])[
+ /// Strongest alignment constraints.
+ long double yyalign_me;
+ /// A buffer large enough to store any of the semantic values.
+ char yyraw[S];
+ } yybuffer_;]b4_parse_assert_if([
+
+ /// Whether the content is built: if defined, the name of the stored type.
+ const char *yytname_;])[
};
]])
## -------------------------- ##
-# b4_semantic_type_declare
-# ------------------------
+# b4_value_type_declare
+# ---------------------
# Declare semantic_type.
-m4_define([b4_semantic_type_declare],
-[ /// An auxiliary type to compute the largest semantic type.
+m4_define([b4_value_type_declare],
+[[ /// An auxiliary type to compute the largest semantic type.
union union_type
{]b4_type_foreach([b4_char_sizeof])[};
/// Symbol semantic values.
- typedef variant<sizeof(union_type)> semantic_type;dnl
+ typedef variant<sizeof(union_type)> semantic_type;][]dnl
])
# ----------------------------
m4_define([b4_symbol_value],
[m4_ifval([$2],
- [$1.as< $2 >()],
+ [$1.as< $2 > ()],
[$1])])
# b4_symbol_value_template(VAL, [TYPE])
# Same as b4_symbol_value, but used in a template method.
m4_define([b4_symbol_value_template],
[m4_ifval([$2],
- [$1.template as< $2 >()],
+ [$1.template as< $2 > ()],
[$1])])
b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
b4_join(b4_symbol_if([$1], [has_type],
[const b4_symbol([$1], [type])& v]),
- b4_locations_if([const location_type& l])))[
+ b4_locations_if([const location_type& l])))
{
- symbol_type res (token::]b4_symbol([$1], [id])[]b4_locations_if([, l])[);
- ]b4_symbol_if([$1], [has_type], [res.value.build (v);])[
- // ]b4_locations_if([res.location = l;])[
- return res;
+ return symbol_type (b4_join([token::b4_symbol([$1], [id])],
+ b4_symbol_if([$1], [has_type], [v]),
+ b4_locations_if([l])));
+
}
-]])])])
+])])])
+
+# b4_basic_symbol_constructor_declare
+# -----------------------------------
+# Generate a constructor declaration for basic_symbol from given type.
+m4_define([b4_basic_symbol_constructor_declare],
+[[
+ basic_symbol (]b4_join(
+ [typename Base::kind_type t],
+ b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
+ b4_locations_if([const location_type& l]))[);
+]])
+
+# b4_basic_symbol_constructor_define
+# ----------------------------------
+# Generate a constructor implementation for basic_symbol from given type.
+m4_define([b4_basic_symbol_constructor_define],
+[[
+ template <typename Base>
+ ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
+ [typename Base::kind_type t],
+ b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
+ b4_locations_if([const location_type& l]))[)
+ : Base (t)
+ , value (]b4_symbol_if([$1], [has_type], [v])[)]b4_locations_if([
+ , location (l)])[
+ {}
+]])
# b4_symbol_constructor_define
# ----------------------------
projects / bison.git / blobdiff