luabind/detail/operators.hpp

   1 // Copyright (c) 2003 Daniel Wallin and Arvid Norberg
   2
   3 // Permission is hereby granted, free of charge, to any person obtaining a
   4 // copy of this software and associated documentation files (the "Software"),
   5 // to deal in the Software without restriction, including without limitation
   6 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   7 // and/or sell copies of the Software, and to permit persons to whom the
   8 // Software is furnished to do so, subject to the following conditions:
   9
  10 // The above copyright notice and this permission notice shall be included
  11 // in all copies or substantial portions of the Software.
  12
  13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
  14 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  15 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
  17 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  18 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
  21 // OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23
  24 #if !BOOST_PP_IS_ITERATING
  25
  26 #ifndef LUABIND_OPERATORS_HPP_INCLUDED
  27 #define LUABIND_OPERATORS_HPP_INCLUDED
  28
  29 #include <luabind/config.hpp>
  30
  31 #include <sstream>
  32
  33 #include <boost/preprocessor/repeat.hpp>
  34 #include <boost/preprocessor/repetition/enum.hpp>
  35 #include <boost/preprocessor/repetition/enum_params.hpp>
  36 #include <boost/preprocessor/iteration.hpp>
  37
  38
  39 #include <boost/mpl/if.hpp>
  40 #include <boost/mpl/vector.hpp>
  41
  42 #include <luabind/detail/other.hpp>
  43 #include <luabind/detail/operator_id.hpp>
  44 #include <luabind/detail/signature_match.hpp>
  45 #include <luabind/detail/policy.hpp>
  46
  47 namespace luabind { namespace detail {
  48
  49
  50         template<int N> struct execute_selector;
  51
  52 #if defined (BOOST_MSVC) && (BOOST_MSVC <= 1200)
  53         #define LUABIND_MSVC6_NO_TYPENAME
  54 #else
  55         #define LUABIND_MSVC6_NO_TYPENAME typename
  56 #endif
  57
  58 //#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
  59         #define LUABIND_CONVERT_PARAMETER conv_self.apply(L, LUABIND_DECORATE_TYPE(Self&), 1)
  60 //#else
  61 //      #define LUABIND_CONVERT_PARAMETER conv_self::template apply<Self_>(L, LUABIND_DECORATE_TYPE(Self&), 1)
  62 //#endif
  63
  64
  65         #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/operators.hpp>, 1))
  66         #include BOOST_PP_ITERATE()
  67
  68         #define LUABIND_UNWRAP_PARAM(z,n,_) LUABIND_MSVC6_NO_TYPENAME unwrap_other<A##n>::type
  69
  70         // Signature is a constructor<...> with all the parameter types in it
  71         // constant is true if the application operator is const
  72         template<class Signature, bool Constant, class Policies = null_type>
  73         struct application_operator
  74         {
  75                 template<class Self>
  76                 struct apply: execute_selector<Signature::arity>::template apply<Signature, Constant, Self, Policies> {};
  77
  78                 template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, class A)>
  79                 static inline int match_impl(
  80                                         lua_State* L,
  81                                         const constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)>*)
  82                 {
  83                         typedef constructor<BOOST_PP_ENUM(LUABIND_MAX_ARITY, LUABIND_UNWRAP_PARAM, _)> unwrapped_sig;
  84
  85                         object_rep* obj = is_class_object(L, 1);
  86                         if (obj == 0) return -1;
  87
  88                         bool constant_obj = obj->flags() & object_rep::constant;
  89
  90                         if (!Constant && constant_obj) return -1;
  91 //                      if (lua_gettop(L) != Signature::arity + 1) return -1;
  92
  93                         int i = match_params(L, 2, static_cast<const unwrapped_sig*>(0), static_cast<const Policies*>(0));
  94                         if (Constant && !constant_obj) i++;
  95                         return i;
  96                 }
  97
  98                 static inline int match(lua_State* L)
  99                 {
 100                         return match_impl(L, static_cast<const Signature*>(0));
 101                 }
 102         };
 103
 104         #undef LUABIND_UNWRAP_PARAM
 105
 106         // this is the type that represents all the operators
 107         // this is returned from all operators on self_t
 108         template<class id, class L, class R = null_type>
 109         struct operator_
 110         {
 111         };
 112
 113         struct self_t : boost::arg<-1>
 114         {
 115                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/operators.hpp>, 2))
 116                 #include BOOST_PP_ITERATE()
 117
 118                 operator_<op_tostring_tag, self_t, null_type> tostring;
 119         };
 120
 121         struct const_self_t : boost::arg<-1>
 122         {
 123                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/operators.hpp>, 3))
 124                 #include BOOST_PP_ITERATE()
 125
 126                 operator_<op_tostring_tag, const_self_t, null_type> tostring;
 127         };
 128
 129         // TODO: fix this. The type cannot be a value type for all cases
 130         template<class T, class Policy>
 131         inline int convert_result(lua_State* L, T v, const Policy*)
 132         {
 133                 typedef typename find_conversion_policy<0, Policy>::type converter_policy;
 134                 typename converter_policy::template generate_converter<T, cpp_to_lua>::type ret_converter;
 135                 ret_converter.apply(L, v);
 136                 return 1;
 137         }
 138
 139         // this is an implementation that is specialized
 140         // for each operator and used by operator_
 141         template<class id>
 142         struct binary_operator
 143         {
 144                 template<class Policies, class Left, class Right>
 145                 struct impl;
 146         };
 147
 148         template<class id>
 149         struct unary_operator
 150         {
 151                 template<class Policies, class Left> struct impl;
 152         };
 153
 154         template<class Policies, class id, class Self, class L, class R = null_type>
 155         struct operator_unwrapper :
 156                 ::boost::mpl::if_<
 157                         ::boost::is_same<detail::null_type, R>,
 158                         // if this is true, it is a unary operator
 159                         typename unary_operator<id>::template impl<
 160                                 Policies,
 161                                 typename ::boost::mpl::if_<
 162                                         boost::is_same<detail::self_t, L>,
 163                                         Self&,
 164                                         typename ::boost::mpl::if_<
 165                                                 ::boost::is_same<detail::const_self_t, L>,
 166                                                 const Self&,
 167                                                 typename unwrap_other<L>::type
 168                                         >::type
 169                                 >::type
 170                         >,
 171                         // else, if this is a binary operator
 172                         typename binary_operator<id>::template impl<
 173                                 Policies,
 174                                 // extract the left type and substitute self_t and const_self_t with the real self type
 175                                 // also, unwrap the type if it's wrapped in other<>
 176                                 typename ::boost::mpl::if_<
 177                                         boost::is_same<detail::self_t, L>,
 178                                         Self&,
 179                                         typename ::boost::mpl::if_<
 180                                                 ::boost::is_same<detail::const_self_t, L>,
 181                                                 const Self&,
 182                                                 typename unwrap_other<L>::type>::type
 183                                         >::type,
 184                                 // same thing but with the right type
 185                                 typename ::boost::mpl::if_<
 186                                         boost::is_same<detail::self_t, R>,
 187                                         Self&,
 188                                         typename ::boost::mpl::if_<
 189                                                 ::boost::is_same<detail::const_self_t, R>,
 190                                                 const Self&,
 191                                                 typename unwrap_other<R>::type
 192                                         >::type
 193                                 >::type
 194                         >
 195                 >::type
 196         {};
 197 }}
 198
 199 namespace luabind
 200 {
 201         namespace
 202         {
 203                 detail::self_t self;
 204                 detail::const_self_t const_self;
 205         }
 206
 207 #define LUABIND_BINARY_OPERATOR(id, op)\
 208         namespace detail {\
 209                 template<>\
 210                 struct binary_operator<op_##id##_tag>\
 211                 {\
 212                         template<class Policies, class Left, class Right>\
 213                         struct impl\
 214                         {\
 215                                 typedef typename unwrap_other<Left>::type left_t; \
 216                                 typedef typename unwrap_other<Right>::type right_t; \
 217                                 static inline operator_id get_id() { return op_##id; } \
 218                                 static inline int execute(lua_State* L)\
 219                                 {\
 220                                         typedef typename find_conversion_policy<1, Policies>::type converter_policy_left; \
 221                                         typename converter_policy_left::template generate_converter<left_t, lua_to_cpp>::type converter_left; \
 222                                         typedef typename find_conversion_policy<2, Policies>::type converter_policy_right; \
 223                                         typename converter_policy_right::template generate_converter<right_t, lua_to_cpp>::type converter_right; \
 224                                         int ret = convert_result(L, converter_left.apply(L, LUABIND_DECORATE_TYPE(left_t), 1) op converter_right.apply(L, LUABIND_DECORATE_TYPE(right_t), 2), static_cast<const Policies*>(0));\
 225                                         return ret;\
 226                                 }\
 227                                 static int match(lua_State* L)\
 228                                 {\
 229                                         return match_params(L, 1, static_cast<constructor<left_t, right_t>*>(0), static_cast<Policies*>(0));\
 230                                 }\
 231                         };\
 232                 };\
 233         }\
 234         \
 235         namespace detail\
 236         {\
 237         inline detail::operator_<detail::op_##id##_tag, detail::self_t, detail::self_t> operator op(const detail::self_t&, const detail::self_t&)\
 238         {\
 239                 return detail::operator_<detail::op_##id##_tag, detail::self_t, detail::self_t>();\
 240         }\
 241         template<class L>\
 242         inline detail::operator_<detail::op_##id##_tag, L, detail::self_t> operator op(const L&, const detail::self_t&)\
 243         {\
 244                 return detail::operator_<detail::op_##id##_tag, L, detail::self_t>();\
 245         }\
 246         template<class R>\
 247         inline detail::operator_<detail::op_##id##_tag, detail::self_t, R> operator op(const detail::self_t&, const R&)\
 248         {\
 249                 return detail::operator_<detail::op_##id##_tag, detail::self_t, R>();\
 250         }\
 251         inline detail::operator_<detail::op_##id##_tag, detail::const_self_t, detail::const_self_t> operator op(const detail::const_self_t&, const detail::const_self_t&)\
 252         {\
 253                 return detail::operator_<detail::op_##id##_tag, detail::const_self_t, detail::const_self_t>();\
 254         }\
 255         template<class L>\
 256         inline detail::operator_<detail::op_##id##_tag, L, detail::const_self_t> operator op(const L&, const detail::const_self_t&)\
 257         {\
 258                 return detail::operator_<detail::op_##id##_tag, L, detail::const_self_t>();\
 259         }\
 260         template<class R>\
 261         inline detail::operator_<detail::op_##id##_tag, detail::const_self_t, R> operator op(const detail::const_self_t&, const R&)\
 262         {\
 263                 return detail::operator_<detail::op_##id##_tag, detail::const_self_t, R>();\
 264         }\
 265         }
 266
 267         LUABIND_BINARY_OPERATOR(add,+)
 268         LUABIND_BINARY_OPERATOR(sub,-)
 269         LUABIND_BINARY_OPERATOR(div,/)
 270         LUABIND_BINARY_OPERATOR(mul,*)
 271         LUABIND_BINARY_OPERATOR(pow,^)
 272         LUABIND_BINARY_OPERATOR(lt,<)
 273         LUABIND_BINARY_OPERATOR(le,<=)
 274         LUABIND_BINARY_OPERATOR(eq,==)
 275
 276 #undef LUABIND_BINARY_OPERATOR
 277
 278
 279 #define LUABIND_UNARY_OPERATOR(id, op)\
 280         namespace detail\
 281         {\
 282                 template<>\
 283                 struct unary_operator<op_##id##_tag>\
 284                 {\
 285                         template<class Policies, class Left>\
 286                         struct impl\
 287                         {\
 288                                 typedef typename unwrap_other<Left>::type left_t;\
 289                                 typedef detail::null_type right_t;\
 290                                 static inline operator_id get_id() { return op_##id; }\
 291                                 static inline int execute(lua_State* L)\
 292                                 {\
 293                                         typedef typename find_conversion_policy<1, Policies>::type converter_policy_left; \
 294                                         typename converter_policy_left::template generate_converter<left_t, lua_to_cpp>::type converter_left;\
 295                                         return convert_result(L, op converter_left.apply(L, LUABIND_DECORATE_TYPE(left_t), 1), static_cast<const Policies*>(0));\
 296                                 }\
 297                                 static inline int match(lua_State* L)\
 298                                 {\
 299                                         return match_params(L, 1, static_cast<constructor<left_t>*>(0), static_cast<Policies*>(0));\
 300                                 }\
 301                         };\
 302                 };\
 303         }\
 304         \
 305         inline detail::operator_<detail::op_##id##_tag, detail::self_t, detail::null_type> operator op(const detail::self_t&)\
 306         {\
 307                 return detail::operator_<detail::op_##id##_tag, detail::self_t, detail::null_type>();\
 308         }\
 309         inline detail::operator_<detail::op_##id##_tag, detail::const_self_t, detail::null_type> operator op(const detail::const_self_t&)\
 310         {\
 311                 return detail::operator_<detail::op_##id##_tag, detail::const_self_t, detail::null_type>();\
 312         }
 313
 314         LUABIND_UNARY_OPERATOR(unm,-);
 315
 316         namespace detail
 317         {
 318                 template<>
 319                 struct unary_operator<op_tostring_tag>
 320                 {
 321                         template<class Policies, class Left>
 322                         struct impl
 323                         {
 324                                 typedef typename unwrap_other<Left>::type left_t;
 325                                 typedef detail::null_type right_t;
 326                                 static inline operator_id get_id() { return op_tostring; }
 327                                 static inline int execute(lua_State* L)
 328                                 {
 329                                         // TODO: Should policies apply to this operator? shouldn't the string returntype be enforced?
 330                                         typedef typename find_conversion_policy<1, Policies>::type converter_policy_left;
 331                                         typename converter_policy_left::template generate_converter<left_t, lua_to_cpp>::type converter_left;
 332                                         std::stringstream s;
 333                                         s << converter_left.apply(L, LUABIND_DECORATE_TYPE(left_t), 1) << std::ends;
 334                                         return convert_result(L, s.str(), static_cast<const Policies*>(0));
 335                                 }
 336                                 static inline int match(lua_State* L)
 337                                 {
 338                                         return match_params(L, 1, static_cast<constructor<left_t>*>(0), static_cast<Policies*>(0));
 339                                 }
 340                         };
 341                 };
 342         }
 343
 344         inline detail::operator_<detail::op_tostring_tag, detail::self_t, detail::null_type> tostring(const detail::self_t&)
 345         {
 346                 return detail::operator_<detail::op_tostring_tag, detail::self_t, detail::null_type>();
 347         }
 348         inline detail::operator_<detail::op_tostring_tag, detail::const_self_t, detail::null_type> tostring(const detail::const_self_t&)
 349         {
 350                 return detail::operator_<detail::op_tostring_tag, detail::const_self_t, detail::null_type>();
 351         }
 352
 353
 354 #undef LUABIND_UNARY_OPERATOR
 355 #undef LUABIND_MSVC6_NO_TYPENAME
 356 }
 357
 358 #endif // LUABIND_OPERATORS_HPP_INCLUDED
 359
 360
 361 #elif BOOST_PP_ITERATION_FLAGS() == 1
 362
 363 #define LUABIND_DECL(z,n,_) typedef typename find_conversion_policy<n + 1, Policies>::type BOOST_PP_CAT(converter_policy,n); \
 364                 typedef typename unwrap_other<A##n>::type unwrapped_a##n; \
 365                 typename BOOST_PP_CAT(converter_policy,n)::template generate_converter<unwrapped_a##n, lua_to_cpp>::type BOOST_PP_CAT(c,n);
 366
 367 #define LUABIND_PARAM(z,n,_) BOOST_PP_CAT(c,n).apply(L, LUABIND_DECORATE_TYPE(unwrapped_a##n), n+2)
 368
 369         template<>
 370         struct execute_selector<BOOST_PP_ITERATION()>
 371         {
 372                 template<class Signature, bool Constant, class Self_, class Policies>
 373                 struct apply
 374                 {
 375                         static inline int execute(lua_State* L)
 376                         {
 377                                 return execute_impl(L, static_cast<const Signature*>(0));
 378                         }
 379
 380                         template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, class A)>
 381                         static inline int execute_impl(
 382                                                 lua_State* L,
 383                                                 const constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)>*)
 384                         {
 385                                 // TODO: use policies here, instead of default_policy, or shouldn't we?
 386                                 typename boost::mpl::apply_if_c<Constant,
 387                                         LUABIND_MSVC6_NO_TYPENAME default_policy::template generate_converter<const Self_&, lua_to_cpp>,
 388                                         LUABIND_MSVC6_NO_TYPENAME default_policy::template generate_converter<Self_&, lua_to_cpp>
 389                                 >::type conv_self;
 390
 391                                 typedef typename boost::mpl::if_c<Constant,
 392                                         const Self_,
 393                                         Self_
 394                                 >::type Self;
 395
 396                                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 397
 398                                 return convert_result(L, LUABIND_CONVERT_PARAMETER
 399                                         (
 400                                                 BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAM, _)
 401                                         ), static_cast<const Policies*>(0));
 402                         }
 403                 };
 404         };
 405
 406 #undef LUABIND_DECL
 407 #undef LUABIND_PARAM
 408
 409 #elif BOOST_PP_ITERATION_FLAGS() == 2 // self_t
 410
 411 #define LUABIND_UNWRAP_PARAM(z,n,_) A##n
 412
 413 #if BOOST_PP_ITERATION() > 0
 414 template<BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 415 #endif
 416 application_operator< constructor<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_UNWRAP_PARAM, _)>, false>*
 417 operator()(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) { return 0; }
 418
 419 #undef LUABIND_UNWRAP_PARAM
 420
 421 #elif BOOST_PP_ITERATION_FLAGS() == 3 // const_self_t
 422
 423 #define LUABIND_UNWRAP_PARAM(z,n,_) A##n
 424
 425 #if BOOST_PP_ITERATION() > 0
 426 template<BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 427 #endif
 428 application_operator< constructor<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_UNWRAP_PARAM, _)>, true>*
 429 operator()(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) { return 0; }
 430
 431 #undef LUABIND_UNWRAP_PARAM
 432
 433 #endif
 434