luabind/detail/call.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_CALL_HPP_INCLUDED
  27 #define LUABIND_CALL_HPP_INCLUDED
  28
  29 #include <boost/config.hpp>
  30 #include <boost/preprocessor/repeat.hpp>
  31 #include <boost/preprocessor/iteration/iterate.hpp>
  32 #include <boost/preprocessor/repetition/enum.hpp>
  33 #include <boost/preprocessor/repetition/enum_params.hpp>
  34 #include <boost/preprocessor/repetition/enum_trailing.hpp>
  35 #include <boost/preprocessor/repetition/repeat.hpp>
  36 #include <boost/preprocessor/punctuation/comma_if.hpp>
  37 #include <boost/preprocessor/cat.hpp>
  38 #include <boost/mpl/bool.hpp>
  39
  40 #include <luabind/config.hpp>
  41 #include <luabind/detail/policy.hpp>
  42 #include <luabind/yield_policy.hpp>
  43
  44 /*
  45 #define LUABIND_DECL(z, n, text) typedef typename detail::get_policy<n+1,Policies>::type BOOST_PP_CAT(a##n,_policy); \
  46                 typedef typename BOOST_PP_CAT(a##n,_policy)::head BOOST_PP_CAT(a##n,_converter_intermediate); \
  47                 typedef typename BOOST_PP_CAT(a##n,_converter_intermediate)::template generate_converter<A##n, lua_to_cpp>::type BOOST_PP_CAT(p##n,_conv);
  48 #define LUABIND_PARAMS(z,n,text) BOOST_PP_CAT(p##n,_conv)::apply(L, LUABIND_DECORATE_TYPE(A##n), n + 2)
  49 */
  50
  51 #define LUABIND_DECL(z, n, text) typedef typename find_conversion_policy<n + 1, Policies>::type BOOST_PP_CAT(converter_policy,n); \
  52                 typename BOOST_PP_CAT(converter_policy,n)::template generate_converter<A##n, lua_to_cpp>::type BOOST_PP_CAT(c,n);
  53 //typedef typename BOOST_PP_CAT(converter_policy,n)::template generate_converter<A##n, lua_to_cpp>::type BOOST_PP_CAT(converter,n);
  54 //#define LUABIND_PARAMS(z,n,text) BOOST_PP_CAT(converter,n)::apply(L, LUABIND_DECORATE_TYPE(A##n), n + 2)
  55 #define LUABIND_ADD_INDEX(z,n,text) + BOOST_PP_CAT(converter_policy,n)::has_arg
  56 #define LUABIND_INDEX_MAP(z,n,text) 2 BOOST_PP_REPEAT(n, LUABIND_ADD_INDEX, _)
  57 #define LUABIND_PARAMS(z,n,text) BOOST_PP_CAT(c,n).apply(L, LUABIND_DECORATE_TYPE(A##n), LUABIND_INDEX_MAP(_,n,_))
  58 #define LUABIND_POSTCALL(z,n,text) BOOST_PP_CAT(c,n).converter_postcall(L, LUABIND_DECORATE_TYPE(A##n), LUABIND_INDEX_MAP(_,n,_));
  59
  60 namespace luabind { namespace detail
  61 {
  62         template<class Policies>
  63         struct maybe_yield
  64         {
  65                 static inline int apply(lua_State* L, int nret)
  66                 {
  67                         return ret(L, nret, boost::mpl::bool_<has_yield<Policies>::value>());
  68                 }
  69
  70                 static inline int ret(lua_State* L, int nret, boost::mpl::bool_<true>)
  71                 {
  72                         return lua_yield(L, nret);
  73                 }
  74
  75                 static inline int ret(lua_State*, int nret, boost::mpl::bool_<false>)
  76                 {
  77                         return nret;
  78                 }
  79         };
  80
  81         template<class T, class U>
  82         U& dereference(T* p, U&(*)())
  83         {
  84                 return *p;
  85         }
  86
  87         template<class T, class U>
  88         U* dereference(T* p, U*(*)())
  89         {
  90                 return p;
  91         }
  92
  93         template<class T>
  94         struct returns
  95         {
  96                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>, 1))
  97                 #include BOOST_PP_ITERATE()
  98         };
  99
 100         template<>
 101         struct returns<void>
 102         {
 103                 #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>, 2))
 104                 #include BOOST_PP_ITERATE()
 105         };
 106
 107         #define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>, 3))
 108         #include BOOST_PP_ITERATE()
 109 }}
 110
 111 #undef LUABIND_DECL
 112 #undef LUABIND_PARAMS
 113 #undef LUABIND_POSTCALL
 114 #undef LUABIND_ADD_INDEX
 115 #undef LUABIND_INDEX_MAP
 116
 117 #endif // LUABIND_CALL_HPP_INCLUDED
 118
 119 #elif BOOST_PP_ITERATION_FLAGS() == 1
 120
 121         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 122         static int call(T(C::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 123         {
 124                 int nargs = lua_gettop(L);
 125
 126                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 127                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 128
 129                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 130
 131                 converter_ret.apply(L, (obj->*f)
 132                 (
 133                         BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 134                 ));
 135
 136                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 137
 138                 int nret = lua_gettop(L) - nargs;
 139
 140                 const int indices[] =
 141                 {
 142                         1               /* self */,
 143                         nargs + nret /* result */
 144                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 145                 };
 146
 147                 policy_list_postcall<Policies>::apply(L, indices);
 148
 149                 return maybe_yield<Policies>::apply(L, nret);
 150 //              return nret;
 151         }
 152
 153         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 154         static int call(T(C::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) const, C* obj, lua_State* L, const Policies*)
 155         {
 156                 int nargs = lua_gettop(L);
 157                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 158                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 159                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 160                 converter_ret.apply(L, (obj->*f)
 161                 (
 162                         BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 163                 ));
 164
 165                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 166                 int nret = lua_gettop(L) - nargs;
 167
 168                 const int indices[] =
 169                 {
 170                         1               /* self */,
 171                         nargs + nret /* result */
 172                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 173                 };
 174
 175                 policy_list_postcall<Policies>::apply(L, indices);
 176
 177         //      return nret;
 178                 return maybe_yield<Policies>::apply(L, nret);
 179         }
 180
 181         template<class C, class CL, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 182         static int call(T(*f)(CL BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 183         {
 184                 int nargs = lua_gettop(L);
 185                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 186                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 187                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 188                 converter_ret.apply(L, f
 189                 (
 190                         dereference(obj, (CL(*)())0)
 191                         BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 192                 ));
 193                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 194
 195                 int nret = lua_gettop(L) - nargs;
 196
 197                 const int indices[] =
 198                 {
 199                         1               , // self
 200                         nargs + nret // result
 201                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 202                 };
 203
 204                 policy_list_postcall<Policies>::apply(L, indices);
 205
 206         //      return nret;
 207                 return maybe_yield<Policies>::apply(L, nret);
 208         }
 209 /*
 210         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 211         static int call(T(*f)(const C* obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 212         {
 213                 int nargs = lua_gettop(L);
 214                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 215                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 216                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 217                 converter_ret.apply(L, f
 218                 (
 219                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 220                 ));
 221                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 222
 223                 int nret = lua_gettop(L) - nargs;
 224
 225                 const int indices[] =
 226                 {
 227                         1               , // self
 228                         nargs + nret // result
 229                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 230                 };
 231
 232                 policy_list_postcall<Policies>::apply(L, indices);
 233
 234         //      return nret;
 235                 return maybe_yield<Policies>::apply(L, nret);
 236         }
 237
 238
 239         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 240         static int call(T(*f)(C& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 241         {
 242                 int nargs = lua_gettop(L);
 243                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 244                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 245                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 246                 converter_ret.apply(L, f
 247                 (
 248                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 249                 ));
 250                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 251
 252                 int nret = lua_gettop(L) - nargs;
 253
 254                 const int indices[] =
 255                 {
 256                         1               ,// self
 257                         nargs + nret // result
 258                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 259                 };
 260
 261                 policy_list_postcall<Policies>::apply(L, indices);
 262
 263         //      return nret;
 264                 return maybe_yield<Policies>::apply(L, nret);
 265         }
 266
 267         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 268         static int call(T(*f)(const C& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 269         {
 270                 int nargs = lua_gettop(L);
 271                 typedef typename find_conversion_policy<0, Policies>::type converter_policy_ret;
 272                 typename converter_policy_ret::template generate_converter<T, cpp_to_lua>::type converter_ret;
 273                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 274                 converter_ret.apply(L, f
 275                 (
 276                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 277                 ));
 278                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 279
 280                 int nret = lua_gettop(L) - nargs;
 281
 282                 const int indices[] =
 283                 {
 284                         1               , // self
 285                         nargs + nret // result
 286                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 287                 };
 288
 289                 policy_list_postcall<Policies>::apply(L, indices);
 290
 291         //      return nret;
 292                 return maybe_yield<Policies>::apply(L, nret);
 293         }
 294 */
 295 #elif BOOST_PP_ITERATION_FLAGS() == 2
 296
 297         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 298         static int call(void(C::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 299         {
 300                 int nargs = lua_gettop(L);
 301                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 302                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 303                 (obj->*f)
 304                 (
 305                         BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 306                 );
 307                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 308
 309                 int nret = lua_gettop(L) - nargs;
 310
 311                 const int indices[] =
 312                 {
 313                         1               /* self */,
 314                         nargs + nret /* result */
 315                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 316                 };
 317
 318                 policy_list_postcall<Policies>::apply(L, indices);
 319
 320         //      return nret;
 321                 return maybe_yield<Policies>::apply(L, nret);
 322         }
 323
 324         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 325         static int call(void(C::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) const, C* obj, lua_State* L, const Policies*)
 326         {
 327                 int nargs = lua_gettop(L);
 328                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 329                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 330                 (obj->*f)
 331                 (
 332                         BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 333                 );
 334                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 335
 336                 int nret = lua_gettop(L) - nargs;
 337
 338                 const int indices[] =
 339                 {
 340                         1               /* self */,
 341                         nargs + nret /* result */
 342                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 343                 };
 344
 345                 policy_list_postcall<Policies>::apply(L, indices);
 346
 347         //      return nret;
 348                 return maybe_yield<Policies>::apply(L, nret);
 349         }
 350
 351         template<class C, class CL, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 352         static int call(void(*f)(CL BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 353         {
 354                 int nargs = lua_gettop(L);
 355                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 356                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 357                 f(
 358                         dereference(obj, (CL(*)())0)
 359                         BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 360                 );
 361
 362                 int nret = lua_gettop(L) - nargs;
 363
 364                 const int indices[] =
 365                 {
 366                         1               /* self */,
 367                         nargs + nret /* result */
 368                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 369                 };
 370                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 371
 372                 policy_list_postcall<Policies>::apply(L, indices);
 373
 374         //      return nret;
 375                 return maybe_yield<Policies>::apply(L, nret);
 376         }
 377 /*
 378         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 379         static int call(void(*f)(C& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 380         {
 381                 int nargs = lua_gettop(L);
 382                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 383                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 384                 f(
 385                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 386                 );
 387
 388                 int nret = lua_gettop(L) - nargs;
 389
 390                 const int indices[] =
 391                 {
 392                         1               , // self
 393                         nargs + nret // result
 394                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 395                 };
 396                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 397
 398                 policy_list_postcall<Policies>::apply(L, indices);
 399
 400         //      return nret;
 401                 return maybe_yield<Policies>::apply(L, nret);
 402         }
 403
 404         template<class C, class Policies BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 405         static int call(void(*f)(const C& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), C* obj, lua_State* L, const Policies*)
 406         {
 407                 int nargs = lua_gettop(L);
 408                 L = L; // L is used, but metrowerks compiler seem to warn about it before expanding the macros
 409                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_DECL, _)
 410                 f(
 411                         *obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_PARAMS, _)
 412                 );
 413                 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_POSTCALL, _)
 414
 415                 int nret = lua_gettop(L) - nargs;
 416
 417                 const int indices[] =
 418                 {
 419                         1               , // self
 420                         nargs + nret // result //
 421                         BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), LUABIND_INDEX_MAP, _)
 422                 };
 423
 424                 policy_list_postcall<Policies>::apply(L, indices);
 425
 426         //      return nret;
 427                 return maybe_yield<Policies>::apply(L, nret);
 428         }
 429 */
 430 #elif BOOST_PP_ITERATION_FLAGS() == 3
 431 /*
 432         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 433         int call(R(*f)(T& BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 434         {
 435                 return returns<R>::call(f, obj, L, policies);
 436         }
 437
 438         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 439         int call(R(*f)(const T& BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 440         {
 441                 return returns<R>::call(f, obj, L, policies);
 442         }
 443
 444         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 445         int call(R(*f)(T* BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 446         {
 447                 return returns<R>::call(f, obj, L, policies);
 448         }
 449
 450         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 451         int call(R(*f)(const T* BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 452         {
 453                 return returns<R>::call(f, obj, L, policies);
 454         }
 455 */
 456         template<class CL, class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 457         int call(R(*f)(CL BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 458         {
 459                 return returns<R>::call(f, obj, L, policies);
 460         }
 461
 462         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 463         int call(R(T::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), T* obj, lua_State* L, const Policies* policies)
 464         {
 465                 return returns<R>::call(f, obj, L, policies);
 466         }
 467
 468         template<class T, class Policies, class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
 469         int call(R(T::*f)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)) const, T* obj, lua_State* L, const Policies* policies)
 470         {
 471                 return returns<R>::call(f, obj, L, policies);
 472         }
 473
 474 #endif