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