1[/============================================================================== 2 Copyright (C) 2001-2010 Joel de Guzman 3 Copyright (C) 2001-2005 Dan Marsden 4 Copyright (C) 2001-2010 Thomas Heller 5 6 Distributed under the Boost Software License, Version 1.0. (See accompanying 7 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 8===============================================================================/] 9 10[section Transforming the Expression Tree] 11 12This example will show how to write __phoenix_actions__ that transform the 13Phoenix AST. 14 15[: 16"/Lisp macros transform the program structure itself, with the full language 17available to express such transformations./" 18 19[@http://en.wikipedia.org/wiki/Lisp_macro#Lisp_macros Wikipedia] 20] 21 22What we want to do is to invert some arithmetic operators, i.e. plus will be 23transformed to minus, minus to plus, multiplication to division and division to 24multiplication. 25 26Let's start with defining our default action: 27 28 struct invert_actions 29 { 30 template <typename Rule> 31 struct when 32 : proto::_ // the default is proto::_ 33 {}; 34 }; 35 36By default, we don't want to do anything, well, not exactly nothing, but just 37return the expression. This is done by 38[@http://www.boost.org/doc/libs/release/doc/html/boost/proto/_.html proto::_] 39which, used as a transform, just passes the current expression along. Making this 40action an identity transform. 41 42[def __proto_make_expr__ [@http://www.boost.org/doc/libs/release/doc/html/boost/proto/functional/make_expr.html `proto::functional::make_expr`]] 43 44So, after the basics are set up, we can start by writing the transformations we 45want to have on our tree: 46 47 // Transform plus to minus 48 template <> 49 struct invert_actions::when<phoenix::rule::plus> 50 : __proto_call__< 51 __proto_make_expr__<proto::tag::minus>( 52 phoenix::evaluator(proto::_left, phoenix::_context) 53 , phoenix::evaluator(proto::_right, phoenix::_context) 54 ) 55 > 56 {}; 57 58Wow, this looks complicated! Granted you need to know a little bit about __proto__ 59(For a good introduction read through the 60 [@http://cpp-next.com/archive/2010/08/expressive-c-introduction/ Expressive C++] series). 61 62What is done is the following: 63 64* The left expression is passed to evaluator (with the current context, that contains our invert_actions) 65* The right expression is passed to evaluator (with the current context, that contains our invert_actions) 66* The result of these two __proto_transforms__ is passed to __proto_make_expr__ which returns the freshly created expression 67 68After you know what is going on, maybe the rest doesn't look so scary anymore: 69 70 // Transform minus to plus 71 template <> 72 struct invert_actions::when<phoenix::rule::minus> 73 : __proto_call__< 74 __proto_make_expr__<proto::tag::plus>( 75 phoenix::evaluator(proto::_left, phoenix::_context) 76 , phoenix::evaluator(proto::_right, phoenix::_context) 77 ) 78 > 79 {}; 80 81 // Transform multiplies to divides 82 template <> 83 struct invert_actions::when<phoenix::rule::multiplies> 84 : __proto_call__< 85 __proto_make_expr__<proto::tag::divides>( 86 phoenix::evaluator(proto::_left, phoenix::_context) 87 , phoenix::evaluator(proto::_right, phoenix::_context) 88 ) 89 > 90 {}; 91 92 // Transform divides to multiplies 93 template <> 94 struct invert_actions::when<phoenix::rule::divides> 95 : __proto_call__< 96 __proto_make_expr__<proto::tag::multiplies>( 97 phoenix::evaluator(proto::_left, phoenix::_context) 98 , phoenix::evaluator(proto::_right, phoenix::_context) 99 ) 100 > 101 {}; 102 103That's it! Now that we have our actions defined, we want to evaluate some of our expressions with them: 104 105 template <typename Expr> 106 // Calculate the result type: our transformed AST 107 typename boost::result_of< 108 phoenix::evaluator( 109 Expr const& 110 , phoenix::result_of::context<int, invert_actions>::type 111 ) 112 >::type 113 invert(Expr const & expr) 114 { 115 return 116 // Evaluate it with our actions 117 phoenix::eval( 118 expr 119 , phoenix::context( 120 int() 121 , invert_actions() 122 ) 123 ); 124 } 125 126Run some tests to see if it is working: 127 128 invert(_1); // --> _1 129 invert(_1 + _2); // --> _1 - _2 130 invert(_1 + _2 - _3); // --> _1 - _2 + _3 131 invert(_1 * _2); // --> _1 / _2 132 invert(_1 * _2 / _3); // --> _1 / _2 * _3 133 invert(_1 * _2 + _3); // --> _1 / _2 - _3 134 invert(_1 * _2 - _3); // --> _1 / _2 + _2 135 invert(if_(_1 * _4)[_2 - _3]); // --> if_(_1 / _4)[_2 + _3] 136 _1 * invert(_2 - _3)); // --> _1 * _2 + _3 137 138__note__ The complete example can be found here: [@../../example/invert.cpp example/invert.cpp] 139 140/Pretty simple .../ 141 142[endsect] 143