| /////////////////////////////////////////////////////////////////////////////// |
| // proto::make_expr.hpp |
| // |
| // Copyright 2008 Eric Niebler. 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) |
| |
| #include <sstream> |
| #include <boost/proto/core.hpp> |
| #include <boost/proto/transform.hpp> |
| #include <boost/utility/addressof.hpp> |
| #include <boost/fusion/tuple.hpp> |
| #include <boost/test/unit_test.hpp> |
| |
| namespace fusion = boost::fusion; |
| namespace proto = boost::proto; |
| |
| template<typename E> struct ewrap; |
| |
| struct mydomain |
| : proto::domain<proto::generator<ewrap> > |
| {}; |
| |
| template<typename E> struct ewrap |
| : proto::extends<E, ewrap<E>, mydomain> |
| { |
| explicit ewrap(E const &e = E()) |
| : proto::extends<E, ewrap<E>, mydomain>(e) |
| {} |
| }; |
| |
| void test_make_expr() |
| { |
| int i = 42; |
| proto::terminal<int>::type t1 = proto::make_expr<proto::tag::terminal>(1); |
| proto::terminal<int>::type t2 = proto::make_expr<proto::tag::terminal>(i); |
| proto::unary_plus<proto::terminal<int>::type>::type p1 = proto::make_expr<proto::tag::unary_plus>(1); |
| proto::unary_plus<proto::terminal<int>::type>::type p2 = proto::make_expr<proto::tag::unary_plus>(i); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p2)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::unary_plus |
| , proto::list1< |
| ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int> > > |
| > |
| > |
| > |
| p3_type; |
| p3_type p3 = proto::make_expr<proto::tag::unary_plus, mydomain>(i); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p3)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::plus |
| , proto::list2< |
| p3_type |
| , ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int> > > |
| > |
| > |
| > |
| p4_type; |
| p4_type p4 = proto::make_expr<proto::tag::plus>(p3, 0); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(proto::left(p4))), 42); |
| } |
| |
| void test_make_expr_ref() |
| { |
| int i = 42; |
| int const ci = 84; |
| proto::terminal<int const &>::type t1 = proto::make_expr<proto::tag::terminal>(boost::cref(ci)); |
| proto::terminal<int &>::type t2 = proto::make_expr<proto::tag::terminal>(boost::ref(i)); |
| BOOST_CHECK_EQUAL(&i, &proto::value(t2)); |
| proto::unary_plus<proto::terminal<int const &>::type>::type p1 = proto::make_expr<proto::tag::unary_plus>(boost::cref(ci)); |
| proto::unary_plus<proto::terminal<int &>::type>::type p2 = proto::make_expr<proto::tag::unary_plus>(boost::ref(i)); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p2)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::unary_plus |
| , proto::list1< |
| ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int &> > > |
| > |
| > |
| > |
| p3_type; |
| p3_type p3 = proto::make_expr<proto::tag::unary_plus, mydomain>(boost::ref(i)); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p3)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::plus |
| , proto::list2< |
| p3_type & |
| , ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int> > > |
| > |
| > |
| > |
| p4_type; |
| p4_type p4 = proto::make_expr<proto::tag::plus>(boost::ref(p3), 0); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(proto::left(p4))), 42); |
| } |
| |
| void test_make_expr_functional() |
| { |
| int i = 42; |
| proto::terminal<int>::type t1 = proto::functional::make_expr<proto::tag::terminal>()(1); |
| proto::terminal<int>::type t2 = proto::functional::make_expr<proto::tag::terminal>()(i); |
| proto::unary_plus<proto::terminal<int>::type>::type p1 = proto::functional::make_expr<proto::tag::unary_plus>()(1); |
| proto::unary_plus<proto::terminal<int>::type>::type p2 = proto::functional::make_expr<proto::tag::unary_plus>()(i); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p2)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::unary_plus |
| , proto::list1< |
| ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int> > > |
| > |
| > |
| > |
| p3_type; |
| p3_type p3 = proto::functional::make_expr<proto::tag::unary_plus, mydomain>()(i); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p3)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::plus |
| , proto::list2< |
| p3_type |
| , ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int> > > |
| > |
| > |
| > |
| p4_type; |
| p4_type p4 = proto::functional::make_expr<proto::tag::plus>()(p3, 0); |
| } |
| |
| void test_make_expr_functional_ref() |
| { |
| int i = 42; |
| int const ci = 84; |
| proto::terminal<int const &>::type t1 = proto::functional::make_expr<proto::tag::terminal>()(boost::cref(ci)); |
| proto::terminal<int &>::type t2 = proto::functional::make_expr<proto::tag::terminal>()(boost::ref(i)); |
| BOOST_CHECK_EQUAL(&i, &proto::value(t2)); |
| proto::unary_plus<proto::terminal<int const &>::type>::type p1 = proto::functional::make_expr<proto::tag::unary_plus>()(boost::cref(ci)); |
| proto::unary_plus<proto::terminal<int &>::type>::type p2 = proto::functional::make_expr<proto::tag::unary_plus>()(boost::ref(i)); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p2)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::unary_plus |
| , proto::list1< |
| ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int &> > > |
| > |
| > |
| > |
| p3_type; |
| p3_type p3 = proto::functional::make_expr<proto::tag::unary_plus, mydomain>()(boost::ref(i)); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p3)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::plus |
| , proto::list2< |
| p3_type & |
| , ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int> > > |
| > |
| > |
| > |
| p4_type; |
| p4_type p4 = proto::functional::make_expr<proto::tag::plus>()(boost::ref(p3), 0); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(proto::left(p4))), 42); |
| } |
| |
| void test_unpack_expr() |
| { |
| int i = 42; |
| proto::terminal<int>::type t1 = proto::unpack_expr<proto::tag::terminal>(fusion::make_tuple(1)); |
| proto::terminal<int &>::type t2 = proto::unpack_expr<proto::tag::terminal>(fusion::make_tuple(boost::ref(i))); |
| proto::unary_plus<proto::terminal<int>::type>::type p1 = proto::unpack_expr<proto::tag::unary_plus>(fusion::make_tuple(1)); |
| proto::unary_plus<proto::terminal<int &>::type>::type p2 = proto::unpack_expr<proto::tag::unary_plus>(fusion::make_tuple(boost::ref(i))); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p2)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::unary_plus |
| , proto::list1< |
| ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int &> > > |
| > |
| > |
| > |
| p3_type; |
| p3_type p3 = proto::unpack_expr<proto::tag::unary_plus, mydomain>(fusion::make_tuple(boost::ref(i))); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p3)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::plus |
| , proto::list2< |
| p3_type & |
| , ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int> > > |
| > |
| > |
| > |
| p4_type; |
| p4_type p4 = proto::unpack_expr<proto::tag::plus>(fusion::make_tuple(boost::ref(p3), 0)); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(proto::left(p4))), 42); |
| } |
| |
| void test_unpack_expr_functional() |
| { |
| int i = 42; |
| proto::terminal<int>::type t1 = proto::functional::unpack_expr<proto::tag::terminal>()(fusion::make_tuple(1)); |
| proto::terminal<int &>::type t2 = proto::functional::unpack_expr<proto::tag::terminal>()(fusion::make_tuple(boost::ref(i))); |
| proto::unary_plus<proto::terminal<int>::type>::type p1 = proto::functional::unpack_expr<proto::tag::unary_plus>()(fusion::make_tuple(1)); |
| proto::unary_plus<proto::terminal<int &>::type>::type p2 = proto::functional::unpack_expr<proto::tag::unary_plus>()(fusion::make_tuple(boost::ref(i))); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p2)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::unary_plus |
| , proto::list1< |
| ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int &> > > |
| > |
| > |
| > |
| p3_type; |
| p3_type p3 = proto::functional::unpack_expr<proto::tag::unary_plus, mydomain>()(fusion::make_tuple(boost::ref(i))); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(p3)), 42); |
| |
| typedef |
| ewrap< |
| proto::basic_expr< |
| proto::tag::plus |
| , proto::list2< |
| p3_type & |
| , ewrap<proto::basic_expr<proto::tag::terminal, proto::term<int> > > |
| > |
| > |
| > |
| p4_type; |
| p4_type p4 = proto::functional::unpack_expr<proto::tag::plus>()(fusion::make_tuple(boost::ref(p3), 0)); |
| BOOST_CHECK_EQUAL(proto::value(proto::child(proto::left(p4))), 42); |
| } |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) |
| #define _byref(x) call<proto::_byref(x)> |
| #define _byval(x) call<proto::_byval(x)> |
| #define Minus(x) proto::call<Minus(x)> |
| #endif |
| |
| // Turn all terminals held by reference into ones held by value |
| struct ByVal |
| : proto::or_< |
| proto::when<proto::terminal<proto::_>, proto::_make_terminal(proto::_byval(proto::_value))> |
| , proto::when<proto::nary_expr<proto::_, proto::vararg<ByVal> > > |
| > |
| {}; |
| |
| // Turn all terminals held by value into ones held by reference (not safe in general) |
| struct ByRef |
| : proto::or_< |
| proto::when<proto::terminal<proto::_>, proto::_make_terminal(proto::_byref(proto::_value))> |
| , proto::when<proto::nary_expr<proto::_, proto::vararg<ByRef> > > |
| > |
| {}; |
| |
| // turn all proto::plus nodes to minus nodes: |
| struct Minus |
| : proto::or_< |
| proto::when<proto::terminal<proto::_> > |
| , proto::when<proto::plus<Minus, Minus>, proto::_make_minus(Minus(proto::_left), Minus(proto::_right)) > |
| > |
| {}; |
| |
| struct Square |
| : proto::or_< |
| // Not creating new proto::terminal nodes here, |
| // so hold the existing terminals by reference: |
| proto::when<proto::terminal<proto::_>, proto::_make_multiplies(proto::_, proto::_)> |
| , proto::when<proto::plus<Square, Square> > |
| > |
| {}; |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) |
| #undef _byref |
| #undef _byval |
| #undef Minus |
| #endif |
| |
| void test_make_expr_transform() |
| { |
| proto::plus< |
| proto::terminal<int>::type |
| , proto::terminal<int>::type |
| >::type t1 = ByVal()(proto::as_expr(1) + 1); |
| |
| proto::plus< |
| proto::terminal<int const &>::type |
| , proto::terminal<int const &>::type |
| >::type t2 = ByRef()(proto::as_expr(1) + 1); |
| |
| proto::minus< |
| proto::terminal<int>::type const & |
| , proto::terminal<int const &>::type const & |
| >::type t3 = Minus()(proto::as_expr(1) + 1); |
| |
| proto::plus< |
| proto::multiplies<proto::terminal<int>::type const &, proto::terminal<int>::type const &>::type |
| , proto::multiplies<proto::terminal<int const &>::type const &, proto::terminal<int const &>::type const &>::type |
| >::type t4 = Square()(proto::as_expr(1) + 1); |
| } |
| |
| |
| struct length_impl {}; |
| struct dot_impl {}; |
| |
| proto::terminal<length_impl>::type const length = {{}}; |
| proto::terminal<dot_impl>::type const dot = {{}}; |
| |
| // work around msvc bugs... |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) |
| #define _byref(a) call<proto::_byref(a)> |
| #define _byval(a) call<proto::_byval(a)> |
| #define _child1(a) call<proto::_child1(a)> |
| #define _make_terminal(a) call<proto::_make_terminal(a)> |
| #define _make_function(a,b,c) call<proto::_make_function(a,b,c)> |
| #define dot_impl() proto::make<dot_impl()> |
| #endif |
| |
| // convert length(a) < length(b) to dot(a,a) < dot(b,b) |
| struct Convert |
| : proto::when< |
| proto::less< |
| proto::function<proto::terminal<length_impl>, proto::_> |
| , proto::function<proto::terminal<length_impl>, proto::_> |
| > |
| , proto::_make_less( |
| proto::_make_function( |
| proto::_make_terminal(dot_impl()) |
| , proto::_child1(proto::_child0) |
| , proto::_child1(proto::_child0) |
| ) |
| , proto::_make_function( |
| proto::_make_terminal(dot_impl()) |
| , proto::_child1(proto::_child1) |
| , proto::_child1(proto::_child1) |
| ) |
| ) |
| > |
| {}; |
| |
| template<typename Expr> |
| void test_make_expr_transform2_test(Expr const &expr) |
| { |
| void const *addr1 = boost::addressof(proto::child_c<1>(proto::child_c<0>(expr))); |
| void const *addr2 = boost::addressof(proto::child_c<1>(proto::child_c<0>(Convert()(expr)))); |
| BOOST_CHECK_EQUAL(addr1, addr2); |
| |
| BOOST_CHECK_EQUAL(1, proto::value(proto::child_c<1>(proto::child_c<0>(expr)))); |
| BOOST_CHECK_EQUAL(1, proto::value(proto::child_c<1>(proto::child_c<0>(Convert()(expr))))); |
| } |
| |
| void test_make_expr_transform2() |
| { |
| test_make_expr_transform2_test(length(1) < length(2)); |
| } |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) |
| #undef _byref |
| #undef _byval |
| #undef _child1 |
| #undef _make_terminal |
| #undef _make_function |
| #undef dot_impl |
| #endif |
| |
| using namespace boost::unit_test; |
| /////////////////////////////////////////////////////////////////////////////// |
| // init_unit_test_suite |
| // |
| test_suite* init_unit_test_suite( int argc, char* argv[] ) |
| { |
| test_suite *test = BOOST_TEST_SUITE("test proto::make_expr, proto::unpack_expr and friends"); |
| |
| test->add(BOOST_TEST_CASE(&test_make_expr)); |
| test->add(BOOST_TEST_CASE(&test_make_expr_ref)); |
| test->add(BOOST_TEST_CASE(&test_make_expr_functional)); |
| test->add(BOOST_TEST_CASE(&test_make_expr_functional_ref)); |
| test->add(BOOST_TEST_CASE(&test_unpack_expr)); |
| test->add(BOOST_TEST_CASE(&test_unpack_expr_functional)); |
| test->add(BOOST_TEST_CASE(&test_make_expr_transform)); |
| test->add(BOOST_TEST_CASE(&test_make_expr_transform2)); |
| |
| return test; |
| } |
