luabind/wrapper_base.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 #if !BOOST_PP_IS_ITERATING
  24
  25 #ifndef LUABIND_WRAPPER_BASE_HPP_INCLUDED
  26 #define LUABIND_WRAPPER_BASE_HPP_INCLUDED
  27
  28 #include <luabind/config.hpp>
  29 #include <luabind/weak_ref.hpp>
  30 #include <luabind/detail/ref.hpp>
  31 #include <luabind/detail/call_member.hpp>
  32
  33 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
  34 #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
  35
  36 #include <stdexcept>
  37
  38 namespace luabind
  39 {
  40         namespace detail
  41         {
  42                 struct wrap_access;
  43
  44                 // implements the selection between dynamic dispatch
  45                 // or default implementation calls from within a virtual
  46                 // function wrapper. The input is the self reference on
  47                 // the top of the stack. Output is the function to call
  48                 // on the top of the stack (the input self reference will
  49                 // be popped)
  50                 LUABIND_API void do_call_member_selection(lua_State* L, char const* name);
  51         }
  52
  53         struct wrapped_self_t: weak_ref
  54         {
  55                 detail::lua_reference m_strong_ref;
  56         };
  57
  58         struct wrap_base
  59         {
  60                 friend struct detail::wrap_access;
  61                 wrap_base() {}
  62
  63     #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/wrapper_base.hpp>, 1))
  64         #include BOOST_PP_ITERATE()
  65
  66         private:
  67                 wrapped_self_t m_self;
  68         };
  69
  70 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/wrapper_base.hpp>, 2))
  71 #include BOOST_PP_ITERATE()
  72
  73         namespace detail
  74         {
  75                 struct wrap_access
  76                 {
  77                         static wrapped_self_t const& ref(wrap_base const& b)
  78                         {
  79                                 return b.m_self;
  80                         }
  81
  82                         static wrapped_self_t& ref(wrap_base& b)
  83                         {
  84                                 return b.m_self;
  85                         }
  86                 };
  87         }
  88 }
  89
  90 #endif // LUABIND_WRAPPER_BASE_HPP_INCLUDED
  91
  92 #elif BOOST_PP_ITERATION_FLAGS() == 1
  93
  94 #define LUABIND_TUPLE_PARAMS(z, n, data) const A##n *
  95 #define LUABIND_OPERATOR_PARAMS(z, n, data) const A##n & a##n
  96
  97         template<class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
  98                 typename boost::mpl::if_<boost::is_void<R>
  99                                 , luabind::detail::proxy_member_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
 100                                 , luabind::detail::proxy_member_caller<R, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type
 101                                 call(char const* name BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _), detail::type_<R>* = 0) const
 102                 {
 103                         typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t;
 104         #if BOOST_PP_ITERATION() == 0
 105                         tuple_t args;
 106         #else
 107                         tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a));
 108         #endif
 109
 110                         typedef typename boost::mpl::if_<boost::is_void<R>
 111                                 , luabind::detail::proxy_member_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
 112                                 , luabind::detail::proxy_member_caller<R, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type;
 113
 114                         // this will be cleaned up by the proxy object
 115                         // once the call has been made
 116
 117                         // TODO: what happens if this virtual function is
 118                         // dispatched from a lua thread where the state
 119                         // pointer is different?
 120
 121                         // get the function
 122                         lua_State* L = m_self.state();
 123                         m_self.get(L);
 124                         assert(!lua_isnil(L, -1));
 125                         detail::do_call_member_selection(L, name);
 126
 127                         if (lua_isnil(L, -1))
 128                         {
 129                                 lua_pop(L, 1);
 130                                 throw std::runtime_error("Attempt to call nonexistent function");
 131                         }
 132
 133                         // push the self reference as the first parameter
 134                         m_self.get(L);
 135
 136                         // now the function and self objects
 137                         // are on the stack. These will both
 138                         // be popped by pcall
 139                         return proxy_type(L, args);
 140                 }
 141
 142 #undef LUABIND_CALL_MEMBER_NAME
 143 #undef LUABIND_OPERATOR_PARAMS
 144 #undef LUABIND_TUPLE_PARAMS
 145
 146 #else // free call_member forwardarding functions
 147
 148 #define N BOOST_PP_ITERATION()
 149
 150 #define LUABIND_TUPLE_PARAMS(z, n, data) const A##n *
 151 #define LUABIND_OPERATOR_PARAMS(z, n, data) const A##n & a##n
 152
 153     template<
 154         class R
 155         BOOST_PP_ENUM_TRAILING_PARAMS(N, class A)
 156     >
 157     typename boost::mpl::if_<
 158         boost::is_void<R>
 159       , detail::proxy_member_void_caller<
 160             boost::tuples::tuple<
 161                 BOOST_PP_ENUM(N, LUABIND_TUPLE_PARAMS, _)
 162             >
 163         >
 164       , detail::proxy_member_caller<
 165             R
 166           , boost::tuples::tuple<
 167                 BOOST_PP_ENUM(N, LUABIND_TUPLE_PARAMS, _)
 168             >
 169         >
 170     >::type
 171     call_member(
 172         wrap_base const* self
 173       , char const* fn
 174         BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, A, &a)
 175       , detail::type_<R>* = 0
 176     )
 177     {
 178         return self->call(
 179             fn
 180             BOOST_PP_ENUM_TRAILING_PARAMS(N, a)
 181          , (detail::type_<R>*)0
 182         );
 183     }
 184
 185 #undef LUABIND_OPERATOR_PARAMS
 186 #undef LUABIND_TUPLE_PARAMS
 187
 188 #undef N
 189
 190 #endif