boost/spirit
2
0
Fork 0
mirror of https://github.com/boostorg/spirit.git synced 2026-01-19 04:42:11 +00:00
Code Issues Projects Releases Wiki Activity

Spirit: patch allowing to use Spirit with Phoenix V3

Browse Source 
[SVN r70656]
This commit is contained in:
Hartmut Kaiser
2011-03-28 02:37:31 +00:00
parent cd74cfba7e
commit 400a764d61
42 changed files with 1275 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
include/boost/spirit/home/lex/argument.hpp
View File

@@ -1,6 +1,7 @@
// Copyright (c) 2001-2011 Hartmut Kaiser
// Copyright (c) 2001-2011 Joel de Guzman
// Copyright (c) 2010 Bryce Lelbach
// Copyright (c) 2011 Thomas Heller
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,18 +13,16 @@
#pragma once
#endif
#include <boost/spirit/home/phoenix/core/actor.hpp>
#include <boost/spirit/home/phoenix/core/argument.hpp>
#include <boost/spirit/home/phoenix/core/compose.hpp>
#include <boost/spirit/home/phoenix/core/value.hpp>
#include <boost/spirit/home/phoenix/core/as_actor.hpp>
#include <boost/spirit/home/phoenix/operator/self.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/home/support/string_traits.hpp>
#include <boost/spirit/home/lex/argument_phoenix.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit { namespace lex
@@ -48,9 +47,11 @@ namespace boost { namespace spirit { namespace lex
template <typename Env>
struct result
{
typedef typename
remove_const<
typename mpl::at_c<typename Env::args_type, 4>::type
typedef
typename remove_reference<
typename remove_const<
typename mpl::at_c<typename Env::args_type, 4>::type
>::type
>::type
context_type;
@@ -92,9 +93,11 @@ namespace boost { namespace spirit { namespace lex
template <typename Env>
void eval(Env const& env) const
{
typedef typename
remove_const<
typename mpl::at_c<typename Env::args_type, 4>::type
typedef
typename remove_reference<
typename remove_const<
typename mpl::at_c<typename Env::args_type, 4>::type
>::type
>::type
context_type;
@@ -108,38 +111,14 @@ namespace boost { namespace spirit { namespace lex
: actor_(actor) {}
// see explanation for this constructor at the end of this file
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
state_setter(phoenix::actor<state_getter>, Actor const& actor)
: actor_(actor) {}
#endif
Actor actor_;
};
///////////////////////////////////////////////////////////////////////////
// The state_context is used as a noop Phoenix actor to create the
// placeholder '_state' (see below). It is a noop actor because it is used
// as a placeholder only, while it is being converted either to a
// state_getter (if used as a rvalue) or to a state_setter (if used as a
// lvalue). The conversion is achieved by specializing and overloading a
// couple of the Phoenix templates from the Phoenix expression composition
// engine (see the end of this file).
struct state_context
{
typedef mpl::true_ no_nullary;
template <typename Env>
struct result
{
typedef unused_type type;
};
template <typename Env>
unused_type
eval(Env const& env) const
{
return unused;
}
};
///////////////////////////////////////////////////////////////////////////
// The value_getter is used to create the _val placeholder, which is a
// Phoenix actor used to access the value of the current token.
@@ -159,9 +138,11 @@ namespace boost { namespace spirit { namespace lex
template <typename Env>
struct result
{
typedef typename
remove_const<
typename mpl::at_c<typename Env::args_type, 4>::type
typedef
typename remove_reference<
typename remove_const<
typename mpl::at_c<typename Env::args_type, 4>::type
>::type
>::type
context_type;
@@ -209,39 +190,15 @@ namespace boost { namespace spirit { namespace lex
value_setter(Actor const& actor)
: actor_(actor) {}
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
// see explanation for this constructor at the end of this file
value_setter(phoenix::actor<value_getter>, Actor const& actor)
: actor_(actor) {}
#endif
Actor actor_;
};
///////////////////////////////////////////////////////////////////////////
// The value_context is used as a noop Phoenix actor to create the
// placeholder '_val' (see below). It is a noop actor because it is used
// as a placeholder only, while it is being converted either to a
// value_getter (if used as a rvalue) or to a value_setter (if used as a
// lvalue). The conversion is achieved by specializing and overloading a
// couple of the Phoenix templates from the Phoenix expression composition
// engine (see the end of this file).
struct value_context
{
typedef mpl::true_ no_nullary;
template <typename Env>
struct result
{
typedef unused_type type;
};
template <typename Env>
unused_type
eval(Env const& env) const
{
return unused;
}
};
///////////////////////////////////////////////////////////////////////////
// The eoi_getter is used to create the _eoi placeholder, which is a
// Phoenix actor used to access the end of input iterator pointing to the
@@ -263,9 +220,11 @@ namespace boost { namespace spirit { namespace lex
template <typename Env>
struct result
{
typedef typename
remove_const<
typename mpl::at_c<typename Env::args_type, 4>::type
typedef
typename remove_reference<
typename remove_const<
typename mpl::at_c<typename Env::args_type, 4>::type
>::type
>::type
context_type;
@@ -283,33 +242,47 @@ namespace boost { namespace spirit { namespace lex
///////////////////////////////////////////////////////////////////////////
// '_start' and '_end' may be used to access the start and the end of
// the matched sequence of the current token
phoenix::actor<phoenix::argument<0> > const _start = phoenix::argument<0>();
phoenix::actor<phoenix::argument<1> > const _end = phoenix::argument<1>();
typedef phoenix::arg_names::_1_type _start_type;
typedef phoenix::arg_names::_2_type _end_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
_start_type const _start = _start_type();
_end_type const _end = _end_type();
#endif
// We are reusing the placeholder '_pass' to access and change the pass
// status of the current match (see support/argument.hpp for its
// definition).
// typedef phoenix::arg_names::_3_type _pass_type;
using boost::spirit::_pass_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
using boost::spirit::_pass;
#endif
// '_tokenid' may be used to access and change the tokenid of the current
// token
phoenix::actor<phoenix::argument<3> > const _tokenid = phoenix::argument<3>();
typedef phoenix::arg_names::_4_type _tokenid_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
_tokenid_type const _tokenid = _tokenid_type();
#endif
typedef phoenix::actor<value_context> _val_type;
typedef phoenix::actor<state_context> _state_type;
typedef phoenix::actor<eoi_getter> _eoi_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
// '_val' may be used to access and change the token value of the current
// token
phoenix::actor<value_context> const _val = value_context();
_val_type const _val = _val_type();
// _state may be used to access and change the name of the current lexer
// state
phoenix::actor<state_context> const _state = state_context();
_state_type const _state = _state_type();
// '_eoi' may be used to access the end of input iterator of the input
// stream used by the lexer to match tokens from
phoenix::actor<eoi_getter> const _eoi = eoi_getter();
_eoi_type const _eoi = _eoi_type();
#endif
}}}
///////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
namespace boost { namespace phoenix
{
///////////////////////////////////////////////////////////////////////////
@@ -382,6 +355,7 @@ namespace boost { namespace phoenix
typedef spirit::lex::value_setter<typename as_actor<RHS>::type> type;
};
}}
#endif
#undef SPIRIT_DECLARE_ARG
#endif

220
include/boost/spirit/home/lex/argument_phoenix.hpp Normal file
View File

@@ -0,0 +1,220 @@
// Copyright (c) 2001-2011 Hartmut Kaiser
// Copyright (c) 2011 Thomas Heller
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#if !defined(BOOST_SPIRIT_LEX_ARGUMENT_PHEONIX_MARCH_25_2011_1841PM)
#define BOOST_SPIRIT_LEX_ARGUMENT_PHEONIX_MARCH_25_2011_1841PM
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/spirit/include/phoenix_core.hpp>
namespace boost { namespace spirit { namespace lex
{
///////////////////////////////////////////////////////////////////////////
// The value_context is used as a noop Phoenix actor to create the
// placeholder '_val' (see below). It is a noop actor because it is used
// as a placeholder only, while it is being converted either to a
// value_getter (if used as a rvalue) or to a value_setter (if used as a
// lvalue). The conversion is achieved by specializing and overloading a
// couple of the Phoenix templates from the Phoenix expression composition
// engine (see the end of this file).
struct value_context
{
typedef mpl::true_ no_nullary;
template <typename Env>
struct result
{
typedef unused_type type;
};
template <typename Env>
unused_type
eval(Env const& env) const
{
return unused;
}
};
// forward declarations
struct value_getter;
template <typename> struct value_setter;
///////////////////////////////////////////////////////////////////////////
// The state_context is used as a noop Phoenix actor to create the
// placeholder '_state' (see below). It is a noop actor because it is used
// as a placeholder only, while it is being converted either to a
// state_getter (if used as a rvalue) or to a state_setter (if used as a
// lvalue). The conversion is achieved by specializing and overloading a
// couple of the Phoenix templates from the Phoenix expression composition
// engine (see the end of this file).
struct state_context
{
typedef mpl::true_ no_nullary;
template <typename Env>
struct result
{
typedef unused_type type;
};
template <typename Env>
unused_type
eval(Env const& env) const
{
return unused;
}
};
// forward declarations
struct state_getter;
template <typename> struct state_setter;
struct eoi_getter;
}}}
BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
template<>
, boost::spirit::lex::value_context
, mpl::false_
, v2_eval(
proto::make<boost::spirit::lex::value_getter()>
, proto::call<
functional::env(proto::_state)
>
)
)
BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
template<>
, boost::spirit::lex::state_context
, mpl::false_
, v2_eval(
proto::make<boost::spirit::lex::state_getter()>
, proto::call<
functional::env(proto::_state)
>
)
)
BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
template<>
, boost::spirit::lex::eoi_getter
, mpl::false_
, v2_eval(
proto::make<boost::spirit::lex::eoi_getter()>
, proto::call<
functional::env(proto::_state)
>
)
)
///////////////////////////////////////////////////////////////////////////////
#ifdef BOOST_SPIRIT_USE_PHOENIX_V3
BOOST_PHOENIX_DEFINE_EXPRESSION(
(boost)(spirit)(lex)(value_setter)
, (boost::phoenix::meta_grammar)
)
BOOST_PHOENIX_DEFINE_EXPRESSION(
(boost)(spirit)(lex)(state_setter)
, (boost::phoenix::meta_grammar)
)
namespace boost { namespace phoenix
{
template <typename Dummy>
struct is_nullary::when<spirit::lex::rule::value_setter, Dummy>
: proto::make<mpl::false_()>
{};
template <typename Dummy>
struct default_actions::when<spirit::lex::rule::value_setter, Dummy>
: proto::call<
v2_eval(
proto::make<
spirit::lex::value_setter<proto::_child0>(
proto::_child0
)
>
, _env
)
>
{};
template <>
struct actor<spirit::lex::value_context>
: boost::phoenix::actor<proto::terminal<spirit::lex::value_context>::type>
{
typedef boost::phoenix::actor<
typename proto::terminal<spirit::lex::value_context>::type
> base_type;
actor(base_type const & base = base_type())
: base_type(base)
{}
template <typename Expr>
typename spirit::lex::expression::value_setter<
typename phoenix::as_actor<Expr>::type>::type const
operator=(Expr const & expr) const
{
return
spirit::lex::expression::value_setter<
typename phoenix::as_actor<Expr>::type
>::make(phoenix::as_actor<Expr>::convert(expr));
}
};
template <typename Dummy>
struct is_nullary::when<spirit::lex::rule::state_setter, Dummy>
: proto::make<mpl::false_()>
{};
template <typename Dummy>
struct default_actions::when<spirit::lex::rule::state_setter, Dummy>
: proto::call<
v2_eval(
proto::make<
spirit::lex::state_setter<proto::_child0>(
proto::_child0
)
>
, _env
)
>
{};
template <>
struct actor<spirit::lex::state_context>
: boost::phoenix::actor<proto::terminal<spirit::lex::state_context>::type>
{
typedef boost::phoenix::actor<
typename proto::terminal<spirit::lex::state_context>::type
> base_type;
actor(base_type const & base = base_type())
: base_type(base)
{}
template <typename Expr>
typename spirit::lex::expression::state_setter<
typename phoenix::as_actor<Expr>::type>::type const
operator=(Expr const & expr) const
{
return
spirit::lex::expression::state_setter<
typename phoenix::as_actor<Expr>::type
>::make(phoenix::as_actor<Expr>::convert(expr));
}
};
}}
#endif // BOOST_SPIRIT_USE_PHOENIX_V3
#endif

12
include/boost/spirit/home/lex/lexer/lexertl/wrap_action.hpp
View File

@@ -13,10 +13,10 @@
#pragma once
#endif
#include <boost/spirit/home/phoenix/core/actor.hpp>
#include <boost/spirit/home/phoenix/core/argument.hpp>
#include <boost/spirit/home/phoenix/bind.hpp>
#include <boost/spirit/home/phoenix/scope.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_bind.hpp>
#include <boost/spirit/include/phoenix_scope.hpp>
#include <boost/spirit/home/support/attributes.hpp>
#include <boost/spirit/home/lex/lexer/pass_flags.hpp>
@@ -40,9 +40,11 @@ namespace boost { namespace spirit { namespace lex { namespace lexertl
// wrap phoenix actor
struct phoenix_action
{
typedef void result_type;
template <typename F, typename T1, typename T2, typename T3
, typename T4, typename T5>
struct result { typedef void type; };
struct result { typedef result_type type; };
template <typename Eval>
void operator()(phoenix::actor<Eval> const& f, Iterator& start

47
include/boost/spirit/home/lex/lexer/support_functions.hpp
View File

@@ -10,14 +10,12 @@
#pragma once
#endif
#include <boost/spirit/home/phoenix/core/actor.hpp>
#include <boost/spirit/home/phoenix/core/argument.hpp>
#include <boost/spirit/home/phoenix/core/compose.hpp>
#include <boost/spirit/home/phoenix/core/value.hpp>
#include <boost/spirit/home/phoenix/core/as_actor.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/home/support/detail/scoped_enum_emulation.hpp>
#include <boost/spirit/home/lex/lexer/pass_flags.hpp>
#include <boost/spirit/home/lex/lexer/support_functions_expression.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit { namespace lex
{
@@ -72,13 +70,14 @@ namespace boost { namespace spirit { namespace lex
};
// The function lex::less() is used to create a Phoenix actor allowing to
// implement functionality similar to flex' function yyless().
// implement functionality similar to flex' function yyless().
template <typename T>
inline phoenix::actor<less_type<typename phoenix::as_actor<T>::type> >
inline typename expression::less<
typename phoenix::as_actor<T>::type
>::type const
less(T const& v)
{
typedef typename phoenix::as_actor<T>::type actor_type;
return less_type<actor_type>(phoenix::as_actor<T>::convert(v));
return expression::less<T>::make(phoenix::as_actor<T>::convert(v));
}
///////////////////////////////////////////////////////////////////////////
@@ -115,10 +114,10 @@ namespace boost { namespace spirit { namespace lex
// The function lex::more() is used to create a Phoenix actor allowing to
// implement functionality similar to flex' function yymore().
inline phoenix::actor<more_type>
more()
//inline expression::more<mpl::void_>::type const
inline phoenix::actor<more_type> more()
{
return more_type();
return phoenix::actor<more_type>();
}
///////////////////////////////////////////////////////////////////////////
@@ -156,27 +155,27 @@ namespace boost { namespace spirit { namespace lex
// The function lex::lookahead() is used to create a Phoenix actor
// allowing to implement functionality similar to flex' lookahead operator
// a/b.
// a/b.
template <typename T>
inline phoenix::actor<
lookahead_type<
typename phoenix::as_actor<T>::type
, typename phoenix::as_actor<std::size_t>::type> >
inline typename expression::lookahead<
typename phoenix::as_actor<T>::type
, typename phoenix::as_actor<std::size_t>::type
>::type const
lookahead(T const& id)
{
typedef typename phoenix::as_actor<T>::type id_actor_type;
typedef typename phoenix::as_actor<std::size_t>::type state_actor_type;
return lookahead_type<id_actor_type, state_actor_type>(
return expression::lookahead<id_actor_type, state_actor_type>::make(
phoenix::as_actor<T>::convert(id),
phoenix::as_actor<std::size_t>::convert(std::size_t(~0)));
}
template <typename Attribute, typename Char, typename Idtype>
inline phoenix::actor<
lookahead_type<
typename phoenix::as_actor<Idtype>::type
, typename phoenix::as_actor<std::size_t>::type> >
inline typename expression::lookahead<
typename phoenix::as_actor<Idtype>::type
, typename phoenix::as_actor<std::size_t>::type
>::type const
lookahead(token_def<Attribute, Char, Idtype> const& tok)
{
typedef typename phoenix::as_actor<Idtype>::type id_actor_type;
@@ -189,8 +188,8 @@ namespace boost { namespace spirit { namespace lex
// lexer.
BOOST_ASSERT(std::size_t(~0) != state &&
"token_def instance not associated with lexer yet");
return lookahead_type<id_actor_type, state_actor_type>(
return expression::lookahead<id_actor_type, state_actor_type>::make(
phoenix::as_actor<Idtype>::convert(tok.id()),
phoenix::as_actor<std::size_t>::convert(state));
}

118
include/boost/spirit/home/lex/lexer/support_functions_expression.hpp Normal file
View File

@@ -0,0 +1,118 @@
// Copyright (c) 2001-2011 Hartmut Kaiser
// Copyright (c) 2011 Thomas Heller
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#if !defined(SPIRIT_LEX_SUPPORT_FUNCTIONS_EXPRESSION_MAR_22_2011_0711PM)
#define SPIRIT_LEX_SUPPORT_FUNCTIONS_EXPRESSION_MAR_22_2011_0711PM
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/spirit/include/phoenix_core.hpp>
namespace boost { namespace spirit { namespace lex
{
template <typename> struct less_type;
struct more_type;
template <typename, typename> struct lookahead_type;
}}}
BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
template <>
, boost::spirit::lex::more_type
, mpl::false_
, v2_eval(
proto::make<boost::spirit::lex::more_type()>
, proto::call<functional::env(proto::_state)>
)
)
///////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
namespace boost { namespace spirit { namespace lex
{
namespace expression
{
template <typename Eval>
struct less
{
typedef phoenix::actor<lex::less_type<Eval> > type;
static type make(Eval const & eval)
{
return lex::less_type<Eval>(eval);
}
};
template <typename IdType, typename State>
struct lookahead
{
typedef phoenix::actor<lex::lookahead_type<IdType, State> > type;
static type make(IdType const & id_type, State const & state)
{
return lex::lookahead_type<IdType, State>(id_type, state);
}
};
}
}}}
#else // BOOST_SPIRIT_USE_PHOENIX_V3
BOOST_PHOENIX_DEFINE_EXPRESSION(
(boost)(spirit)(lex)(less)
, (boost::phoenix::meta_grammar)
)
BOOST_PHOENIX_DEFINE_EXPRESSION(
(boost)(spirit)(lex)(lookahead)
, (boost::phoenix::meta_grammar)
(boost::phoenix::meta_grammar)
)
namespace boost { namespace phoenix
{
template <typename Dummy>
struct is_nullary::when<spirit::lex::rule::less, Dummy>
: proto::make<mpl::false_()>
{};
template <typename Dummy>
struct default_actions::when<spirit::lex::rule::less, Dummy>
: proto::call<
v2_eval(
spirit::lex::less_type<proto::_child0>(proto::_child0)
, _env
)
>
{};
template <typename Dummy>
struct is_nullary::when<spirit::lex::rule::lookahead, Dummy>
: proto::make<mpl::false_()>
{};
template <typename Dummy>
struct default_actions::when<spirit::lex::rule::lookahead, Dummy>
: proto::call<
v2_eval(
spirit::lex::lookahead_type<
proto::_child0
, proto::_child1
>(
proto::_child0
, proto::_child1
)
, _env
)
>
{};
}}
#endif // BOOST_SPIRIT_USE_PHOENIX_V3
#endif

18
include/boost/spirit/home/phoenix/core/argument.hpp
View File

@@ -21,10 +21,14 @@
#include <boost/mpl/size.hpp>
#include <boost/type_traits/add_reference.hpp>
#define PHOENIX_DECLARE_ARG(z, n, data) \
actor<argument<n> > const \
BOOST_PP_CAT(arg, BOOST_PP_INC(n)) = argument<n>(); \
actor<argument<n> > const \
#define PHOENIX_DECLARE_ARG(z, n, data) \
typedef actor<argument<n> > \
BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(n)), _type); \
actor<argument<n> > const \
BOOST_PP_CAT(arg, BOOST_PP_INC(n)) = argument<n>(); \
typedef actor<argument<n> > \
BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type); \
actor<argument<n> > const \
BOOST_PP_CAT(_, BOOST_PP_INC(n)) = argument<n>();
namespace boost { namespace phoenix
@@ -69,13 +73,19 @@ namespace boost { namespace phoenix
namespace arg_names
{
// Phoenix style names
typedef actor<argument<0> > arg1_type;
actor<argument<0> > const arg1 = argument<0>();
typedef actor<argument<1> > arg2_type;
actor<argument<1> > const arg2 = argument<1>();
typedef actor<argument<2> > arg3_type;
actor<argument<2> > const arg3 = argument<2>();
// BLL style names
typedef actor<argument<0> > _1_type;
actor<argument<0> > const _1 = argument<0>();
typedef actor<argument<1> > _2_type;
actor<argument<1> > const _2 = argument<1>();
typedef actor<argument<2> > _3_type;
actor<argument<2> > const _3 = argument<2>();
// Bring in the rest or the Phoenix style arguments (arg4 .. argN+1)

136
include/boost/spirit/home/support/action_dispatch.hpp
View File

@@ -13,7 +13,16 @@
#pragma once
#endif
#include <boost/spirit/home/phoenix/core/actor.hpp>
#include<boost/config.hpp>
#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_LAMBDAS) && \
!defined(BOOST_NO_VARIADIC_TEMPLATES) && !defined(BOOST_NO_DECLTYPE)
#include <utility>
#include <type_traits>
#endif
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/home/support/attributes.hpp>
namespace boost { namespace spirit { namespace traits
@@ -21,6 +30,130 @@ namespace boost { namespace spirit { namespace traits
template <typename Component>
struct action_dispatch
{
#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_LAMBDAS) && \
!defined(BOOST_NO_VARIADIC_TEMPLATES) && !defined(BOOST_NO_DECLTYPE)
// omit function parameters without specializing for each possible
// type of callable entity
// many thanks to Eelis/##iso-c++ for this contribution
private:
// this will be used to pass around POD types which are safe
// to go through the ellipsis operator (if ever used)
template <typename>
struct fwd_tag {};
// the first parameter is a placeholder to obtain SFINAE when
// doing overload resolution, the second one is the actual
// forwarder, where we can apply our implementation
template <typename, typename T>
struct fwd_storage { typedef T type; };
// gcc should accept fake<T>() but it prints a sorry, needs
// a check once the bug is sorted out, use a FAKE_CALL macro for now
template <typename T>
T fake_call();
#define BOOST_SPIRIT_FAKE_CALL(T) (*(T*)0)
// the forwarders, here we could tweak the implementation of
// how parameters are passed to the functions, if needed
struct fwd_none
{
template<typename F, typename... Rest>
auto operator()(F && f, Rest&&...) -> decltype(f())
{
return f();
}
};
struct fwd_attrib
{
template<typename F, typename A, typename... Rest>
auto operator()(F && f, A && a, Rest&&...) -> decltype(f(a))
{
return f(a);
}
};
struct fwd_attrib_context
{
template<typename F, typename A, typename B, typename... Rest>
auto operator()(F && f, A && a, B && b, Rest&&...)
-> decltype(f(a, b))
{
return f(a, b);
}
};
struct fwd_attrib_context_pass
{
template<typename F, typename A, typename B, typename C
, typename... Rest>
auto operator()(F && f, A && a, B && b, C && c, Rest&&...)
-> decltype(f(a, b, c))
{
return f(a, b, c);
}
};
// SFINAE for our calling syntax, the forwarders are stored based
// on what function call gives a proper result
// this code can probably be more generic once implementations are
// steady
template <typename F>
static auto do_call(F && f, ...)
-> typename fwd_storage<decltype(f()), fwd_none>::type
{
return {};
}
template <typename F, typename A>
static auto do_call(F && f, fwd_tag<A>, ...)
-> typename fwd_storage<decltype(f(BOOST_SPIRIT_FAKE_CALL(A)))
, fwd_attrib>::type
{
return {};
}
template <typename F, typename A, typename B>
static auto do_call(F && f, fwd_tag<A>, fwd_tag<B>, ...)
-> typename fwd_storage<
decltype(f(BOOST_SPIRIT_FAKE_CALL(A), BOOST_SPIRIT_FAKE_CALL(B)))
, fwd_attrib_context>::type
{
return {};
}
template <typename F, typename A, typename B, typename C>
static auto do_call(F && f, fwd_tag<A>, fwd_tag<B>, fwd_tag<C>, ...)
-> typename fwd_storage<
decltype(f(BOOST_SPIRIT_FAKE_CALL(A), BOOST_SPIRIT_FAKE_CALL(B)
, BOOST_SPIRIT_FAKE_CALL(C)))
, fwd_attrib_context_pass>::type
{
return {};
}
// this function calls the forwarder and is responsible for
// stripping the tail of the parameters
template <typename F, typename... A>
static void caller(F && f, A && ... a)
{
do_call(f, fwd_tag<typename std::remove_reference<A>::type>()...)
(std::forward<F>(f), std::forward<A>(a)...);
}
#undef BOOST_SPIRIT_FAKE_CALL
public:
template <typename F, typename Attribute, typename Context>
bool operator()(F const& f, Attribute& attr, Context& context)
{
bool pass = true;
caller(f, attr, context, pass);
return pass;
}
#else
// general handler for everything not explicitly specialized below
template <typename F, typename Attribute, typename Context>
bool operator()(F const& f, Attribute& attr, Context& context)
@@ -29,6 +162,7 @@ namespace boost { namespace spirit { namespace traits
f(attr, context, pass);
return pass;
}
#endif
// handler for phoenix actors

89
include/boost/spirit/home/support/argument.hpp
View File

@@ -1,5 +1,7 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2011 Thomas Heller
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -13,45 +15,79 @@
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/spirit/home/phoenix/core/actor.hpp>
#include <boost/spirit/home/phoenix/core/argument.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/home/support/assert_msg.hpp>
#include <boost/spirit/home/support/limits.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/fusion/include/size.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/at.hpp>
#if !defined(SPIRIT_ARGUMENTS_LIMIT)
# define SPIRIT_ARGUMENTS_LIMIT PHOENIX_LIMIT
#endif
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
#define SPIRIT_DECLARE_ARG(z, n, data) \
typedef phoenix::actor<argument<n> > const \
BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type); \
phoenix::actor<argument<n> > const \
BOOST_PP_CAT(_, BOOST_PP_INC(n)) = argument<n>();
#define SPIRIT_DECLARE_ARG(z, n, data) \
typedef phoenix::actor<argument<n> > const \
BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type); \
phoenix::actor<argument<n> > const \
BOOST_PP_CAT(_, BOOST_PP_INC(n)) = \
BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type)(); \
/***/
#define SPIRIT_USING_ARGUMENT(z, n, data) \
using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_, n), _type); \
using spirit::BOOST_PP_CAT(_, n);
#define SPIRIT_USING_ARGUMENT(z, n, data) \
using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_, n), _type); \
using spirit::BOOST_PP_CAT(_, n); \
/***/
#else
#define SPIRIT_DECLARE_ARG(z, n, data) \
typedef phoenix::actor<argument<n> > const \
BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type);
#define SPIRIT_DECLARE_ARG(z, n, data) \
typedef phoenix::actor<argument<n> > const \
BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type); \
/***/
#define SPIRIT_USING_ARGUMENT(z, n, data) \
using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_, n), _type); \
#define SPIRIT_USING_ARGUMENT(z, n, data) \
using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_, n), _type); \
/***/
#endif
namespace boost { namespace spirit
{
template <int N>
struct argument;
template <typename Dummy>
struct attribute_context;
}}
BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
template <int N>
, boost::spirit::argument<N>
, mpl::false_ // is not nullary
, v2_eval(
proto::make<
boost::spirit::argument<N>()
>
, proto::call<
functional::env(proto::_state)
>
)
)
BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
template <typename Dummy>
, boost::spirit::attribute_context<Dummy>
, mpl::false_ // is not nullary
, v2_eval(
proto::make<
boost::spirit::attribute_context<Dummy>()
>
, proto::call<
functional::env(proto::_state)
>
)
)
namespace boost { namespace spirit
{
namespace result_of
@@ -91,6 +127,7 @@ namespace boost { namespace spirit
return result_of::get_arg<T, N>::call(val);
}
template <typename>
struct attribute_context
{
typedef mpl::true_ no_nullary;
@@ -138,9 +175,9 @@ namespace boost { namespace spirit
};
// _0 refers to the whole attribute as generated by the lhs parser
typedef phoenix::actor<attribute_context> const _0_type;
typedef phoenix::actor<attribute_context<void> > const _0_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
_0_type _0 = attribute_context();
_0_type _0 = _0_type();
#endif
// _1, _2, ... refer to the attributes of the single components the lhs
@@ -150,15 +187,15 @@ namespace boost { namespace spirit
typedef phoenix::actor<argument<2> > const _3_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
_1_type _1 = argument<0>();
_2_type _2 = argument<1>();
_3_type _3 = argument<2>();
_1_type _1 = _1_type();
_2_type _2 = _2_type();
_3_type _3 = _3_type();
#endif
// '_pass' may be used to make a match fail in retrospective
typedef phoenix::actor<phoenix::argument<2> > const _pass_type;
typedef phoenix::arg_names::_3_type const _pass_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
_pass_type _pass = phoenix::argument<2>();
_pass_type _pass = _pass_type();
#endif
// Bring in the rest of the arguments and attributes (_4 .. _N+1), using PP

122
include/boost/spirit/home/support/argument_expression.hpp Normal file
View File

@@ -0,0 +1,122 @@
/*=============================================================================
Copyright (c) 2011 Thomas Heller
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2011 Thomas Heller
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_SPIRIT_ARGUMENT_MARCH_22_2011_0939PM)
#define BOOST_SPIRIT_ARGUMENT_MARCH_22_2011_0939PM
#include <boost/spirit/include/phoenix_core.hpp>
namespace boost { namespace spirit
{
template <int N>
struct argument;
template <typename Dummy>
struct attribute_context;
namespace expression
{
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
template <int N>
struct argument
{
typedef phoenix::actor<spirit::argument<N> > type;
static type make()
{
return spirit::argument<N>();
}
};
template <typename Dummy>
struct attribute_context
{
typedef phoenix::actor<spirit::attribute_context<Dummy> > type;
static type make()
{
return spirit::attribute_context<Dummy>();
}
};
#else
template <int N>
struct argument
: phoenix::expression::terminal<spirit::argument<N> >
{
typedef typename phoenix::expression::terminal<
spirit::argument<N>
>::type type;
static type make()
{
type const e = {{{}}};
return e;
}
};
template <typename Dummy>
struct attribute_context
: phoenix::expression::terminal<spirit::attribute_context<Dummy> >
{
typedef typename phoenix::expression::terminal<
spirit::attribute_context<Dummy>
>::type type;
static type make()
{
type const e = {{{}}};
return e;
}
};
#endif
}
}}
#ifdef BOOST_SPIRIT_USE_PHOENIX_V3
namespace boost { namespace phoenix
{
namespace result_of
{
template <typename Dummy>
struct is_nullary<custom_terminal<spirit::attribute_context<Dummy> > >
: mpl::false_
{};
template <int N>
struct is_nullary<custom_terminal<spirit::argument<N> > >
: mpl::false_
{};
}
template <typename Dummy>
struct is_custom_terminal<spirit::attribute_context<Dummy> >
: mpl::true_
{};
template <int N>
struct is_custom_terminal<spirit::argument<N> >
: mpl::true_
{};
template <typename Dummy>
struct custom_terminal<spirit::attribute_context<Dummy> >
: proto::call<
v2_eval(spirit::attribute_context<Dummy>(), _env)
>
{};
template <int N>
struct custom_terminal<spirit::argument<N> >
: proto::call<
v2_eval(spirit::argument<N>(), _env(proto::_, proto::_state, int()))
>
{};
}}
#endif // BOOST_SPIRIT_USE_PHOENIX_V3
#endif

1
include/boost/spirit/home/support/char_class.hpp
View File

@@ -269,6 +269,7 @@ namespace boost { namespace spirit { namespace tag
struct char_code
: char_code_base<CharClass>, char_encoding_base<CharEncoding>
{
typedef void is_spirit_tag;
typedef CharEncoding char_encoding; // e.g. ascii
typedef CharClass char_class; // e.g. tag::alnum
};

124
include/boost/spirit/home/support/context.hpp
View File

@@ -1,5 +1,7 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2011 Thomas Heller
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,11 +14,11 @@
#endif
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/home/support/nonterminal/expand_arg.hpp>
#include <boost/spirit/home/support/assert_msg.hpp>
#include <boost/spirit/home/support/argument.hpp>
#include <boost/spirit/home/phoenix/core/actor.hpp>
#include <boost/spirit/home/phoenix/core/argument.hpp>
#include <boost/spirit/home/support/limits.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/fusion/include/size.hpp>
#include <boost/fusion/include/as_list.hpp>
@@ -24,35 +26,69 @@
#include <boost/mpl/size.hpp>
#include <boost/mpl/at.hpp>
#if !defined(SPIRIT_ATTRIBUTES_LIMIT)
# define SPIRIT_ATTRIBUTES_LIMIT PHOENIX_LIMIT
#endif
///////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
#define SPIRIT_DECLARE_ATTRIBUTE(z, n, data) \
typedef phoenix::actor<attribute<n> > const \
BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type); \
phoenix::actor<attribute<n> > const \
BOOST_PP_CAT(_r, n) = attribute<n>();
#define SPIRIT_USING_ATTRIBUTE(z, n, data) \
using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type); \
using spirit::BOOST_PP_CAT(_r, n); \
#define SPIRIT_DECLARE_ATTRIBUTE(z, n, data) \
typedef phoenix::actor<attribute<n> > \
BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type); \
phoenix::actor<attribute<n> > const \
BOOST_PP_CAT(_r, n) = BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type)();
/***/
#define SPIRIT_USING_ATTRIBUTE(z, n, data) \
using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type); \
using spirit::BOOST_PP_CAT(_r, n); \
/***/
#else
#define SPIRIT_DECLARE_ATTRIBUTE(z, n, data) \
typedef phoenix::actor<attribute<n> > const \
BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type); \
#define SPIRIT_USING_ATTRIBUTE(z, n, data) \
using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type); \
#define SPIRIT_DECLARE_ATTRIBUTE(z, n, data) \
typedef phoenix::actor<attribute<n> > \
BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type); \
/***/
#define SPIRIT_USING_ATTRIBUTE(z, n, data) \
using spirit::BOOST_PP_CAT(BOOST_PP_CAT(_r, n), _type); \
/***/
#endif
namespace boost { namespace spirit
{
template <int>
struct attribute;
template <int>
struct local_variable;
}}
BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
template <int N>
, boost::spirit::attribute<N>
, mpl::false_ // is not nullary
, v2_eval(
proto::make<
boost::spirit::attribute<N>()
>
, proto::call<
functional::env(proto::_state)
>
)
)
BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
template <int N>
, boost::spirit::local_variable<N>
, mpl::false_ // is not nullary
, v2_eval(
proto::make<
boost::spirit::local_variable<N>()
>
, proto::call<
functional::env(proto::_state)
>
)
)
namespace boost { namespace spirit
{
template <typename Attributes, typename Locals>
@@ -99,6 +135,11 @@ namespace boost { namespace spirit
typedef typename Context::attributes_type const type;
};
template <typename Context>
struct attributes_of<Context &>
: attributes_of<Context>
{};
template <typename Context>
struct locals_of
{
@@ -111,6 +152,12 @@ namespace boost { namespace spirit
typedef typename Context::locals_type const type;
};
template <typename Context>
struct locals_of<Context &>
{
typedef typename Context::locals_type type;
};
template <int N>
struct attribute
{
@@ -182,21 +229,19 @@ namespace boost { namespace spirit
return get_arg<N>((fusion::at_c<1>(env.args())).locals);
}
};
typedef phoenix::actor<attribute<0> > const _val_type;
typedef phoenix::actor<attribute<0> > const _r0_type;
typedef phoenix::actor<attribute<1> > const _r1_type;
typedef phoenix::actor<attribute<2> > const _r2_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
// _val refers to the 'return' value of a rule (same as _r0)
// _r1, _r2, ... refer to the rule arguments
_val_type _val = attribute<0>();
_r0_type _r0 = attribute<0>();
_r1_type _r1 = attribute<1>();
_r2_type _r2 = attribute<2>();
_val_type _val = _val_type();
_r0_type _r0 = _r0_type();
_r1_type _r1 = _r1_type();
_r2_type _r2 = _r2_type();
#endif
// Bring in the rest of the attributes (_r4 .. _rN+1), using PP
@@ -215,20 +260,19 @@ namespace boost { namespace spirit
typedef phoenix::actor<local_variable<9> > const _j_type;
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
// _a, _b, ... refer to the local variables of a rule
_a_type _a = local_variable<0>();
_b_type _b = local_variable<1>();
_c_type _c = local_variable<2>();
_d_type _d = local_variable<3>();
_e_type _e = local_variable<4>();
_f_type _f = local_variable<5>();
_g_type _g = local_variable<6>();
_h_type _h = local_variable<7>();
_i_type _i = local_variable<8>();
_j_type _j = local_variable<9>();
_a_type _a = _a_type();
_b_type _b = _b_type();
_c_type _c = _c_type();
_d_type _d = _d_type();
_e_type _e = _e_type();
_f_type _f = _f_type();
_g_type _g = _g_type();
_h_type _h = _h_type();
_i_type _i = _i_type();
_j_type _j = _j_type();
#endif
// You can bring these in with the using directive
// without worrying about bringing in too much.
namespace labels

35
include/boost/spirit/home/support/limits.hpp Normal file
View File

@@ -0,0 +1,35 @@
// Copyright (c) 2001-2011 Hartmut Kaiser
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#if !defined(BOOST_SPIRIT_SUPPORT_LIMITS_MAR_26_2011_0833PM)
#define BOOST_SPIRIT_SUPPORT_LIMITS_MAR_26_2011_0833PM
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/spirit/include/phoenix_core.hpp>
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#if !defined(SPIRIT_ARGUMENTS_LIMIT)
# define SPIRIT_ARGUMENTS_LIMIT PHOENIX_LIMIT
#endif
#if !defined(SPIRIT_ATTRIBUTES_LIMIT)
# define SPIRIT_ATTRIBUTES_LIMIT PHOENIX_LIMIT
#endif
#else
#if !defined(SPIRIT_ARGUMENTS_LIMIT)
# define SPIRIT_ARGUMENTS_LIMIT BOOST_PHOENIX_LIMIT
#endif
#if !defined(SPIRIT_ATTRIBUTES_LIMIT)
# define SPIRIT_ATTRIBUTES_LIMIT BOOST_PHOENIX_LIMIT
#endif
#endif
#endif

70
include/boost/spirit/home/support/make_component.hpp
View File

@@ -12,6 +12,7 @@
#pragma once
#endif
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/proto/proto.hpp>
#include <boost/spirit/home/support/detail/make_cons.hpp>
#include <boost/spirit/home/support/modify.hpp>
@@ -321,11 +322,25 @@ namespace boost { namespace spirit { namespace detail
)>::type
lhs_component;
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
typedef typename
proto::result_of::value<
typename proto::result_of::child_c<Expr, 1>::type
>::type
rhs_component;
#else
typedef
typename mpl::eval_if_c<
phoenix::is_actor<
typename proto::result_of::child_c<Expr, 1>::type
>::type::value
, proto::result_of::child_c<Expr, 1>
, proto::result_of::value<
typename proto::result_of::child_c<Expr, 1>::type
>
>::type
rhs_component;
#endif
typedef typename
result_of::make_cons<
@@ -341,6 +356,7 @@ namespace boost { namespace spirit { namespace detail
result<make_component_(elements_type, Data)>::type
result_type;
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
result_type operator()(
typename impl::expr_param expr
, typename impl::state_param state
@@ -357,6 +373,60 @@ namespace boost { namespace spirit { namespace detail
return make_component_()(elements, data);
}
#else
result_type operator()(
typename impl::expr_param expr
, typename impl::state_param state
, typename impl::data_param data
) const
{
return
(*this)(
expr
, state
, data
, typename phoenix::is_actor<
typename proto::result_of::child_c<Expr, 1>::type
>::type()
);
}
result_type operator()(
typename impl::expr_param expr
, typename impl::state_param state
, typename impl::data_param data
, mpl::false_
) const
{
elements_type elements =
detail::make_cons(
Grammar()(
proto::child_c<0>(expr), state, data) // LHS
, detail::make_cons(
proto::value(proto::child_c<1>(expr))) // RHS
);
return make_component_()(elements, data);
}
result_type operator()(
typename impl::expr_param expr
, typename impl::state_param state
, typename impl::data_param data
, mpl::true_
) const
{
elements_type elements =
detail::make_cons(
Grammar()(
proto::child_c<0>(expr), state, data) // LHS
, detail::make_cons(
proto::child_c<1>(expr)) // RHS
);
return make_component_()(elements, data);
}
#endif
};
};
}}}

142
include/boost/spirit/home/support/terminal.hpp
View File

@@ -1,5 +1,7 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2011 Thomas Heller
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -11,15 +13,17 @@
#pragma once
#endif
#include <boost/proto/proto.hpp>
#include <boost/fusion/include/void.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/proto/proto.hpp>
#include <boost/fusion/include/void.hpp>
#include <boost/spirit/home/support/meta_compiler.hpp>
#include <boost/spirit/home/support/detail/make_vector.hpp>
#include <boost/spirit/home/support/unused.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/spirit/home/support/terminal_expression.hpp>
namespace boost { namespace spirit
{
template <typename Terminal, typename Args>
@@ -84,11 +88,7 @@ namespace boost { namespace spirit
proto::terminal<
lazy_terminal<
typename F::terminal_type
, phoenix::actor<
typename phoenix::as_composite<
phoenix::detail::function_eval<1>, F, A0
>::type
>
, typename phoenix::expression::function<F, A0>::type
, 1 // arity
>
>::type
@@ -100,7 +100,7 @@ namespace boost { namespace spirit
{
typedef typename result_type::proto_child0 child_type;
return result_type::make(child_type(
phoenix::compose<phoenix::detail::function_eval<1> >(f, _0)
phoenix::expression::function<F, A0>::make(f, _0)
, f.proto_base().child0
));
}
@@ -113,11 +113,7 @@ namespace boost { namespace spirit
proto::terminal<
lazy_terminal<
typename F::terminal_type
, phoenix::actor<
typename phoenix::as_composite<
phoenix::detail::function_eval<2>, F, A0, A1
>::type
>
, typename phoenix::expression::function<F, A0, A1>::type
, 2 // arity
>
>::type
@@ -129,7 +125,7 @@ namespace boost { namespace spirit
{
typedef typename result_type::proto_child0 child_type;
return result_type::make(child_type(
phoenix::compose<phoenix::detail::function_eval<2> >(f, _0, _1)
phoenix::expression::function<F, A0, A1>::make(f, _0, _1)
, f.proto_base().child0
));
}
@@ -142,11 +138,7 @@ namespace boost { namespace spirit
proto::terminal<
lazy_terminal<
typename F::terminal_type
, phoenix::actor<
typename phoenix::as_composite<
phoenix::detail::function_eval<3>, F, A0, A1, A2
>::type
>
, typename phoenix::expression::function<F, A0, A1, A2>::type
, 3 // arity
>
>::type
@@ -158,7 +150,7 @@ namespace boost { namespace spirit
{
typedef typename result_type::proto_child0 child_type;
return result_type::make(child_type(
phoenix::compose<phoenix::detail::function_eval<3> >(f, _0, _1, _2)
phoenix::expression::function<F, A0, A1, A2>::make(f, _0, _1, _2)
, f.proto_base().child0
));
}
@@ -167,14 +159,19 @@ namespace boost { namespace spirit
namespace detail
{
// Helper struct for SFINAE purposes
template <bool C>
struct bool_;
template <bool C> struct bool_;
template <>
struct bool_<true> : mpl::bool_<true>
{ typedef bool_<true>* is_true; };
{
typedef bool_<true>* is_true;
};
template <>
struct bool_<false> : mpl::bool_<false>
{ typedef bool_<false>* is_false; };
{
typedef bool_<false>* is_false;
};
// Metafunction to detect if at least one arg is a Phoenix actor
template <
@@ -184,10 +181,10 @@ namespace boost { namespace spirit
>
struct contains_actor
: bool_<
phoenix::is_actor<A0>::value
|| phoenix::is_actor<A1>::value
|| phoenix::is_actor<A2>::value
>
phoenix::is_actor<A0>::value
|| phoenix::is_actor<A1>::value
|| phoenix::is_actor<A2>::value
>
{};
// to_lazy_arg: convert a terminal arg type to the type make_lazy needs
@@ -200,6 +197,11 @@ namespace boost { namespace spirit
struct to_lazy_arg<const A>
: to_lazy_arg<A>
{};
template <typename A>
struct to_lazy_arg<A &>
: to_lazy_arg<A>
{};
template <>
struct to_lazy_arg<unused_type>
@@ -221,6 +223,11 @@ namespace boost { namespace spirit
: to_nonlazy_arg<A>
{};
template <typename A>
struct to_nonlazy_arg<A &>
: to_nonlazy_arg<A>
{};
template <>
struct to_nonlazy_arg<unused_type>
{
@@ -247,7 +254,8 @@ namespace boost { namespace spirit
terminal() {}
terminal(Terminal const& t)
: base_type(proto::terminal<Terminal>::type::make(t)) {}
: base_type(proto::terminal<Terminal>::type::make(t))
{}
template <
bool Lazy
@@ -307,6 +315,40 @@ namespace boost { namespace spirit
type;
};
template <typename This, typename A0>
struct result<This(A0)>
{
typedef typename
result_helper<
detail::contains_actor<A0, unused_type, unused_type>::value
, A0, unused_type, unused_type
>::type
type;
};
template <typename This, typename A0, typename A1>
struct result<This(A0, A1)>
{
typedef typename
result_helper<
detail::contains_actor<A0, A1, unused_type>::value
, A0, A1, unused_type
>::type
type;
};
template <typename This, typename A0, typename A1, typename A2>
struct result<This(A0, A1, A2)>
{
typedef typename
result_helper<
detail::contains_actor<A0, A1, A2>::value
, A0, A1, A2
>::type
type;
};
// Note: in the following overloads, SFINAE cannot
// be done on return type because of gcc bug #24915:
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24915
@@ -360,7 +402,6 @@ namespace boost { namespace spirit
// Lazy overloads. Enabled when at
// least one arg is a Phoenix actor.
template <typename A0>
typename result<A0>::type
operator()(A0 const& _0
@@ -441,10 +482,13 @@ namespace boost { namespace spirit
// support for stateful tag types
namespace tag
{
template <typename Data, typename Tag
template <
typename Data, typename Tag
, typename DataTag1 = unused_type, typename DataTag2 = unused_type>
struct stateful_tag
{
typedef void is_spirit_tag;
typedef Data data_type;
stateful_tag() {}
@@ -458,7 +502,8 @@ namespace boost { namespace spirit
};
}
template <typename Data, typename Tag
template <
typename Data, typename Tag
, typename DataTag1 = unused_type, typename DataTag2 = unused_type>
struct stateful_tag_type
: spirit::terminal<tag::stateful_tag<Data, Tag, DataTag1, DataTag2> >
@@ -467,7 +512,8 @@ namespace boost { namespace spirit
stateful_tag_type() {}
stateful_tag_type(Data const& data)
: spirit::terminal<tag_type>(data) {}
: spirit::terminal<tag_type>(data)
{}
private:
// silence MSVC warning C4512: assignment operator could not be generated
@@ -493,6 +539,28 @@ namespace boost { namespace spirit
}}
#ifdef BOOST_SPIRIT_USE_PHOENIX_V3
namespace boost { namespace phoenix
{
template <typename Tag>
struct is_custom_terminal<Tag, typename Tag::is_spirit_tag>
: mpl::true_
{};
template <typename Tag>
struct custom_terminal<Tag, typename Tag::is_spirit_tag>
{
typedef spirit::terminal<Tag> result_type;
template <typename Context>
result_type operator()(Tag const & t, Context const &)
{
return spirit::terminal<Tag>(t);
}
};
}}
#endif
// Define a spirit terminal. This macro may be placed in any namespace.
// Common placeholders are placed in the main boost::spirit namespace
// (see common_terminals.hpp)
@@ -505,7 +573,7 @@ namespace boost { namespace spirit
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
#define BOOST_SPIRIT_TERMINAL_NAME(name, type_name) \
namespace tag { struct name {}; } \
namespace tag { struct name { typedef void is_spirit_tag; }; } \
typedef boost::proto::terminal<tag::name>::type type_name; \
type_name const name = {{}}; \
inline void BOOST_PP_CAT(silence_unused_warnings_, name)() { (void) name; } \
@@ -514,7 +582,7 @@ namespace boost { namespace spirit
#else
#define BOOST_SPIRIT_TERMINAL_NAME(name, type_name) \
namespace tag { struct name {}; } \
namespace tag { struct name { typedef void is_spirit_tag; }; } \
typedef boost::proto::terminal<tag::name>::type type_name; \
/***/
@@ -543,7 +611,7 @@ namespace boost { namespace spirit
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
#define BOOST_SPIRIT_TERMINAL_NAME_EX(name, type_name) \
namespace tag { struct name {}; } \
namespace tag { struct name { typedef void is_spirit_tag; }; } \
typedef boost::spirit::terminal<tag::name> type_name; \
type_name const name = type_name(); \
inline void BOOST_PP_CAT(silence_unused_warnings_, name)() { (void) name; } \
@@ -552,7 +620,7 @@ namespace boost { namespace spirit
#else
#define BOOST_SPIRIT_TERMINAL_NAME_EX(name, type_name) \
namespace tag { struct name {}; } \
namespace tag { struct name { typedef void is_spirit_tag; }; } \
typedef boost::spirit::terminal<tag::name> type_name; \
/***/

75
include/boost/spirit/home/support/terminal_expression.hpp Normal file
View File

@@ -0,0 +1,75 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2011 Thomas Heller
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_SPIRIT_TERMINAL_EXPRESSION_MARCH_24_2011_1210AM)
#define BOOST_SPIRIT_TERMINAL_EXPRESSION_MARCH_24_2011_1210AM
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
namespace boost { namespace phoenix
{
namespace expression
{
template <
typename F, typename A0 = void, typename A1 = void
, typename A2 = void, typename Dummy = void>
struct function;
template <typename F, typename A0>
struct function<F, A0>
{
typedef phoenix::actor<
typename phoenix::as_composite<
phoenix::detail::function_eval<1>, F, A0
>::type
> type;
static type make(F f, A0 const & _0)
{
return phoenix::compose<
phoenix::detail::function_eval<1> >(f, _0);
}
};
template <typename F, typename A0, typename A1>
struct function<F, A0, A1>
{
typedef phoenix::actor<
typename phoenix::as_composite<
phoenix::detail::function_eval<2>, F, A0, A1
>::type
> type;
static type make(F f, A0 const & _0, A1 const & _1)
{
return phoenix::compose<
phoenix::detail::function_eval<2> >(f, _0, _1);
}
};
template <typename F, typename A0, typename A1, typename A2>
struct function<F, A0, A1, A2>
{
typedef phoenix::actor<
typename phoenix::as_composite<
phoenix::detail::function_eval<3>, F, A0, A1, A2
>::type
> type;
static type make(F f, A0 const & _0, A1 const & _1, A2 const & _2)
{
return phoenix::compose<
phoenix::detail::function_eval<3> >(f, _0, _1, _2);
}
};
}
}}
#endif // !BOOST_SPIRIT_USE_PHOENIX_V3
#endif

6
include/boost/spirit/include/phoenix.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX
#define BOOST_SPIRIT_INCLUDE_PHOENIX
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix.hpp>
#else
#include <boost/phoenix.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_algorithm.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_ALGORITHM
#define BOOST_SPIRIT_INCLUDE_PHOENIX_ALGORITHM
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/algorithm.hpp>
#else
#include <boost/phoenix/algorithm.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_bind.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_BIND
#define BOOST_SPIRIT_INCLUDE_PHOENIX_BIND
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/bind.hpp>
#else
#include <boost/phoenix/bind.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_container.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_CONTAINER
#define BOOST_SPIRIT_INCLUDE_PHOENIX_CONTAINER
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/container.hpp>
#else
#include <boost/phoenix/container.hpp>
#endif
#endif

7
include/boost/spirit/include/phoenix_core.hpp
View File

@@ -8,5 +8,12 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_CORE
#define BOOST_SPIRIT_INCLUDE_PHOENIX_CORE
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#define BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(A,B,C,D)
#include <boost/spirit/home/phoenix/core.hpp>
#else
#include <boost/phoenix/core.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_function.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_FUNCTION
#define BOOST_SPIRIT_INCLUDE_PHOENIX_FUNCTION
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/function.hpp>
#else
#include <boost/phoenix/function.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_fusion.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_FUSION
#define BOOST_SPIRIT_INCLUDE_PHOENIX_FUSION
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/fusion.hpp>
#else
#include <boost/phoenix/fusion.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_object.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_OBJECT
#define BOOST_SPIRIT_INCLUDE_PHOENIX_OBJECT
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/object.hpp>
#else
#include <boost/phoenix/object.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_operator.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_OPERATOR
#define BOOST_SPIRIT_INCLUDE_PHOENIX_OPERATOR
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/operator.hpp>
#else
#include <boost/phoenix/operator.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_scope.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_SCOPE
#define BOOST_SPIRIT_INCLUDE_PHOENIX_SCOPE
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/scope.hpp>
#else
#include <boost/phoenix/scope.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_statement.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_STATEMENT
#define BOOST_SPIRIT_INCLUDE_PHOENIX_STATEMENT
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/statement.hpp>
#else
#include <boost/phoenix/statement.hpp>
#endif
#endif

6
include/boost/spirit/include/phoenix_stl.hpp
View File

@@ -8,5 +8,11 @@
=============================================================================*/
#ifndef BOOST_SPIRIT_INCLUDE_PHOENIX_STL
#define BOOST_SPIRIT_INCLUDE_PHOENIX_STL
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/home/phoenix/stl.hpp>
#else
#include <boost/phoenix/stl.hpp>
#endif
#endif

51
test/Jamfile
View File

@@ -7,6 +7,26 @@
# License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#==============================================================================
# bring in rules for testing
import testing ;
import modules ;
import feature ;
###############################################################################
# new feature definition allowing to switch between Phoenix V2 and V3 tests
feature.feature phoenix_v3
: on
: optional composite propagated
;
feature.compose <phoenix_v3>on
: <define>BOOST_SPIRIT_USE_PHOENIX_V3=1
<define>BOOST_PROTO_MAX_ARITY=11
<define>BOOST_PROTO_MAX_LOGICAL_ARITY=11
;
###############################################################################
project spirit_v2x/test
: requirements
<include>.
@@ -16,10 +36,35 @@ project spirit_v2x/test
:
;
path-constant LEX_DIR : $(BOOST_ROOT)/libs/spirit/test/lex ;
# use this alias to buil Spirit against Phoenix V2
alias test_using_phoenix_v2
: spirit_v2/qi
spirit_v2/qi_regressions
spirit_v2/karma
spirit_v2/karma_regressions
spirit_v2/lex
spirit_v2/lex_regressions
spirit_v2/support
spirit_v2/support_regressions
;
# bring in rules for testing
import testing ;
# use this alias to buil Spirit against Phoenix V3
alias test_using_phoenix_v3
: spirit_v2/qi
spirit_v2/qi_regressions
spirit_v2/karma
spirit_v2/karma_regressions
spirit_v2/lex
spirit_v2/lex_regressions
spirit_v2/support
spirit_v2/support_regressions
: <phoenix_v3>on
;
explicit test_using_phoenix_v2 test_using_phoenix_v3 ;
###############################################################################
path-constant LEX_DIR : $(BOOST_ROOT)/libs/spirit/test/lex ;
{
###########################################################################

7
test/karma/sequence2.cpp
View File

@@ -34,10 +34,15 @@ using namespace spirit_test;
struct seqsize_impl
{
template <typename Sequence>
struct result
struct result
: boost::fusion::result_of::size<Sequence>
{};
template <typename This, typename Sequence>
struct result<This(Sequence)>
: result<typename boost::proto::detail::uncvref<Sequence>::type>
{};
template <typename Sequence>
typename result<Sequence>::type
operator()(Sequence const& seq) const

2
test/karma/utree1.cpp
View File

@@ -10,8 +10,8 @@
#include <boost/mpl/print.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <sstream>

2
test/karma/utree2.cpp
View File

@@ -10,8 +10,8 @@
#include <boost/mpl/print.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <sstream>

2
test/karma/utree3.cpp
View File

@@ -10,8 +10,8 @@
#include <boost/mpl/print.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <sstream>

8
test/lex/auto_switch_lexerstate.cpp
View File

@@ -15,16 +15,12 @@
#include <boost/config/warning_disable.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/support_multi_pass.hpp>
#include <boost/spirit/include/classic_position_iterator.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/home/phoenix/core.hpp>
#include <boost/spirit/home/phoenix/operator.hpp>
#include <boost/spirit/home/phoenix/statement.hpp>
#include <boost/spirit/home/phoenix/object.hpp>
#include <boost/spirit/home/phoenix/stl.hpp>
namespace spirit = boost::spirit;
namespace lex = spirit::lex;
namespace phoenix = boost::phoenix;

5
test/lex/id_type_enum.cpp
View File

@@ -11,10 +11,7 @@
#include <boost/spirit/include/classic_position_iterator.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/home/phoenix/core.hpp>
#include <boost/spirit/home/phoenix/operator.hpp>
#include <boost/spirit/home/phoenix/statement.hpp>
#include <boost/spirit/home/phoenix/object.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace spirit = boost::spirit;
namespace lex = spirit::lex;

2
test/lex/lexer_state_switcher.cpp
View File

@@ -26,7 +26,7 @@ struct switch_state_tokens : boost::spirit::lex::lexer<Lexer>
this->self = identifier [ phoenix::ref(state_) = _state ];
integer = "[0-9]+";
this->self("INT") = integer [ _state = phoenix::val("INITIAL") ];
this->self("INT") = integer [ _state = "INITIAL" ];
}
std::string state_;

10
test/lex/regression_file_iterator1.cpp
View File

@@ -13,11 +13,7 @@
#include <boost/spirit/include/classic_position_iterator.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/home/phoenix/core.hpp>
#include <boost/spirit/home/phoenix/operator.hpp>
#include <boost/spirit/home/phoenix/statement.hpp>
#include <boost/spirit/home/phoenix/object.hpp>
#include <boost/spirit/home/phoenix/stl.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace spirit = boost::spirit;
namespace lex = spirit::lex;
@@ -41,14 +37,14 @@ make_file_iterator(std::istream& input, const std::string& filename)
struct identifier
{
identifier(file_iterator begin, file_iterator end)
identifier(file_iterator, file_iterator)
{
}
};
struct string_literal
{
string_literal(file_iterator begin, file_iterator end)
string_literal(file_iterator, file_iterator)
{
}
};

10
test/lex/regression_file_iterator2.cpp
View File

@@ -13,11 +13,7 @@
#include <boost/spirit/include/classic_position_iterator.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/home/phoenix/core.hpp>
#include <boost/spirit/home/phoenix/operator.hpp>
#include <boost/spirit/home/phoenix/statement.hpp>
#include <boost/spirit/home/phoenix/object.hpp>
#include <boost/spirit/home/phoenix/stl.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace spirit = boost::spirit;
namespace lex = spirit::lex;
@@ -39,14 +35,14 @@ make_file_iterator(std::istream& input, const std::string& filename)
struct identifier
{
identifier(file_iterator begin, file_iterator end)
identifier(file_iterator, file_iterator)
{
}
};
struct string_literal
{
string_literal(file_iterator begin, file_iterator end)
string_literal(file_iterator, file_iterator)
{
}
};

11
test/lex/regression_file_iterator3.cpp
View File

@@ -14,10 +14,11 @@
#include <boost/spirit/include/classic_position_iterator.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/home/phoenix/core.hpp>
#include <boost/spirit/home/phoenix/operator.hpp>
#include <boost/spirit/home/phoenix/statement.hpp>
#include <boost/spirit/home/phoenix/object.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <sstream>
@@ -43,7 +44,7 @@ make_file_iterator(std::istream& input, const std::string& filename)
struct string_literal
{
string_literal(file_iterator begin, file_iterator end)
string_literal(file_iterator, file_iterator)
{
}
};

5
test/lex/regression_file_iterator4.cpp
View File

@@ -17,10 +17,7 @@
#include <boost/spirit/include/classic_position_iterator.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/home/phoenix/core.hpp>
#include <boost/spirit/home/phoenix/operator.hpp>
#include <boost/spirit/home/phoenix/statement.hpp>
#include <boost/spirit/home/phoenix/object.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace spirit = boost::spirit;
namespace lex = spirit::lex;

1
test/lex/regression_wide.cpp
View File

@@ -59,6 +59,7 @@ test_data data[] =
///////////////////////////////////////////////////////////////////////////////
struct test_impl
{
typedef void result_type;
template <typename TokenId, typename Value>
struct result { typedef void type; };

3
test/lex/regression_word_count.cpp
View File

@@ -12,9 +12,8 @@
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
#include <boost/spirit/include/phoenix_container.hpp>
#include <iostream>
#include <string>

1
test/support/utree.cpp
View File

@@ -11,6 +11,7 @@
#include <boost/detail/lightweight_test.hpp>
#include <boost/functional/hash.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <iostream>