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(*)(), void*);
  69
  70                                 inline void set_fun(call_ptr f) { call_fun = f; }
  71                                 inline int call(lua_State* L, void(*f)(), void* storage) const { return call_fun(L, f, storage); }
  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
 121                         private:
 122
 123 #ifdef LUABIND_DONT_COPY_STRINGS
 124                                 const char* m_name;
 125 #else
 126                                 std::string m_name;
 127 #endif
 128
 129                                 // this have to be write protected, since each time an overload is
 130                                 // added it has to be checked for existence. add_overload() should
 131                                 // be used.
 132                                 std::vector<free_functions::overload_rep> m_overloads;
 133                         };
 134
 135
 136
 137                 // returns generates functions that calls function pointers
 138
 139 #define LUABIND_DECL(z, n, text) typedef typename find_conversion_policy<n + 1, Policies>::type BOOST_PP_CAT(converter_policy,n); \
 140                 typename BOOST_PP_CAT(converter_policy,n)::template generate_converter<A##n, lua_to_cpp>::type BOOST_PP_CAT(c,n);
 141
 142 #define LUABIND_ADD_INDEX(z,n,text) + BOOST_PP_CAT(converter_policy,n)::has_arg
 143 #define LUABIND_INDEX_MAP(z,n,text) 1 BOOST_PP_REPEAT(n, LUABIND_ADD_INDEX, _)
 144 #define LUABIND_PARAMS(z,n,text) BOOST_PP_CAT(c,n).apply(L, LUABIND_DECORATE_TYPE(A##n), LUABIND_INDEX_MAP(_,n,_))
 145 #define LUABIND_POSTCALL(z,n,text) BOOST_PP_CAT(c,n).converter_postcall(L, LUABIND_DECORATE_TYPE(A##n), LUABIND_INDEX_MAP(_,n,_));
 146
 147                         template<class Policies>
 148                         struct maybe_yield
 149                         {
 150                                 static inline int apply(lua_State* L, int nret)
 151                                 {
 152                                         return ret(L, nret, boost::mpl::bool_<has_yield<Policies>::value>());
 153                                 }
 154
 155                                 static inline int ret(lua_State* L, int nret, boost::mpl::bool_<true>)
 156                                 {
 157                                         return lua_yield(L, nret);
 158                                 }
 159
 160                                 static inline int ret(lua_State*, int nret, boost::mpl::bool_<false>)
 161                                 {
 162                                         return nret;
 163                                 }
 164                         };
 165
 166
 167                         template<class T>
 168                         struct returns
 169                         {
 170                                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 2))
 171                                 #include BOOST_PP_ITERATE()
 172                         };
 173
 174                         template<>
 175                         struct returns<void>
 176                         {
 177                                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 3))
 178                                 #include BOOST_PP_ITERATE()
 179                         };
 180
 181                         #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 4))
 182                         #include BOOST_PP_ITERATE()
 183
 184
 185 #undef LUABIND_PARAMS
 186 #undef LUABIND_DECL
 187 #undef LUABIND_POSTCALL
 188 #undef LUABIND_ADD_INDEX
 189 #undef LUABIND_INDEX_MAP
 190
 191
 192                         #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/function.hpp>, 5))
 193                         #include BOOST_PP_ITERATE()
 194
 195
 196                         template<class F, class Policies>
 197                         struct function_callback_s
 198                         {
 199                                 static inline int apply(lua_State* L, void(*fun)(), void* storage)
 200                                 {
 201                                         return free_functions::call(reinterpret_cast<F>(fun), L, static_cast<const Policies*>(0), storage);
 202                                 }
 203                         };
 204
 205                         template<class F, class Policies>
 206                         struct match_function_callback_s
 207                         {
 208                                 static inline int apply(lua_State* L)
 209                                 {
 210                                         F fptr = 0;
 211                                         return free_functions::match(fptr, L, static_cast<Policies*>(0));
 212                                 }
 213
 214                                 static int callback(lua_State* L)
 215                                 {
 216                                         F fptr = 0;
 217                                         return free_functions::match(fptr, L, static_cast<Policies*>(0));
 218                                 }
 219                         };
 220
 221                         LUABIND_API int function_dispatcher(lua_State* L);
 222                 }
 223         }
 224
 225         template<class F, class Policies>
 226         void function(lua_State* L, const char* name, F f, const Policies& p)
 227         {
 228                 module(L) [ def(name, f, p) ];
 229         }
 230
 231         template<class F>
 232         void function(lua_State* L, const char* name, F f)
 233         {
 234                 luabind::function(L, name, f, detail::null_type());
 235         }
 236
 237         namespace detail
 238         {
 239                 template<class F, class Policies>
 240                 struct function_commiter : detail::registration
 241                 {
 242                         function_commiter(const char* n, F f, const Policies& p)
 243                                 : m_name(n)
 244                                 , fun(f)
 245                                 , policies(p)
 246                         {}
 247
 248                         virtual void register_(lua_State* L) const
 249                         {
 250                                 detail::free_functions::overload_rep o(fun, static_cast<Policies*>(0));
 251
 252                                 o.set_match_fun(&detail::free_functions::match_function_callback_s<F, Policies>::apply);
 253                                 o.set_fun(&detail::free_functions::function_callback_s<F, Policies>::apply);
 254
 255 #ifndef LUABIND_NO_ERROR_CHECKING
 256                                 o.set_sig_fun(&detail::get_free_function_signature<F>::apply);
 257 #endif
 258
 259                                 lua_pushstring(L, m_name.c_str());
 260                                 lua_gettable(L, -2);
 261
 262                                 detail::free_functions::function_rep* rep = 0;
 263                                 if (lua_iscfunction(L, -1))
 264                                 {
 265                                         if (lua_getupvalue(L, -1, 2) != 0)
 266                                         {
 267                                                 // check the magic number that identifies luabind's functions
 268                                                 if (lua_touserdata(L, -1) == (void*)0x1337)
 269                                                 {
 270                                                         if (lua_getupvalue(L, -2, 1) != 0)
 271                                                         {
 272                                                                 rep = static_cast<detail::free_functions::function_rep*>(lua_touserdata(L, -1));
 273                                                                 lua_pop(L, 1);
 274                                                         }
 275                                                 }
 276                                                 lua_pop(L, 1);
 277                                         }
 278                                 }
 279                                 lua_pop(L, 1);
 280
 281                                 if (rep == 0)
 282                                 {
 283                                         lua_pushstring(L, m_name.c_str());
 284                                         // create a new function_rep
 285                                         rep = static_cast<detail::free_functions::function_rep*>(lua_newuserdata(L, sizeof(detail::free_functions::function_rep)));
 286                                         new(rep) detail::free_functions::function_rep(m_name.c_str());
 287
 288                                         detail::class_registry* r = detail::class_registry::get_registry(L);
 289                                         assert(r && "you must call luabind::open() prior to any function registrations");
 290                                         detail::getref(L, r->lua_function());
 291                                         int ret = lua_setmetatable(L, -2);
 292                                         assert(ret != 0);
 293
 294                                         // this is just a magic number to identify functions that luabind created
 295                                         lua_pushlightuserdata(L, (void*)0x1337);
 296
 297                                         lua_pushcclosure(L, &free_functions::function_dispatcher, 2);
 298                                         lua_settable(L, -3);
 299                                 }
 300
 301                                 rep->add_overload(o);
 302                         }
 303
 304                         std::string m_name;
 305                         F fun;
 306                         Policies policies;
 307                 };
 308         }
 309
 310         template<class F, class Policies>
 311         detail::scope def(const char* name, F f, const Policies& policies)
 312         {
 313                 return detail::scope(std::auto_ptr<detail::registration>(
 314                         new detail::function_commiter<F,Policies>(name, f, policies)));
 315         }
 316
 317         template<class F>
 318         detail::scope def(const char* name, F f)
 319         {
 320                 return detail::scope(std::auto_ptr<detail::registration>(
 321                         new detail::function_commiter<F,detail::null_type>(
 322                                 name, f, detail::null_type())));
 323         }
 324
 325 } // namespace luabind
 326
 327
 328 #endif // LUABIND_FUNCTION_HPP_INCLUDED
 329
 330 #elif BOOST_PP_ITERATION_FLAGS() == 1
 331
 332 // overloaded template funtion that initializes the parameter list
 333 // called m_params and the m_arity member.
 334
 335 #define LUABIND_INIT_PARAM(z, n, _) m_params[n] = LUABIND_TYPEID(A##n);
 336 #define LUABIND_POLICY_DECL(z,n,text) typedef typename find_conversion_policy<n + 1, Policies>::type BOOST_PP_CAT(p,n);
 337 #define LUABIND_ARITY(z,n,text) + BOOST_PP_CAT(p,n)::has_arg
 338
 339 template<class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A), class Policies>
 340 overload_rep(R(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), Policies*)
 341         : fun(reinterpret_cast<void(*)()>(f))
 342         , m_num_args(BOOST_PP_ITERATION())
 343 {
 344         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_INIT_PARAM, _)
 345         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POLICY_DECL, _)
 346
 347         m_arity = 0 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_ARITY, _);
 348 }
 349
 350 #undef LUABIND_INIT_PARAM
 351 #undef LUABIND_POLICY_DECL
 352 #undef LUABIND_ARITY
 353
 354 #elif BOOST_PP_ITERATION_FLAGS() == 2
 355
 356 template<class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 357 static int call(T(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, const Policies*, void* storage)
 358 {
 359 /*      typedef typename get_policy<0, Policies>::type ret_policy;
 360         typedef typename ret_policy::head return_value_converter_intermediate;
 361         typedef typename return_value_converter_intermediate::template generate_converter<T, cpp_to_lua>::type ret_conv;*/
 362
 363         int nargs = lua_gettop(L);
 364
 365 //      typedef typename get_policy_list<0, Policies>::type policy_list_ret;
 366 //      typedef typename find_converter_policy<policy_list_ret>::type converter_policy_ret;
 367         typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 368         typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 369
 370         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 371                 converter_ret.apply(L, f
 372                                 (
 373                                  BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 374                                 ));
 375         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 376
 377         int nret = lua_gettop(L) - nargs;
 378
 379         const int indices[] =
 380         {
 381                 -1              /* self */,
 382                 nargs + nret    /* result*/
 383                 BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 384         };
 385
 386         policy_list_postcall<Policies>::apply(L, indices);
 387
 388         return maybe_yield<Policies>::apply(L, nret);
 389 }
 390
 391
 392
 393 #elif BOOST_PP_ITERATION_FLAGS() == 3
 394
 395 template<class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 396 static int call(void(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, const Policies*, void* storage)
 397 {
 398         int nargs = lua_gettop(L);
 399
 400         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 401                 f
 402                 (
 403                  BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 404                 );
 405         BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 406
 407         int nret = lua_gettop(L) - nargs;
 408
 409         const int indices[] =
 410         {
 411                 -1              /* self */,
 412                 nargs + nret    /* result*/
 413                 BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 414         };
 415
 416         policy_list_postcall<Policies>::apply(L, indices);
 417
 418         return maybe_yield<Policies>::apply(L, nret);
 419 }
 420
 421
 422 #elif BOOST_PP_ITERATION_FLAGS() == 4
 423
 424 template<class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 425 int call(R(*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, const Policies* policies, void* storage)
 426 {
 427         return free_functions::returns<R>::call(f, L, policies, storage);
 428 }
 429
 430 #elif BOOST_PP_ITERATION_FLAGS() == 5
 431
 432         template<class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 433         static int match(R(*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), lua_State* L, const Policies* policies)
 434         {
 435                 //if (lua_gettop(L) != BOOST_PP_ITERATION()) return -1;
 436                 typedef constructor<BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)> ParameterTypes;
 437                 return match_params(L, 1, static_cast<ParameterTypes*>(0), policies);
 438         }
 439
 440
 441
 442 #endif
 443