luabind/function.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_FUNCTION_HPP_INCLUDED
  27 #define LUABIND_FUNCTION_HPP_INCLUDED
  28
  29 #include <luabind/config.hpp>
  30
  31 #include <boost/config.hpp>
  32 #include <boost/preprocessor/repeat.hpp>
  33 #include <boost/preprocessor/iteration/iterate.hpp>
  34 #include <boost/preprocessor/repetition/enum.hpp>
  35 #include <boost/preprocessor/repetition/enum_params.hpp>
  36 #include <boost/preprocessor/cat.hpp>
  37
  38 #include <luabind/detail/signature_match.hpp>
  39 #include <luabind/detail/call_function.hpp>
  40 #include <luabind/detail/get_overload_signature.hpp>
  41 #include <luabind/detail/overload_rep_base.hpp>
  42
  43 #include <luabind/scope.hpp>
  44
  45 namespace luabind
  46 {
  47         namespace detail
  48         {
  49
  50                 namespace free_functions
  51                 {
  52
  53                         struct overload_rep: public overload_rep_base
  54                         {
  55
  56 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 1))
  57 #include BOOST_PP_ITERATE()
  58
  59                                 inline bool operator==(const overload_rep& o) const
  60                                 {
  61                                         if (o.m_arity != m_arity) return false;
  62                                         if (o.m_num_args != m_num_args) return false;
  63                                         for (int i = 0; i < m_num_args; ++i)
  64                                                 if (!(LUABIND_TYPE_INFO_EQUAL(m_params[i], o.m_params[i]))) return false;
  65                                         return true;
  66                                 }
  67
  68                                 typedef int(*call_ptr)(lua_State*, void(*)());
  69
  70                                 inline void set_fun(call_ptr f) { call_fun = f; }
  71                                 inline int call(lua_State* L, void(*f)()) const { return call_fun(L, f); }
  72
  73                                 // this is the actual function pointer to be called when this overload is invoked
  74                                 void (*fun)();
  75
  76                         private:
  77
  78                                 int m_num_args;
  79                                 call_ptr call_fun;
  80
  81                                 // the number of parameters this overload takes
  82                                 // these are used to detect when a function by a derived class.
  83 //                              int m_arity;
  84                                 // the types of the parameter it takes
  85                                 LUABIND_TYPE_INFO m_params[LUABIND_MAX_ARITY];
  86                         };
  87
  88
  89
  90
  91                         struct function_rep
  92                         {
  93 #ifdef LUABIND_DONT_COPY_STRINGS
  94                                 function_rep(const char* name): m_name(name) {}
  95 #else
  96                                 function_rep(const std::string& name): m_name(name) {}
  97 #endif
  98                                 void add_overload(const free_functions::overload_rep& o)
  99                                 {
 100                                         std::vector<free_functions::overload_rep>::iterator i = std::find(m_overloads.begin(), m_overloads.end(), o);
 101
 102                                         // if the overload already exists, overwrite the existing function
 103                                         if (i != m_overloads.end())
 104                                         {
 105                                                 *i = o;
 106                                         }
 107                                         else
 108                                         {
 109                                                 m_overloads.push_back(o);
 110                                         }
 111                                 }
 112
 113                                 const std::vector<overload_rep>& overloads() const throw() { return m_overloads; }
 114
 115 #ifdef LUABIND_DONT_COPY_STRINGS
 116                                 const char* name() const { return m_name; }
 117 #else
 118                                 const char* name() const { return m_name.c_str(); }
 119 #endif
 120                         private:
 121
 122 #ifdef LUABIND_DONT_COPY_STRINGS
 123                                 const char* m_name;
 124 #else
 125                                 std::string m_name;
 126 #endif
 127
 128                                 // this have to be write protected, since each time an overload is
 129                                 // added it has to be checked for existence. add_overload() should
 130                                 // be used.
 131                                 std::vector<free_functions::overload_rep> m_overloads;
 132                         };
 133
 134
 135
 136                 // returns generates functions that calls function pointers
 137
 138 #define LUABIND_DECL(z, n, text) typedef typename find_conversion_policy<n + 1, Policies>::type BOOST_PP_CAT(converter_policy,n); \
 139                 typename BOOST_PP_CAT(converter_policy,n)::template generate_converter<A##n, lua_to_cpp>::type BOOST_PP_CAT(c,n);
 140
 141 #define LUABIND_ADD_INDEX(z,n,text) + BOOST_PP_CAT(converter_policy,n)::has_arg
 142 #define LUABIND_INDEX_MAP(z,n,text) 1 BOOST_PP_REPEAT(n, LUABIND_ADD_INDEX, _)
 143 #define LUABIND_PARAMS(z,n,text) BOOST_PP_CAT(c,n).apply(L, LUABIND_DECORATE_TYPE(A##n), LUABIND_INDEX_MAP(_,n,_))
 144 #define LUABIND_POSTCALL(z,n,text) BOOST_PP_CAT(c,n).converter_postcall(L, LUABIND_DECORATE_TYPE(A##n), LUABIND_INDEX_MAP(_,n,_));
 145
 146                         template<class Policies>
 147                         struct maybe_yield
 148                         {
 149                                 static inline int apply(lua_State* L, int nret)
 150                                 {
 151                                         return ret(L, nret, boost::mpl::bool_<has_yield<Policies>::value>());
 152                                 }
 153
 154                                 static inline int ret(lua_State* L, int nret, boost::mpl::bool_<true>)
 155                                 {
 156                                         return lua_yield(L, nret);
 157                                 }
 158
 159                                 static inline int ret(lua_State*, int nret, boost::mpl::bool_<false>)
 160                                 {
 161                                         return nret;
 162                                 }
 163                         };
 164
 165
 166                         template<class T>
 167                         struct returns
 168                         {
 169                                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 2))
 170                                 #include BOOST_PP_ITERATE()
 171                         };
 172
 173                         template<>
 174                         struct returns<void>
 175                         {
 176                                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 3))
 177                                 #include BOOST_PP_ITERATE()
 178                         };
 179
 180                         #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 4))
 181                         #include BOOST_PP_ITERATE()
 182
 183
 184 #undef LUABIND_PARAMS
 185 #undef LUABIND_DECL
 186 #undef LUABIND_POSTCALL
 187 #undef LUABIND_ADD_INDEX
 188 #undef LUABIND_INDEX_MAP
 189
 190
 191                         #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 5))
 192                         #include BOOST_PP_ITERATE()
 193
 194
 195                         template<class F, class Policies>
 196                         struct function_callback_s
 197                         {
 198                                 static inline int apply(lua_State* L, void(*fun)())
 199                                 {
 200                                         return free_functions::call(reinterpret_cast<F>(fun), L, static_cast<const Policies*>(0));
 201                                 }
 202                         };
 203
 204                         template<class F, class Policies>
 205                         struct match_function_callback_s
 206                         {
 207                                 static inline int apply(lua_State* L)
 208                                 {
 209                                         F fptr = 0;
 210                                         return free_functions::match(fptr, L, static_cast<Policies*>(0));
 211                                 }
 212
 213                                 static int callback(lua_State* L)
 214                                 {
 215                                         F fptr = 0;
 216                                         return free_functions::match(fptr, L, static_cast<Policies*>(0));
 217                                 }
 218                         };
 219
 220                         int function_dispatcher(lua_State* L);
 221                 }
 222         }
 223
 224         template<class F, class Policies>
 225         void function(lua_State* L, const char* name, F f, const Policies& p)
 226         {
 227                 module(L) [ def(name, f, p) ];
 228         }
 229
 230         template<class F>
 231         void function(lua_State* L, const char* name, F f)
 232         {
 233                 luabind::function(L, name, f, detail::null_type());
 234         }
 235
 236         namespace detail
 237         {
 238                 template<class F, class Policies>
 239                 struct function_commiter : detail::scoped_object
 240                 {
 241                         function_commiter(const char* n, F f, const Policies& p)
 242                                 : m_name(n)
 243                                 , fun(f)
 244                                 , policies(p)
 245                         {}
 246
 247                         virtual detail::scoped_object* clone()
 248                         {
 249                                 return new function_commiter(*this);
 250                         }
 251
 252                         virtual void commit(lua_State* L)
 253                         {
 254                                 detail::free_functions::overload_rep o(fun, static_cast<Policies*>(0));
 255
 256                                 o.set_match_fun(&detail::free_functions::match_function_callback_s<F, Policies>::apply);
 257                                 o.set_fun(&detail::free_functions::function_callback_s<F, Policies>::apply);
 258
 259 #ifndef LUABIND_NO_ERROR_CHECKING
 260                                 o.set_sig_fun(&detail::get_free_function_signature<F>::apply);
 261 #endif
 262
 263                                 detail::getref(L, scope_stack::top(L));
 264                                 lua_pushstring(L, m_name.c_str());
 265                                 lua_gettable(L, -2);
 266
 267                                 detail::free_functions::function_rep* rep = 0;
 268                                 if (lua_iscfunction(L, -1))
 269                                 {
 270                                         lua_getupvalue(L, -1, 1);
 271                                         rep = static_cast<detail::free_functions::function_rep*>(lua_touserdata(L, -1));
 272                                         lua_pop(L, 1);
 273                                 }
 274                                 lua_pop(L, 1);
 275
 276                                 if (rep == 0)
 277                                 {
 278                                         lua_pushstring(L, m_name.c_str());
 279                                         // create a new function_rep
 280                                         rep = static_cast<detail::free_functions::function_rep*>(lua_newuserdata(L, sizeof(detail::free_functions::function_rep)));
 281                                         new(rep) detail::free_functions::function_rep(m_name.c_str());
 282                                         lua_pushcclosure(L, &free_functions::function_dispatcher, 1);
 283                                         lua_settable(L, -3);
 284                                 }
 285
 286                                 rep->add_overload(o);
 287
 288                                 lua_pop(L, 1); // pop scope
 289                         }
 290
 291                         std::string m_name;
 292                         F fun;
 293                         Policies policies;
 294                 };
 295         }
 296
 297         template<class F, class Policies>
 298         detail::function_commiter<F,Policies>
 299         def(const char* name, F f, const Policies& policies)
 300         {
 301                 return detail::function_commiter<F,Policies>(name, f, policies);
 302         }
 303
 304         template<class F>
 305         detail::function_commiter<F, detail::null_type>
 306         def(const char* name, F f)
 307         {
 308                 return detail::function_commiter<F,detail::null_type>(name, f, detail::null_type());
 309         }
 310
 311 } // namespace luabind
 312
 313
 314 #endif // LUABIND_FUNCTION_HPP_INCLUDED
 315
 316 #elif BOOST_PP_ITERATION_FLAGS() == 1
 317
 318 // overloaded template funtion that initializes the parameter list
 319 // called m_params and the m_arity member.
 320
 321 #define LUABIND_INIT_PARAM(z, n, _) m_params[n] = LUABIND_TYPEID(A##n);
 322 #define LUABIND_POLICY_DECL(z,n,text) typedef typename find_conversion_policy<n + 1, Policies>::type BOOST_PP_CAT(p,n);
 323 #define LUABIND_ARITY(z,n,text) + BOOST_PP_CAT(p,n)::has_arg
 324
 325 template<class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A), class Policies>
 326 overload_rep(R(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), Policies*)
 327         : fun(reinterpret_cast<void(*)()>(f))
 328         , m_num_args(BOOST_PP_ITERATION())
 329 {
 330         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_INIT_PARAM, _)
 331         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POLICY_DECL, _)
 332
 333         m_arity = 0 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_ARITY, _);
 334 }
 335
 336 #undef LUABIND_INIT_PARAM
 337 #undef LUABIND_POLICY_DECL
 338 #undef LUABIND_ARITY
 339
 340 #elif BOOST_PP_ITERATION_FLAGS() == 2
 341
 342 template<class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 343 static int call(T(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, const Policies*)
 344 {
 345 /*      typedef typename get_policy<0, Policies>::type ret_policy;
 346         typedef typename ret_policy::head return_value_converter_intermediate;
 347         typedef typename return_value_converter_intermediate::template generate_converter<T, cpp_to_lua>::type ret_conv;*/
 348
 349         int nargs = lua_gettop(L);
 350
 351 //      typedef typename get_policy_list<0, Policies>::type policy_list_ret;
 352 //      typedef typename find_converter_policy<policy_list_ret>::type converter_policy_ret;
 353         typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 354         typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 355
 356         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 357                 converter_ret.apply(L, f
 358                                 (
 359                                  BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 360                                 ));
 361         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 362
 363         int nret = lua_gettop(L) - nargs;
 364
 365         const int indices[] =
 366         {
 367                 -1              /* self */,
 368                 nargs + nret    /* result*/
 369                 BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 370         };
 371
 372         policy_list_postcall<Policies>::apply(L, indices);
 373
 374         return maybe_yield<Policies>::apply(L, nret);
 375 }
 376
 377
 378
 379 #elif BOOST_PP_ITERATION_FLAGS() == 3
 380
 381 template<class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 382 static int call(void(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, const Policies*)
 383 {
 384         int nargs = lua_gettop(L);
 385
 386         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 387                 f
 388                 (
 389                  BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 390                 );
 391         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 392
 393         int nret = lua_gettop(L) - nargs;
 394
 395         const int indices[] =
 396         {
 397                 -1              /* self */,
 398                 nargs + nret    /* result*/
 399                 BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 400         };
 401
 402         policy_list_postcall<Policies>::apply(L, indices);
 403
 404         return maybe_yield<Policies>::apply(L, nret);
 405 }
 406
 407
 408 #elif BOOST_PP_ITERATION_FLAGS() == 4
 409
 410 template<class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 411 int call(R(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, const Policies* policies)
 412 {
 413         return free_functions::returns<R>::call(f, L, policies);
 414 }
 415
 416 #elif BOOST_PP_ITERATION_FLAGS() == 5
 417
 418         template<class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 419         static int match(R(*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, const Policies* policies)
 420         {
 421                 //if (lua_gettop(L) != BOOST_PP_ITERATION()) return -1;
 422                 typedef constructor<BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)> ParameterTypes;
 423                 return match_params(L, 1, static_cast<ParameterTypes*>(0), policies);
 424         }
 425
 426
 427
 428 #endif
 429