mirror of
https://github.com/EQEmu/Server.git
synced 2026-06-24 01:08:21 +00:00
EQStream abstraction layer
This commit is contained in:
KimLS
@@ -0,0 +1,61 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#if !BOOST_PP_IS_ITERATING
|
||||
|
||||
# include <luabind/detail/signature_match.hpp>
|
||||
|
||||
#ifndef LUABIND_CALC_ARITY_HPP_INCLUDED
|
||||
#define LUABIND_CALC_ARITY_HPP_INCLUDED
|
||||
|
||||
#define LUABIND_FIND_CONV(z,n,text) typedef typename find_conversion_policy<n + 1, Policies>::type p##n;
|
||||
#define LUABIND_CALC_ARITY(z,n,text) + BOOST_PP_CAT(p,n)::has_arg
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
template<int N> struct calc_arity;
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/calc_arity.hpp>, 1))
|
||||
#include BOOST_PP_ITERATE()
|
||||
}}
|
||||
|
||||
#undef LUABIND_CALC_ARITY
|
||||
#undef LUABIND_FIND_CONV
|
||||
|
||||
|
||||
#endif // LUABIND_CALC_ARITY_HPP_INCLUDED
|
||||
|
||||
#else // BOOST_PP_ITERATE
|
||||
|
||||
template<>
|
||||
struct calc_arity<BOOST_PP_ITERATION()>
|
||||
{
|
||||
template<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, class A), class Policies>
|
||||
static int apply(constructor<BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)>, Policies*)
|
||||
{
|
||||
BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_FIND_CONV, _)
|
||||
return 0 BOOST_PP_REPEAT(BOOST_PP_ITERATION(), LUABIND_CALC_ARITY, _);
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,323 @@
|
||||
// Copyright Daniel Wallin 2008. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#if !BOOST_PP_IS_ITERATING
|
||||
|
||||
# ifndef LUABIND_CALL2_080911_HPP
|
||||
# define LUABIND_CALL2_080911_HPP
|
||||
|
||||
# include <boost/mpl/apply_wrap.hpp>
|
||||
# include <boost/mpl/begin_end.hpp>
|
||||
# include <boost/mpl/deref.hpp>
|
||||
# include <boost/mpl/front.hpp>
|
||||
# include <boost/mpl/long.hpp>
|
||||
# include <boost/mpl/size.hpp>
|
||||
# include <boost/preprocessor/control/if.hpp>
|
||||
# include <boost/preprocessor/iteration/iterate.hpp>
|
||||
# include <boost/preprocessor/iteration/local.hpp>
|
||||
# include <boost/preprocessor/repetition/enum.hpp>
|
||||
# include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
# include <boost/type_traits/is_void.hpp>
|
||||
|
||||
# include <luabind/config.hpp>
|
||||
# include <luabind/detail/policy.hpp>
|
||||
# include <luabind/yield_policy.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
struct invoke_context;
|
||||
|
||||
struct LUABIND_API function_object
|
||||
{
|
||||
function_object(lua_CFunction entry)
|
||||
: entry(entry)
|
||||
, next(0)
|
||||
{}
|
||||
|
||||
virtual ~function_object()
|
||||
{}
|
||||
|
||||
virtual int call(
|
||||
lua_State* L, invoke_context& ctx) const = 0;
|
||||
virtual void format_signature(lua_State* L, char const* function) const = 0;
|
||||
|
||||
lua_CFunction entry;
|
||||
std::string name;
|
||||
function_object* next;
|
||||
object keepalive;
|
||||
};
|
||||
|
||||
struct LUABIND_API invoke_context
|
||||
{
|
||||
invoke_context()
|
||||
: best_score((std::numeric_limits<int>::max)())
|
||||
, candidate_index(0)
|
||||
{}
|
||||
|
||||
operator bool() const
|
||||
{
|
||||
return candidate_index == 1;
|
||||
}
|
||||
|
||||
void format_error(lua_State* L, function_object const* overloads) const;
|
||||
|
||||
int best_score;
|
||||
function_object const* candidates[10];
|
||||
int candidate_index;
|
||||
};
|
||||
|
||||
template <class F, class Signature, class Policies, class IsVoid>
|
||||
inline int invoke0(
|
||||
lua_State* L, function_object const& self, invoke_context& ctx
|
||||
, F const& f, Signature, Policies const& policies, IsVoid, mpl::true_)
|
||||
{
|
||||
return invoke_member(
|
||||
L, self, ctx, f, Signature(), policies
|
||||
, mpl::long_<mpl::size<Signature>::value - 1>(), IsVoid()
|
||||
);
|
||||
}
|
||||
|
||||
template <class F, class Signature, class Policies, class IsVoid>
|
||||
inline int invoke0(
|
||||
lua_State* L, function_object const& self, invoke_context& ctx,
|
||||
F const& f, Signature, Policies const& policies, IsVoid, mpl::false_)
|
||||
{
|
||||
return invoke_normal(
|
||||
L, self, ctx, f, Signature(), policies
|
||||
, mpl::long_<mpl::size<Signature>::value - 1>(), IsVoid()
|
||||
);
|
||||
}
|
||||
|
||||
template <class F, class Signature, class Policies>
|
||||
inline int invoke(
|
||||
lua_State* L, function_object const& self, invoke_context& ctx
|
||||
, F const& f, Signature, Policies const& policies)
|
||||
{
|
||||
return invoke0(
|
||||
L, self, ctx, f, Signature(), policies
|
||||
, boost::is_void<typename mpl::front<Signature>::type>()
|
||||
, boost::is_member_function_pointer<F>()
|
||||
);
|
||||
}
|
||||
|
||||
inline int maybe_yield_aux(lua_State*, int results, mpl::false_)
|
||||
{
|
||||
return results;
|
||||
}
|
||||
|
||||
inline int maybe_yield_aux(lua_State* L, int results, mpl::true_)
|
||||
{
|
||||
return lua_yield(L, results);
|
||||
}
|
||||
|
||||
template <class Policies>
|
||||
int maybe_yield(lua_State* L, int results, Policies*)
|
||||
{
|
||||
return maybe_yield_aux(
|
||||
L, results, mpl::bool_<has_yield<Policies>::value>());
|
||||
}
|
||||
|
||||
inline int sum_scores(int const* first, int const* last)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
for (; first != last; ++first)
|
||||
{
|
||||
if (*first < 0)
|
||||
return *first;
|
||||
result += *first;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
# define LUABIND_INVOKE_NEXT_ITER(n) \
|
||||
typename mpl::next< \
|
||||
BOOST_PP_IF( \
|
||||
n, BOOST_PP_CAT(iter,BOOST_PP_DEC(n)), first) \
|
||||
>::type
|
||||
|
||||
# define LUABIND_INVOKE_NEXT_INDEX(n) \
|
||||
BOOST_PP_IF( \
|
||||
n \
|
||||
, BOOST_PP_CAT(index,BOOST_PP_DEC(n)) + \
|
||||
BOOST_PP_CAT(c,BOOST_PP_DEC(n)).consumed_args() \
|
||||
, 1 \
|
||||
)
|
||||
|
||||
# define LUABIND_INVOKE_COMPUTE_ARITY(n) + BOOST_PP_CAT(c,n).consumed_args()
|
||||
|
||||
# define LUABIND_INVOKE_DECLARE_CONVERTER(n) \
|
||||
typedef LUABIND_INVOKE_NEXT_ITER(n) BOOST_PP_CAT(iter,n); \
|
||||
typedef typename mpl::deref<BOOST_PP_CAT(iter,n)>::type \
|
||||
BOOST_PP_CAT(a,n); \
|
||||
typedef typename find_conversion_policy<n + 1, Policies>::type \
|
||||
BOOST_PP_CAT(p,n); \
|
||||
typename mpl::apply_wrap2< \
|
||||
BOOST_PP_CAT(p,n), BOOST_PP_CAT(a,n), lua_to_cpp>::type BOOST_PP_CAT(c,n); \
|
||||
int const BOOST_PP_CAT(index,n) = LUABIND_INVOKE_NEXT_INDEX(n);
|
||||
|
||||
# define LUABIND_INVOKE_COMPUTE_SCORE(n) \
|
||||
, BOOST_PP_CAT(c,n).match( \
|
||||
L, LUABIND_DECORATE_TYPE(BOOST_PP_CAT(a,n)), BOOST_PP_CAT(index,n))
|
||||
|
||||
# define LUABIND_INVOKE_ARG(z, n, base) \
|
||||
BOOST_PP_CAT(c,base(n)).apply( \
|
||||
L, LUABIND_DECORATE_TYPE(BOOST_PP_CAT(a,base(n))), BOOST_PP_CAT(index,base(n)))
|
||||
|
||||
# define LUABIND_INVOKE_CONVERTER_POSTCALL(n) \
|
||||
BOOST_PP_CAT(c,n).converter_postcall( \
|
||||
L, LUABIND_DECORATE_TYPE(BOOST_PP_CAT(a,n)), BOOST_PP_CAT(index,n));
|
||||
|
||||
# define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>))
|
||||
# include BOOST_PP_ITERATE()
|
||||
|
||||
# define LUABIND_INVOKE_VOID
|
||||
# define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>))
|
||||
# include BOOST_PP_ITERATE()
|
||||
|
||||
# undef LUABIND_INVOKE_VOID
|
||||
# define LUABIND_INVOKE_MEMBER
|
||||
# define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>))
|
||||
# include BOOST_PP_ITERATE()
|
||||
|
||||
# define LUABIND_INVOKE_VOID
|
||||
# define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, LUABIND_MAX_ARITY, <luabind/detail/call.hpp>))
|
||||
# include BOOST_PP_ITERATE()
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
# endif // LUABIND_CALL2_080911_HPP
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
# ifdef LUABIND_INVOKE_MEMBER
|
||||
# define N BOOST_PP_INC(BOOST_PP_ITERATION())
|
||||
# else
|
||||
# define N BOOST_PP_ITERATION()
|
||||
# endif
|
||||
|
||||
template <class F, class Signature, class Policies>
|
||||
inline int
|
||||
# ifdef LUABIND_INVOKE_MEMBER
|
||||
invoke_member
|
||||
# else
|
||||
invoke_normal
|
||||
# endif
|
||||
(
|
||||
lua_State* L, function_object const& self, invoke_context& ctx
|
||||
, F const& f, Signature, Policies const&, mpl::long_<N>
|
||||
# ifdef LUABIND_INVOKE_VOID
|
||||
, mpl::true_
|
||||
# else
|
||||
, mpl::false_
|
||||
# endif
|
||||
)
|
||||
{
|
||||
typedef typename mpl::begin<Signature>::type first;
|
||||
# ifndef LUABIND_INVOKE_VOID
|
||||
typedef typename mpl::deref<first>::type result_type;
|
||||
typedef typename find_conversion_policy<0, Policies>::type result_policy;
|
||||
typename mpl::apply_wrap2<
|
||||
result_policy, result_type, cpp_to_lua>::type result_converter;
|
||||
# endif
|
||||
|
||||
# if N > 0
|
||||
# define BOOST_PP_LOCAL_MACRO(n) LUABIND_INVOKE_DECLARE_CONVERTER(n)
|
||||
# define BOOST_PP_LOCAL_LIMITS (0,N-1)
|
||||
# include BOOST_PP_LOCAL_ITERATE()
|
||||
# endif
|
||||
|
||||
int const arity = 0
|
||||
# if N > 0
|
||||
# define BOOST_PP_LOCAL_MACRO(n) LUABIND_INVOKE_COMPUTE_ARITY(n)
|
||||
# define BOOST_PP_LOCAL_LIMITS (0,N-1)
|
||||
# include BOOST_PP_LOCAL_ITERATE()
|
||||
# endif
|
||||
;
|
||||
|
||||
int const arguments = lua_gettop(L);
|
||||
|
||||
int score = -1;
|
||||
|
||||
if (arity == arguments)
|
||||
{
|
||||
int const scores[] = {
|
||||
0
|
||||
# if N > 0
|
||||
# define BOOST_PP_LOCAL_MACRO(n) LUABIND_INVOKE_COMPUTE_SCORE(n)
|
||||
# define BOOST_PP_LOCAL_LIMITS (0,N-1)
|
||||
# include BOOST_PP_LOCAL_ITERATE()
|
||||
# endif
|
||||
};
|
||||
|
||||
score = sum_scores(scores + 1, scores + 1 + N);
|
||||
}
|
||||
|
||||
if (score >= 0 && score < ctx.best_score)
|
||||
{
|
||||
ctx.best_score = score;
|
||||
ctx.candidates[0] = &self;
|
||||
ctx.candidate_index = 1;
|
||||
}
|
||||
else if (score == ctx.best_score)
|
||||
{
|
||||
ctx.candidates[ctx.candidate_index++] = &self;
|
||||
}
|
||||
|
||||
int results = 0;
|
||||
|
||||
if (self.next)
|
||||
{
|
||||
results = self.next->call(L, ctx);
|
||||
}
|
||||
|
||||
if (score == ctx.best_score && ctx.candidate_index == 1)
|
||||
{
|
||||
# ifndef LUABIND_INVOKE_VOID
|
||||
result_converter.apply(
|
||||
L,
|
||||
# endif
|
||||
# ifdef LUABIND_INVOKE_MEMBER
|
||||
(c0.apply(L, LUABIND_DECORATE_TYPE(a0), index0).*f)(
|
||||
BOOST_PP_ENUM(BOOST_PP_DEC(N), LUABIND_INVOKE_ARG, BOOST_PP_INC)
|
||||
)
|
||||
# else
|
||||
# define LUABIND_INVOKE_IDENTITY(x) x
|
||||
f(
|
||||
BOOST_PP_ENUM(N, LUABIND_INVOKE_ARG, LUABIND_INVOKE_IDENTITY)
|
||||
)
|
||||
# undef LUABIND_INVOKE_IDENTITY
|
||||
# endif
|
||||
# ifndef LUABIND_INVOKE_VOID
|
||||
)
|
||||
# endif
|
||||
;
|
||||
|
||||
# if N > 0
|
||||
# define BOOST_PP_LOCAL_MACRO(n) LUABIND_INVOKE_CONVERTER_POSTCALL(n)
|
||||
# define BOOST_PP_LOCAL_LIMITS (0,N-1)
|
||||
# include BOOST_PP_LOCAL_ITERATE()
|
||||
# endif
|
||||
|
||||
results = maybe_yield(L, lua_gettop(L) - arguments, (Policies*)0);
|
||||
|
||||
int const indices[] = {
|
||||
arguments + results BOOST_PP_ENUM_TRAILING_PARAMS(N, index)
|
||||
};
|
||||
|
||||
policy_list_postcall<Policies>::apply(L, indices);
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
# undef N
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,442 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#if !BOOST_PP_IS_ITERATING
|
||||
|
||||
#ifndef LUABIND_CALL_FUNCTION_HPP_INCLUDED
|
||||
#define LUABIND_CALL_FUNCTION_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/preprocessor/repeat.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/enum.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma_if.hpp>
|
||||
|
||||
#include <luabind/error.hpp>
|
||||
#include <luabind/detail/convert_to_lua.hpp>
|
||||
#include <luabind/detail/pcall.hpp>
|
||||
|
||||
namespace luabind
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
|
||||
// if the proxy_function_caller returns non-void
|
||||
template<class Ret, class Tuple>
|
||||
class proxy_function_caller
|
||||
{
|
||||
// friend class luabind::object;
|
||||
public:
|
||||
|
||||
typedef int(*function_t)(lua_State*, int, int);
|
||||
|
||||
proxy_function_caller(
|
||||
lua_State* L
|
||||
, int params
|
||||
, function_t fun
|
||||
, const Tuple args)
|
||||
: m_state(L)
|
||||
, m_params(params)
|
||||
, m_fun(fun)
|
||||
, m_args(args)
|
||||
, m_called(false)
|
||||
{
|
||||
}
|
||||
|
||||
proxy_function_caller(const proxy_function_caller& rhs)
|
||||
: m_state(rhs.m_state)
|
||||
, m_params(rhs.m_params)
|
||||
, m_fun(rhs.m_fun)
|
||||
, m_args(rhs.m_args)
|
||||
, m_called(rhs.m_called)
|
||||
{
|
||||
rhs.m_called = true;
|
||||
}
|
||||
|
||||
~proxy_function_caller()
|
||||
{
|
||||
if (m_called) return;
|
||||
|
||||
m_called = true;
|
||||
lua_State* L = m_state;
|
||||
|
||||
int top = lua_gettop(L);
|
||||
|
||||
push_args_from_tuple<1>::apply(L, m_args);
|
||||
if (m_fun(L, boost::tuples::length<Tuple>::value, 0))
|
||||
{
|
||||
assert(lua_gettop(L) == top - m_params + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw luabind::error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
" If you want to handle the error you can use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
// pops the return values from the function call
|
||||
stack_pop pop(L, lua_gettop(L) - top + m_params);
|
||||
}
|
||||
|
||||
operator Ret()
|
||||
{
|
||||
typename mpl::apply_wrap2<default_policy,Ret,lua_to_cpp>::type converter;
|
||||
|
||||
m_called = true;
|
||||
lua_State* L = m_state;
|
||||
|
||||
int top = lua_gettop(L);
|
||||
|
||||
push_args_from_tuple<1>::apply(L, m_args);
|
||||
if (m_fun(L, boost::tuples::length<Tuple>::value, 1))
|
||||
{
|
||||
assert(lua_gettop(L) == top - m_params + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw luabind::error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
" If you want to handle the error you can use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
|
||||
// pops the return values from the function call
|
||||
stack_pop pop(L, lua_gettop(L) - top + m_params);
|
||||
|
||||
#ifndef LUABIND_NO_ERROR_CHECKING
|
||||
|
||||
if (converter.match(L, LUABIND_DECORATE_TYPE(Ret), -1) < 0)
|
||||
{
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw cast_failed(L, typeid(Ret));
|
||||
#else
|
||||
cast_failed_callback_fun e = get_cast_failed_callback();
|
||||
if (e) e(L, typeid(Ret));
|
||||
|
||||
assert(0 && "the lua function's return value could not be converted."
|
||||
" If you want to handle the error you can use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
return converter.apply(L, LUABIND_DECORATE_TYPE(Ret), -1);
|
||||
}
|
||||
|
||||
template<class Policies>
|
||||
Ret operator[](const Policies& p)
|
||||
{
|
||||
typedef typename detail::find_conversion_policy<0, Policies>::type converter_policy;
|
||||
typename mpl::apply_wrap2<converter_policy,Ret,lua_to_cpp>::type converter;
|
||||
|
||||
m_called = true;
|
||||
lua_State* L = m_state;
|
||||
|
||||
int top = lua_gettop(L);
|
||||
|
||||
detail::push_args_from_tuple<1>::apply(L, m_args, p);
|
||||
if (m_fun(L, boost::tuples::length<Tuple>::value, 1))
|
||||
{
|
||||
assert(lua_gettop(L) == top - m_params + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
" If you want to handle the error you can use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
|
||||
// pops the return values from the function call
|
||||
stack_pop pop(L, lua_gettop(L) - top + m_params);
|
||||
|
||||
#ifndef LUABIND_NO_ERROR_CHECKING
|
||||
|
||||
if (converter.match(L, LUABIND_DECORATE_TYPE(Ret), -1) < 0)
|
||||
{
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw cast_failed(L, typeid(Ret));
|
||||
#else
|
||||
cast_failed_callback_fun e = get_cast_failed_callback();
|
||||
if (e) e(L, typeid(Ret));
|
||||
|
||||
assert(0 && "the lua function's return value could not be converted."
|
||||
" If you want to handle the error you can use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
return converter.apply(L, LUABIND_DECORATE_TYPE(Ret), -1);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
lua_State* m_state;
|
||||
int m_params;
|
||||
function_t m_fun;
|
||||
Tuple m_args;
|
||||
mutable bool m_called;
|
||||
|
||||
};
|
||||
|
||||
// if the proxy_member_caller returns void
|
||||
template<class Tuple>
|
||||
class proxy_function_void_caller
|
||||
{
|
||||
friend class luabind::object;
|
||||
public:
|
||||
|
||||
typedef int(*function_t)(lua_State*, int, int);
|
||||
|
||||
proxy_function_void_caller(
|
||||
lua_State* L
|
||||
, int params
|
||||
, function_t fun
|
||||
, const Tuple args)
|
||||
: m_state(L)
|
||||
, m_params(params)
|
||||
, m_fun(fun)
|
||||
, m_args(args)
|
||||
, m_called(false)
|
||||
{
|
||||
}
|
||||
|
||||
proxy_function_void_caller(const proxy_function_void_caller& rhs)
|
||||
: m_state(rhs.m_state)
|
||||
, m_params(rhs.m_params)
|
||||
, m_fun(rhs.m_fun)
|
||||
, m_args(rhs.m_args)
|
||||
, m_called(rhs.m_called)
|
||||
{
|
||||
rhs.m_called = true;
|
||||
}
|
||||
|
||||
~proxy_function_void_caller()
|
||||
{
|
||||
if (m_called) return;
|
||||
|
||||
m_called = true;
|
||||
lua_State* L = m_state;
|
||||
|
||||
int top = lua_gettop(L);
|
||||
|
||||
push_args_from_tuple<1>::apply(L, m_args);
|
||||
if (m_fun(L, boost::tuples::length<Tuple>::value, 0))
|
||||
{
|
||||
assert(lua_gettop(L) == top - m_params + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw luabind::error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
" If you want to handle the error you can use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
// pops the return values from the function call
|
||||
stack_pop pop(L, lua_gettop(L) - top + m_params);
|
||||
}
|
||||
|
||||
template<class Policies>
|
||||
void operator[](const Policies& p)
|
||||
{
|
||||
m_called = true;
|
||||
lua_State* L = m_state;
|
||||
|
||||
int top = lua_gettop(L);
|
||||
|
||||
detail::push_args_from_tuple<1>::apply(L, m_args, p);
|
||||
if (m_fun(L, boost::tuples::length<Tuple>::value, 0))
|
||||
{
|
||||
assert(lua_gettop(L) == top - m_params + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
" If you want to handle the error you can use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
// pops the return values from the function call
|
||||
stack_pop pop(L, lua_gettop(L) - top + m_params);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
lua_State* m_state;
|
||||
int m_params;
|
||||
function_t m_fun;
|
||||
Tuple m_args;
|
||||
mutable bool m_called;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/call_function.hpp>, 1))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
}
|
||||
|
||||
#endif // LUABIND_CALL_FUNCTION_HPP_INCLUDED
|
||||
|
||||
#else
|
||||
#if BOOST_PP_ITERATION_FLAGS() == 1
|
||||
|
||||
#define LUABIND_TUPLE_PARAMS(z, n, data) const A##n *
|
||||
#define LUABIND_OPERATOR_PARAMS(z, n, data) const A##n & a##n
|
||||
|
||||
|
||||
template<class Ret BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
|
||||
typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type
|
||||
call_function(lua_State* L, const char* name BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _) )
|
||||
{
|
||||
assert(name && "luabind::call_function() expects a function name");
|
||||
typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t;
|
||||
#if BOOST_PP_ITERATION() == 0
|
||||
tuple_t args;
|
||||
#else
|
||||
tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a));
|
||||
#endif
|
||||
typedef typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type;
|
||||
|
||||
lua_getglobal(L, name);
|
||||
|
||||
return proxy_type(L, 1, &detail::pcall, args);
|
||||
}
|
||||
|
||||
template<class Ret BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
|
||||
typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type
|
||||
call_function(luabind::object const& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _) )
|
||||
{
|
||||
typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t;
|
||||
#if BOOST_PP_ITERATION() == 0
|
||||
tuple_t args;
|
||||
#else
|
||||
tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a));
|
||||
#endif
|
||||
typedef typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type;
|
||||
|
||||
obj.push(obj.interpreter());
|
||||
return proxy_type(obj.interpreter(), 1, &detail::pcall, args);
|
||||
}
|
||||
|
||||
template<class Ret BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
|
||||
typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type
|
||||
resume_function(lua_State* L, const char* name BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _) )
|
||||
{
|
||||
assert(name && "luabind::resume_function() expects a function name");
|
||||
typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t;
|
||||
#if BOOST_PP_ITERATION() == 0
|
||||
tuple_t args;
|
||||
#else
|
||||
tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a));
|
||||
#endif
|
||||
typedef typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type;
|
||||
|
||||
lua_getglobal(L, name);
|
||||
|
||||
return proxy_type(L, 1, &detail::resume_impl, args);
|
||||
}
|
||||
|
||||
template<class Ret BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
|
||||
typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type
|
||||
resume_function(luabind::object const& obj BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _) )
|
||||
{
|
||||
typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t;
|
||||
#if BOOST_PP_ITERATION() == 0
|
||||
tuple_t args;
|
||||
#else
|
||||
tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a));
|
||||
#endif
|
||||
typedef typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type;
|
||||
|
||||
obj.push(obj.interpreter());
|
||||
return proxy_type(obj.interpreter(), 1, &detail::resume_impl, args);
|
||||
}
|
||||
|
||||
template<class Ret BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
|
||||
typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type
|
||||
resume(lua_State* L BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _) )
|
||||
{
|
||||
typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t;
|
||||
#if BOOST_PP_ITERATION() == 0
|
||||
tuple_t args;
|
||||
#else
|
||||
tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a));
|
||||
#endif
|
||||
typedef typename boost::mpl::if_<boost::is_void<Ret>
|
||||
, luabind::detail::proxy_function_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_function_caller<Ret, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type;
|
||||
|
||||
return proxy_type(L, 0, &detail::resume_impl, args);
|
||||
}
|
||||
|
||||
|
||||
#undef LUABIND_OPERATOR_PARAMS
|
||||
#undef LUABIND_TUPLE_PARAMS
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,365 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#if !BOOST_PP_IS_ITERATING
|
||||
|
||||
#ifndef LUABIND_CALL_MEMBER_HPP_INCLUDED
|
||||
#define LUABIND_CALL_MEMBER_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/detail/convert_to_lua.hpp>
|
||||
#include <luabind/detail/pcall.hpp>
|
||||
#include <luabind/error.hpp>
|
||||
#include <luabind/detail/stack_utils.hpp>
|
||||
#include <luabind/object.hpp> // TODO: REMOVE DEPENDENCY
|
||||
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
|
||||
#include <boost/preprocessor/control/if.hpp>
|
||||
#include <boost/preprocessor/facilities/expand.hpp>
|
||||
#include <boost/preprocessor/repetition/enum.hpp>
|
||||
|
||||
#include <boost/mpl/apply_wrap.hpp>
|
||||
|
||||
namespace luabind
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
|
||||
namespace mpl = boost::mpl;
|
||||
|
||||
// if the proxy_member_caller returns non-void
|
||||
template<class Ret, class Tuple>
|
||||
class proxy_member_caller
|
||||
{
|
||||
// friend class luabind::object;
|
||||
public:
|
||||
|
||||
proxy_member_caller(lua_State* L_, const Tuple args)
|
||||
: L(L_)
|
||||
, m_args(args)
|
||||
, m_called(false)
|
||||
{
|
||||
}
|
||||
|
||||
proxy_member_caller(const proxy_member_caller& rhs)
|
||||
: L(rhs.L)
|
||||
, m_args(rhs.m_args)
|
||||
, m_called(rhs.m_called)
|
||||
{
|
||||
rhs.m_called = true;
|
||||
}
|
||||
|
||||
~proxy_member_caller()
|
||||
{
|
||||
if (m_called) return;
|
||||
|
||||
m_called = true;
|
||||
|
||||
// don't count the function and self-reference
|
||||
// since those will be popped by pcall
|
||||
int top = lua_gettop(L) - 2;
|
||||
|
||||
// pcall will pop the function and self reference
|
||||
// and all the parameters
|
||||
|
||||
push_args_from_tuple<1>::apply(L, m_args);
|
||||
if (pcall(L, boost::tuples::length<Tuple>::value + 1, 0))
|
||||
{
|
||||
assert(lua_gettop(L) == top + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw luabind::error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
"If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
// pops the return values from the function
|
||||
stack_pop pop(L, lua_gettop(L) - top);
|
||||
}
|
||||
|
||||
operator Ret()
|
||||
{
|
||||
typename mpl::apply_wrap2<default_policy,Ret,lua_to_cpp>::type converter;
|
||||
|
||||
m_called = true;
|
||||
|
||||
// don't count the function and self-reference
|
||||
// since those will be popped by pcall
|
||||
int top = lua_gettop(L) - 2;
|
||||
|
||||
// pcall will pop the function and self reference
|
||||
// and all the parameters
|
||||
push_args_from_tuple<1>::apply(L, m_args);
|
||||
if (pcall(L, boost::tuples::length<Tuple>::value + 1, 1))
|
||||
{
|
||||
assert(lua_gettop(L) == top + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw luabind::error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
"If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
|
||||
// pops the return values from the function
|
||||
stack_pop pop(L, lua_gettop(L) - top);
|
||||
|
||||
#ifndef LUABIND_NO_ERROR_CHECKING
|
||||
|
||||
if (converter.match(L, LUABIND_DECORATE_TYPE(Ret), -1) < 0)
|
||||
{
|
||||
assert(lua_gettop(L) == top + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw cast_failed(L, typeid(Ret));
|
||||
#else
|
||||
cast_failed_callback_fun e = get_cast_failed_callback();
|
||||
if (e) e(L, typeid(Ret));
|
||||
|
||||
assert(0 && "the lua function's return value could not be converted."
|
||||
"If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
return converter.apply(L, LUABIND_DECORATE_TYPE(Ret), -1);
|
||||
}
|
||||
|
||||
template<class Policies>
|
||||
Ret operator[](const Policies& p)
|
||||
{
|
||||
typedef typename find_conversion_policy<0, Policies>::type converter_policy;
|
||||
typename mpl::apply_wrap2<converter_policy,Ret,lua_to_cpp>::type converter;
|
||||
|
||||
m_called = true;
|
||||
|
||||
// don't count the function and self-reference
|
||||
// since those will be popped by pcall
|
||||
int top = lua_gettop(L) - 2;
|
||||
|
||||
// pcall will pop the function and self reference
|
||||
// and all the parameters
|
||||
|
||||
detail::push_args_from_tuple<1>::apply(L, m_args, p);
|
||||
if (pcall(L, boost::tuples::length<Tuple>::value + 1, 1))
|
||||
{
|
||||
assert(lua_gettop(L) == top + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
"If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
|
||||
// pops the return values from the function
|
||||
stack_pop pop(L, lua_gettop(L) - top);
|
||||
|
||||
#ifndef LUABIND_NO_ERROR_CHECKING
|
||||
|
||||
if (converter.match(L, LUABIND_DECORATE_TYPE(Ret), -1) < 0)
|
||||
{
|
||||
assert(lua_gettop(L) == top + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw cast_failed(L, typeid(Ret));
|
||||
#else
|
||||
cast_failed_callback_fun e = get_cast_failed_callback();
|
||||
if (e) e(L, typeid(Ret));
|
||||
|
||||
assert(0 && "the lua function's return value could not be converted."
|
||||
"If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
return converter.apply(L, LUABIND_DECORATE_TYPE(Ret), -1);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
lua_State* L;
|
||||
Tuple m_args;
|
||||
mutable bool m_called;
|
||||
|
||||
};
|
||||
|
||||
// if the proxy_member_caller returns void
|
||||
template<class Tuple>
|
||||
class proxy_member_void_caller
|
||||
{
|
||||
friend class luabind::object;
|
||||
public:
|
||||
|
||||
proxy_member_void_caller(lua_State* L_, const Tuple args)
|
||||
: L(L_)
|
||||
, m_args(args)
|
||||
, m_called(false)
|
||||
{
|
||||
}
|
||||
|
||||
proxy_member_void_caller(const proxy_member_void_caller& rhs)
|
||||
: L(rhs.L)
|
||||
, m_args(rhs.m_args)
|
||||
, m_called(rhs.m_called)
|
||||
{
|
||||
rhs.m_called = true;
|
||||
}
|
||||
|
||||
~proxy_member_void_caller()
|
||||
{
|
||||
if (m_called) return;
|
||||
|
||||
m_called = true;
|
||||
|
||||
// don't count the function and self-reference
|
||||
// since those will be popped by pcall
|
||||
int top = lua_gettop(L) - 2;
|
||||
|
||||
// pcall will pop the function and self reference
|
||||
// and all the parameters
|
||||
|
||||
push_args_from_tuple<1>::apply(L, m_args);
|
||||
if (pcall(L, boost::tuples::length<Tuple>::value + 1, 0))
|
||||
{
|
||||
assert(lua_gettop(L) == top + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw luabind::error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
"If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
// pops the return values from the function
|
||||
stack_pop pop(L, lua_gettop(L) - top);
|
||||
}
|
||||
|
||||
template<class Policies>
|
||||
void operator[](const Policies& p)
|
||||
{
|
||||
m_called = true;
|
||||
|
||||
// don't count the function and self-reference
|
||||
// since those will be popped by pcall
|
||||
int top = lua_gettop(L) - 2;
|
||||
|
||||
// pcall will pop the function and self reference
|
||||
// and all the parameters
|
||||
|
||||
detail::push_args_from_tuple<1>::apply(L, m_args, p);
|
||||
if (pcall(L, boost::tuples::length<Tuple>::value + 1, 0))
|
||||
{
|
||||
assert(lua_gettop(L) == top + 1);
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw error(L);
|
||||
#else
|
||||
error_callback_fun e = get_error_callback();
|
||||
if (e) e(L);
|
||||
|
||||
assert(0 && "the lua function threw an error and exceptions are disabled."
|
||||
"If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
// pops the return values from the function
|
||||
stack_pop pop(L, lua_gettop(L) - top);
|
||||
}
|
||||
|
||||
private:
|
||||
lua_State* L;
|
||||
Tuple m_args;
|
||||
mutable bool m_called;
|
||||
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 (4, (0, LUABIND_MAX_ARITY, <luabind/detail/call_member.hpp>, 1))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
}
|
||||
|
||||
#endif // LUABIND_CALL_MEMBER_HPP_INCLUDED
|
||||
|
||||
#else
|
||||
#if BOOST_PP_ITERATION_FLAGS() == 1
|
||||
|
||||
#define LUABIND_TUPLE_PARAMS(z, n, data) const A##n *
|
||||
#define LUABIND_OPERATOR_PARAMS(z, n, data) const A##n & a##n
|
||||
|
||||
template<class R BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), class A)>
|
||||
typename boost::mpl::if_<boost::is_void<R>
|
||||
, luabind::detail::proxy_member_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_member_caller<R, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type
|
||||
call_member(object const& obj, const char* name BOOST_PP_COMMA_IF(BOOST_PP_ITERATION()) BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_OPERATOR_PARAMS, _))
|
||||
{
|
||||
typedef boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> tuple_t;
|
||||
#if BOOST_PP_ITERATION() == 0
|
||||
tuple_t args;
|
||||
#else
|
||||
tuple_t args(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), &a));
|
||||
#endif
|
||||
|
||||
typedef typename boost::mpl::if_<boost::is_void<R>
|
||||
, luabind::detail::proxy_member_void_caller<boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> >
|
||||
, luabind::detail::proxy_member_caller<R, boost::tuples::tuple<BOOST_PP_ENUM(BOOST_PP_ITERATION(), LUABIND_TUPLE_PARAMS, _)> > >::type proxy_type;
|
||||
|
||||
// this will be cleaned up by the proxy object
|
||||
// once the call has been made
|
||||
|
||||
// get the function
|
||||
obj.push(obj.interpreter());
|
||||
lua_pushstring(obj.interpreter(), name);
|
||||
lua_gettable(obj.interpreter(), -2);
|
||||
// duplicate the self-object
|
||||
lua_pushvalue(obj.interpreter(), -2);
|
||||
// remove the bottom self-object
|
||||
lua_remove(obj.interpreter(), -3);
|
||||
|
||||
// now the function and self objects
|
||||
// are on the stack. These will both
|
||||
// be popped by pcall
|
||||
return proxy_type(obj.interpreter(), args);
|
||||
}
|
||||
|
||||
#undef LUABIND_OPERATOR_PARAMS
|
||||
#undef LUABIND_TUPLE_PARAMS
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
// Copyright (c) 2004 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
#define LUABIND_UNWRAP_PARAMETER(z, n, _) \
|
||||
typename detail::unwrap_parameter_type<T, BOOST_PP_CAT(A, n)>::type \
|
||||
BOOST_PP_CAT(_, n)
|
||||
|
||||
template<class Self BOOST_PP_ENUM_TRAILING_PARAMS(N, class A)>
|
||||
struct BOOST_PP_CAT(call_operator, N)
|
||||
: detail::operator_<
|
||||
BOOST_PP_CAT(call_operator, N)<
|
||||
Self BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
|
||||
>
|
||||
>
|
||||
{
|
||||
BOOST_PP_CAT(call_operator, N)(int) {}
|
||||
|
||||
template<class T, class Policies>
|
||||
struct apply
|
||||
{
|
||||
static void execute(
|
||||
lua_State* L
|
||||
, typename detail::unwrap_parameter_type<T, Self>::type self
|
||||
BOOST_PP_ENUM_TRAILING(N, LUABIND_UNWRAP_PARAMETER, _)
|
||||
)
|
||||
{
|
||||
using namespace detail;
|
||||
operator_result(
|
||||
L
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
, self(BOOST_PP_ENUM_PARAMS(N, _))
|
||||
#else
|
||||
, (self(BOOST_PP_ENUM_PARAMS(N, _)), detail::operator_void_return())
|
||||
#endif
|
||||
, (Policies*)0
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
static char const* name() { return "__call"; }
|
||||
};
|
||||
|
||||
#undef LUABIND_UNWRAP_PARAMETER
|
||||
#undef N
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
// Copyright (c) 2004 Daniel Wallin
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef CLASS_CACHE_040218_HPP
|
||||
#define CLASS_CACHE_040218_HPP
|
||||
|
||||
#include <luabind/prefix.hpp>
|
||||
#include <boost/type_traits/add_reference.hpp>
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
#ifdef LUABIND_NOT_THREADSAFE
|
||||
|
||||
class class_rep;
|
||||
|
||||
template<class T>
|
||||
struct class_cache_impl
|
||||
{
|
||||
static lua_State* state;
|
||||
static class_rep* class_;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
lua_State* class_cache_impl<T>::state = 0;
|
||||
|
||||
template<class T>
|
||||
class_rep* class_cache_impl<T>::class_ = 0;
|
||||
|
||||
template<class T>
|
||||
struct class_cache
|
||||
: class_cache_impl<
|
||||
typename boost::add_reference<
|
||||
typename boost::add_const<
|
||||
T
|
||||
>::type
|
||||
>::type
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
template<class T>
|
||||
class_rep* get_class_rep(lua_State* L, void(*)(T*) = 0)
|
||||
{
|
||||
if (class_cache<T>::state != L)
|
||||
{
|
||||
class_cache<T>::state = L;
|
||||
|
||||
class_registry* registry = class_registry::get_registry(L);
|
||||
class_cache<T>::class_ = registry->find_class(typeid(T));
|
||||
}
|
||||
|
||||
return class_cache<T>::class_;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
template<class T>
|
||||
class_rep* get_class_rep(lua_State* L, void(*)(T*) = 0)
|
||||
{
|
||||
class_registry* registry = class_registry::get_registry(L);
|
||||
return registry->find_class(typeid(T));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // CLASS_CACHE_040218_HPP
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_CLASS_REGISTRY_HPP_INCLUDED
|
||||
#define LUABIND_CLASS_REGISTRY_HPP_INCLUDED
|
||||
|
||||
#include <map>
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/open.hpp>
|
||||
#include <luabind/typeid.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
class class_rep;
|
||||
|
||||
struct LUABIND_API class_registry
|
||||
{
|
||||
class_registry(lua_State* L);
|
||||
|
||||
static class_registry* get_registry(lua_State* L);
|
||||
|
||||
int cpp_instance() const { return m_instance_metatable; }
|
||||
int cpp_class() const { return m_cpp_class_metatable; }
|
||||
|
||||
int lua_instance() const { return m_instance_metatable; }
|
||||
int lua_class() const { return m_lua_class_metatable; }
|
||||
int lua_function() const { return m_lua_function_metatable; }
|
||||
|
||||
void add_class(type_id const& info, class_rep* crep);
|
||||
|
||||
class_rep* find_class(type_id const& info) const;
|
||||
|
||||
std::map<type_id, class_rep*> const& get_classes() const
|
||||
{
|
||||
return m_classes;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
std::map<type_id, class_rep*> m_classes;
|
||||
|
||||
// this is a lua reference that points to the lua table
|
||||
// that is to be used as meta table for all C++ class
|
||||
// instances. It is a kind of v-table.
|
||||
int m_instance_metatable;
|
||||
|
||||
// this is a lua reference to the metatable to be used
|
||||
// for all classes defined in C++.
|
||||
int m_cpp_class_metatable;
|
||||
|
||||
// this is a lua reference to the metatable to be used
|
||||
// for all classes defined in lua
|
||||
int m_lua_class_metatable;
|
||||
|
||||
// this metatable only contains a destructor
|
||||
// for luabind::Detail::free_functions::function_rep
|
||||
int m_lua_function_metatable;
|
||||
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#endif // LUABIND_CLASS_REGISTRY_HPP_INCLUDED
|
||||
|
||||
@@ -0,0 +1,213 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_CLASS_REP_HPP_INCLUDED
|
||||
#define LUABIND_CLASS_REP_HPP_INCLUDED
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/lua_include.hpp>
|
||||
#include <luabind/detail/object_rep.hpp>
|
||||
#include <luabind/detail/garbage_collector.hpp>
|
||||
#include <luabind/detail/operator_id.hpp>
|
||||
#include <luabind/detail/class_registry.hpp>
|
||||
#include <luabind/error.hpp>
|
||||
#include <luabind/handle.hpp>
|
||||
#include <luabind/detail/primitives.hpp>
|
||||
#include <luabind/typeid.hpp>
|
||||
#include <luabind/detail/ref.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
|
||||
LUABIND_API std::string stack_content_by_name(lua_State* L, int start_index);
|
||||
|
||||
struct class_registration;
|
||||
|
||||
struct conversion_storage;
|
||||
|
||||
// This function is used as a tag to identify "properties".
|
||||
LUABIND_API int property_tag(lua_State*);
|
||||
|
||||
// this is class-specific information, poor man's vtable
|
||||
// this is allocated statically (removed by the compiler)
|
||||
// a pointer to this structure is stored in the lua tables'
|
||||
// metatable with the name __classrep
|
||||
// it is used when matching parameters to function calls
|
||||
// to determine possible implicit casts
|
||||
// it is also used when finding the best match for overloaded
|
||||
// methods
|
||||
|
||||
class cast_graph;
|
||||
class class_id_map;
|
||||
|
||||
class LUABIND_API class_rep
|
||||
{
|
||||
friend struct class_registration;
|
||||
friend int super_callback(lua_State*);
|
||||
//TODO: avoid the lua-prefix
|
||||
friend int lua_class_gettable(lua_State*);
|
||||
friend int lua_class_settable(lua_State*);
|
||||
friend int static_class_gettable(lua_State*);
|
||||
public:
|
||||
|
||||
enum class_type
|
||||
{
|
||||
cpp_class = 0,
|
||||
lua_class = 1
|
||||
};
|
||||
|
||||
// EXPECTS THE TOP VALUE ON THE LUA STACK TO
|
||||
// BE THE USER DATA WHERE THIS CLASS IS BEING
|
||||
// INSTANTIATED!
|
||||
class_rep(type_id const& type
|
||||
, const char* name
|
||||
, lua_State* L
|
||||
);
|
||||
|
||||
// used when creating a lua class
|
||||
// EXPECTS THE TOP VALUE ON THE LUA STACK TO
|
||||
// BE THE USER DATA WHERE THIS CLASS IS BEING
|
||||
// INSTANTIATED!
|
||||
class_rep(lua_State* L, const char* name);
|
||||
|
||||
~class_rep();
|
||||
|
||||
std::pair<void*,void*> allocate(lua_State* L) const;
|
||||
|
||||
// this is called as metamethod __call on the class_rep.
|
||||
static int constructor_dispatcher(lua_State* L);
|
||||
|
||||
struct base_info
|
||||
{
|
||||
int pointer_offset; // the offset added to the pointer to obtain a basepointer (due to multiple-inheritance)
|
||||
class_rep* base;
|
||||
};
|
||||
|
||||
void add_base_class(const base_info& binfo);
|
||||
|
||||
const std::vector<base_info>& bases() const throw() { return m_bases; }
|
||||
|
||||
void set_type(type_id const& t) { m_type = t; }
|
||||
type_id const& type() const throw() { return m_type; }
|
||||
|
||||
const char* name() const throw() { return m_name; }
|
||||
|
||||
// the lua reference to the metatable for this class' instances
|
||||
int metatable_ref() const throw() { return m_instance_metatable; }
|
||||
|
||||
void get_table(lua_State* L) const { m_table.push(L); }
|
||||
void get_default_table(lua_State* L) const { m_default_table.push(L); }
|
||||
|
||||
class_type get_class_type() const { return m_class_type; }
|
||||
|
||||
void add_static_constant(const char* name, int val);
|
||||
|
||||
static int super_callback(lua_State* L);
|
||||
|
||||
static int lua_settable_dispatcher(lua_State* L);
|
||||
|
||||
// called from the metamethod for __index
|
||||
// obj is the object pointer
|
||||
static int static_class_gettable(lua_State* L);
|
||||
|
||||
bool has_operator_in_lua(lua_State*, int id);
|
||||
|
||||
cast_graph const& casts() const
|
||||
{
|
||||
return *m_casts;
|
||||
}
|
||||
|
||||
class_id_map const& classes() const
|
||||
{
|
||||
return *m_classes;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
void cache_operators(lua_State*);
|
||||
|
||||
// this is a pointer to the type_info structure for
|
||||
// this type
|
||||
// warning: this may be a problem when using dll:s, since
|
||||
// typeid() may actually return different pointers for the same
|
||||
// type.
|
||||
type_id m_type;
|
||||
|
||||
// a list of info for every class this class derives from
|
||||
// the information stored here is sufficient to do
|
||||
// type casts to the base classes
|
||||
std::vector<base_info> m_bases;
|
||||
|
||||
// the class' name (as given when registered to lua with class_)
|
||||
const char* m_name;
|
||||
|
||||
// a reference to this structure itself. Since this struct
|
||||
// is kept inside lua (to let lua collect it when lua_close()
|
||||
// is called) we need to lock it to prevent collection.
|
||||
// the actual reference is not currently used.
|
||||
detail::lua_reference m_self_ref;
|
||||
|
||||
// this should always be used when accessing
|
||||
// members in instances of a class.
|
||||
// this table contains c closures for all
|
||||
// member functions in this class, they
|
||||
// may point to both static and virtual functions
|
||||
handle m_table;
|
||||
|
||||
// this table contains default implementations of the
|
||||
// virtual functions in m_table.
|
||||
handle m_default_table;
|
||||
|
||||
// the type of this class.. determines if it's written in c++ or lua
|
||||
class_type m_class_type;
|
||||
|
||||
// this is a lua reference that points to the lua table
|
||||
// that is to be used as meta table for all instances
|
||||
// of this class.
|
||||
int m_instance_metatable;
|
||||
|
||||
std::map<const char*, int, ltstr> m_static_constants;
|
||||
|
||||
// the first time an operator is invoked
|
||||
// we check the associated lua table
|
||||
// and cache the result
|
||||
int m_operator_cache;
|
||||
|
||||
cast_graph* m_casts;
|
||||
class_id_map* m_classes;
|
||||
};
|
||||
|
||||
bool is_class_rep(lua_State* L, int index);
|
||||
|
||||
}}
|
||||
|
||||
//#include <luabind/detail/overload_rep_impl.hpp>
|
||||
|
||||
#endif // LUABIND_CLASS_REP_HPP_INCLUDED
|
||||
@@ -0,0 +1,73 @@
|
||||
// Copyright Daniel Wallin 2008. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef LUABIND_COMPUTE_RANK_081006_HPP
|
||||
# define LUABIND_COMPUTE_RANK_081006_HPP
|
||||
|
||||
# include <luabind/config.hpp>
|
||||
# include <luabind/detail/policy.hpp>
|
||||
# include <boost/mpl/apply_wrap.hpp>
|
||||
# include <boost/mpl/begin_end.hpp>
|
||||
# include <boost/mpl/int.hpp>
|
||||
# include <boost/mpl/next.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
namespace mpl = boost::mpl;
|
||||
|
||||
template <class Idx, class Iter, class End, class Policies>
|
||||
int compute_score_aux(
|
||||
lua_State*L, int index, Idx, Iter, End end, Policies const& policies)
|
||||
{
|
||||
typedef typename Iter::type arg_type;
|
||||
typedef typename find_conversion_policy<Idx::value, Policies>::type
|
||||
conversion_policy;
|
||||
typedef typename mpl::apply_wrap2<
|
||||
conversion_policy, arg_type, lua_to_cpp>::type converter;
|
||||
|
||||
int score = converter::match(L, LUABIND_DECORATE_TYPE(arg_type), index);
|
||||
|
||||
if (score < 0)
|
||||
return score;
|
||||
|
||||
if (conversion_policy::has_arg)
|
||||
++index;
|
||||
|
||||
int next = compute_score_aux(
|
||||
L
|
||||
, index
|
||||
, typename mpl::next<Idx>::type()
|
||||
, typename mpl::next<Iter>::type()
|
||||
, end
|
||||
, policies
|
||||
);
|
||||
|
||||
if (next < 0)
|
||||
return next;
|
||||
|
||||
return score + next;
|
||||
}
|
||||
|
||||
template <class Idx, class End, class Policies>
|
||||
int compute_score_aux(lua_State*, int, Idx, End, End, Policies const&)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <class Signature, class Policies>
|
||||
int compute_score(lua_State* L, Signature, Policies const& policies)
|
||||
{
|
||||
return compute_score_aux(
|
||||
L
|
||||
, 1
|
||||
, mpl::int_<1>()
|
||||
, typename mpl::next<typename mpl::begin<Signature>::type>::type()
|
||||
, typename mpl::end<Signature>::type()
|
||||
, policies
|
||||
);
|
||||
}
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // LUABIND_COMPUTE_RANK_081006_HPP
|
||||
@@ -0,0 +1,111 @@
|
||||
// Copyright Daniel Wallin 2008. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#if !BOOST_PP_IS_ITERATING
|
||||
|
||||
# ifndef LUABIND_DETAIL_CONSTRUCTOR_081018_HPP
|
||||
# define LUABIND_DETAIL_CONSTRUCTOR_081018_HPP
|
||||
|
||||
# include <luabind/get_main_thread.hpp>
|
||||
# include <luabind/object.hpp>
|
||||
# include <luabind/wrapper_base.hpp>
|
||||
# include <luabind/detail/inheritance.hpp>
|
||||
|
||||
# include <boost/preprocessor/iteration/iterate.hpp>
|
||||
# include <boost/preprocessor/iteration/local.hpp>
|
||||
# include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
# include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
inline void inject_backref(lua_State*, void*, void*)
|
||||
{}
|
||||
|
||||
template <class T>
|
||||
void inject_backref(lua_State* L, T* p, wrap_base*)
|
||||
{
|
||||
weak_ref(get_main_thread(L), L, 1).swap(wrap_access::ref(*p));
|
||||
}
|
||||
|
||||
template <std::size_t Arity, class T, class Pointer, class Signature>
|
||||
struct construct_aux;
|
||||
|
||||
template <class T, class Pointer, class Signature>
|
||||
struct construct
|
||||
: construct_aux<mpl::size<Signature>::value - 2, T, Pointer, Signature>
|
||||
{};
|
||||
|
||||
template <class T, class Pointer, class Signature>
|
||||
struct construct_aux<0, T, Pointer, Signature>
|
||||
{
|
||||
typedef pointer_holder<Pointer, T> holder_type;
|
||||
|
||||
void operator()(argument const& self_) const
|
||||
{
|
||||
object_rep* self = touserdata<object_rep>(self_);
|
||||
class_rep* cls = self->crep();
|
||||
|
||||
std::auto_ptr<T> instance(new T);
|
||||
inject_backref(self_.interpreter(), instance.get(), instance.get());
|
||||
|
||||
void* naked_ptr = instance.get();
|
||||
Pointer ptr(instance.release());
|
||||
|
||||
void* storage = self->allocate(sizeof(holder_type));
|
||||
|
||||
self->set_instance(new (storage) holder_type(
|
||||
ptr, registered_class<T>::id, naked_ptr, cls));
|
||||
}
|
||||
};
|
||||
|
||||
# define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, LUABIND_MAX_ARITY, <luabind/detail/constructor.hpp>))
|
||||
# include BOOST_PP_ITERATE()
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
# endif // LUABIND_DETAIL_CONSTRUCTOR_081018_HPP
|
||||
|
||||
#else // !BOOST_PP_IS_ITERATING
|
||||
|
||||
# define N BOOST_PP_ITERATION()
|
||||
|
||||
template <class T, class Pointer, class Signature>
|
||||
struct construct_aux<N, T, Pointer, Signature>
|
||||
{
|
||||
typedef typename mpl::begin<Signature>::type first;
|
||||
typedef typename mpl::next<first>::type iter0;
|
||||
|
||||
# define BOOST_PP_LOCAL_MACRO(n) \
|
||||
typedef typename mpl::next< \
|
||||
BOOST_PP_CAT(iter,BOOST_PP_DEC(n))>::type BOOST_PP_CAT(iter,n); \
|
||||
typedef typename BOOST_PP_CAT(iter,n)::type BOOST_PP_CAT(a,BOOST_PP_DEC(n));
|
||||
|
||||
# define BOOST_PP_LOCAL_LIMITS (1,N)
|
||||
# include BOOST_PP_LOCAL_ITERATE()
|
||||
|
||||
typedef pointer_holder<Pointer, T> holder_type;
|
||||
|
||||
void operator()(argument const& self_, BOOST_PP_ENUM_BINARY_PARAMS(N,a,_)) const
|
||||
{
|
||||
object_rep* self = touserdata<object_rep>(self_);
|
||||
class_rep* cls = self->crep();
|
||||
|
||||
std::auto_ptr<T> instance(new T(BOOST_PP_ENUM_PARAMS(N,_)));
|
||||
inject_backref(self_.interpreter(), instance.get(), instance.get());
|
||||
|
||||
void* naked_ptr = instance.get();
|
||||
Pointer ptr(instance.release());
|
||||
|
||||
void* storage = self->allocate(sizeof(holder_type));
|
||||
|
||||
self->set_instance(new (storage) holder_type(
|
||||
ptr, registered_class<T>::id, naked_ptr, cls));
|
||||
}
|
||||
};
|
||||
|
||||
# undef N
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
// Copyright Daniel Wallin 2008. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef LUABIND_CONVERSION_STORAGE_080930_HPP
|
||||
# define LUABIND_CONVERSION_STORAGE_080930_HPP
|
||||
|
||||
# include <luabind/config.hpp>
|
||||
# include <boost/aligned_storage.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
typedef void(*destruction_function)(void*);
|
||||
|
||||
// This is used by the converters in policy.hpp, and
|
||||
// class_rep::convert_to as temporary storage when constructing
|
||||
// holders.
|
||||
|
||||
struct conversion_storage
|
||||
{
|
||||
conversion_storage()
|
||||
: destructor(0)
|
||||
{}
|
||||
|
||||
~conversion_storage()
|
||||
{
|
||||
if (destructor)
|
||||
destructor(&data);
|
||||
}
|
||||
|
||||
// Unfortunately the converters currently doesn't have access to
|
||||
// the actual type being converted when this is instantiated, so
|
||||
// we have to guess a max size.
|
||||
boost::aligned_storage<128> data;
|
||||
destruction_function destructor;
|
||||
};
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // LUABIND_CONVERSION_STORAGE_080930_HPP
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_CONVERT_TO_LUA_HPP_INCLUDED
|
||||
#define LUABIND_CONVERT_TO_LUA_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/detail/policy.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#include <boost/mpl/apply_wrap.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
template<bool IsReferenceWrapper = false>
|
||||
struct unwrap_ref
|
||||
{
|
||||
template<class T>
|
||||
static const T& get(const T& r) { return r; }
|
||||
|
||||
template<class T>
|
||||
struct apply
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct unwrap_ref<true>
|
||||
{
|
||||
template<class T>
|
||||
static T& get(const boost::reference_wrapper<T>& r) { return r.get(); }
|
||||
|
||||
template<class T>
|
||||
struct apply
|
||||
{
|
||||
typedef typename T::type& type;
|
||||
};
|
||||
};
|
||||
|
||||
namespace mpl = boost::mpl;
|
||||
|
||||
template<class T>
|
||||
void convert_to_lua(lua_State* L, const T& v)
|
||||
{
|
||||
typedef typename mpl::apply_wrap1<
|
||||
unwrap_ref<boost::is_reference_wrapper<T>::value>
|
||||
, T
|
||||
>::type value_type;
|
||||
|
||||
typename mpl::apply_wrap2<default_policy,value_type,cpp_to_lua>::type converter;
|
||||
|
||||
converter.apply(L, unwrap_ref<boost::is_reference_wrapper<T>::value>::get(v));
|
||||
}
|
||||
|
||||
template<int Index, class T, class Policies>
|
||||
void convert_to_lua_p(lua_State* L, const T& v, const Policies&)
|
||||
{
|
||||
typedef typename mpl::apply_wrap1<
|
||||
unwrap_ref<boost::is_reference_wrapper<T>::value>
|
||||
, T
|
||||
>::type value_type;
|
||||
|
||||
typedef typename find_conversion_policy<Index, Policies>::type converter_policy;
|
||||
typename mpl::apply_wrap2<converter_policy,value_type,cpp_to_lua>::type converter;
|
||||
|
||||
converter.apply(L, unwrap_ref<boost::is_reference_wrapper<T>::value>::get(v));
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef LUABIND_DEBUG_HPP_INCLUDED
|
||||
#define LUABIND_DEBUG_HPP_INCLUDED
|
||||
|
||||
#ifndef NDEBUG
|
||||
|
||||
#include <luabind/lua_include.hpp>
|
||||
#include <cassert>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
struct stack_checker_type
|
||||
{
|
||||
stack_checker_type(lua_State* L)
|
||||
: m_L(L)
|
||||
, m_stack(lua_gettop(m_L))
|
||||
{}
|
||||
|
||||
~stack_checker_type()
|
||||
{
|
||||
assert(m_stack == lua_gettop(m_L));
|
||||
}
|
||||
|
||||
lua_State* m_L;
|
||||
int m_stack;
|
||||
};
|
||||
|
||||
}}
|
||||
#define LUABIND_CHECK_STACK(L) luabind::detail::stack_checker_type stack_checker_object(L)
|
||||
#else
|
||||
#define LUABIND_CHECK_STACK(L) do {} while (0)
|
||||
#endif
|
||||
|
||||
#endif // LUABIND_DEBUG_HPP_INCLUDED
|
||||
@@ -0,0 +1,266 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_DECORATE_TYPE_HPP_INCLUDED
|
||||
#define LUABIND_DECORATE_TYPE_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/detail/primitives.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
template<class T>
|
||||
struct decorated_type
|
||||
{
|
||||
static by_value<T> t;
|
||||
static inline by_value<T>& get() { return /*by_value<T>()*/t; }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
by_value<T> decorated_type<T>::t;
|
||||
|
||||
template<class T>
|
||||
struct decorated_type<T*>
|
||||
{
|
||||
static by_pointer<T> t;
|
||||
static inline by_pointer<T>& get() { return /*by_pointer<T>()*/t; }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
by_pointer<T> decorated_type<T*>::t;
|
||||
|
||||
template<class T>
|
||||
struct decorated_type<const T*>
|
||||
{
|
||||
static by_const_pointer<T> t;
|
||||
static inline by_const_pointer<T> get() { return /*by_const_pointer<T>()*/t; }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
by_const_pointer<T> decorated_type<const T*>::t;
|
||||
|
||||
template<class T>
|
||||
struct decorated_type<const T* const>
|
||||
{
|
||||
static by_const_pointer<T> t;
|
||||
static inline by_const_pointer<T>& get() { return /*by_const_pointer<T>()*/t; }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
by_const_pointer<T> decorated_type<const T* const>::t;
|
||||
|
||||
template<class T>
|
||||
struct decorated_type<T&>
|
||||
{
|
||||
static by_reference<T> t;
|
||||
static inline by_reference<T>& get() { return /*by_reference<T>()*/t; }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
by_reference<T> decorated_type<T&>::t;
|
||||
|
||||
template<class T>
|
||||
struct decorated_type<const T&>
|
||||
{
|
||||
static by_const_reference<T> t;
|
||||
static inline by_const_reference<T>& get() { return /*by_const_reference<T>()*/t; }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
by_const_reference<T> decorated_type<const T&>::t;
|
||||
|
||||
#define LUABIND_DECORATE_TYPE(t) luabind::detail::decorated_type<t>::get()
|
||||
|
||||
#else
|
||||
|
||||
#include <boost/type_traits/is_array.hpp>
|
||||
|
||||
namespace
|
||||
{
|
||||
LUABIND_ANONYMOUS_FIX char decorated_type_array[64];
|
||||
}
|
||||
|
||||
template<class T>
|
||||
struct decorated_type_cref_impl
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC == 1200
|
||||
template<class U>
|
||||
static by_const_reference<U> get(const U&)
|
||||
{
|
||||
return by_const_reference<U>();
|
||||
}
|
||||
static T data() { return reinterpret_cast<T>(decorated_type_array); }
|
||||
#else
|
||||
|
||||
static void(*data())(T)
|
||||
{ return (void(*)(T))0; }
|
||||
|
||||
template<class U>
|
||||
static by_const_reference<U> get(void(*f)(const U&))
|
||||
{ return by_const_reference<U>(); }
|
||||
#endif
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct decorated_type_ref_impl
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC == 1200
|
||||
template<class U>
|
||||
static by_reference<U> get(U&)
|
||||
{
|
||||
return by_reference<U>();
|
||||
}
|
||||
static T data() { return reinterpret_cast<T>(decorated_type_array); }
|
||||
#else
|
||||
static void(*data())(T)
|
||||
{ return (void(*)(T))0; }
|
||||
|
||||
template<class U>
|
||||
static by_reference<U> get(void(*)(U&))
|
||||
{ return by_reference<U>(); }
|
||||
#endif
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct decorated_type_cptr_impl
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC == 1200
|
||||
template<class U>
|
||||
static by_const_pointer<U> get(const U*)
|
||||
{
|
||||
return by_const_pointer<U>();
|
||||
}
|
||||
static T& data() { return reinterpret_cast<T&>(decorated_type_array); }
|
||||
#else
|
||||
static void(*data())(T)
|
||||
{ return (void(*)(T))0; }
|
||||
|
||||
template<class U>
|
||||
static by_const_pointer<U> get(void(*)(const U*))
|
||||
{ return by_const_pointer<U>(); }
|
||||
#endif
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct decorated_type_ptr_impl
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC == 1200
|
||||
template<class U>
|
||||
static by_pointer<U> get(U*)
|
||||
{
|
||||
return by_pointer<U>();
|
||||
}
|
||||
static T& data() { return reinterpret_cast<T&>(decorated_type_array); }
|
||||
#else
|
||||
static void(*data())(T)
|
||||
{ return (void(*)(T))0; }
|
||||
|
||||
template<class U>
|
||||
static by_pointer<U> get(void(*)(U*))
|
||||
{ return by_pointer<U>(); }
|
||||
#endif
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct decorated_type_value_impl
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC == 1200
|
||||
template<class U>
|
||||
static by_value<U> get(U&)
|
||||
{
|
||||
return by_value<U>();
|
||||
}
|
||||
static T& data() { return reinterpret_cast<T&>(decorated_type_array); }
|
||||
#else
|
||||
static void(*data())(T&)
|
||||
{ return (void(*)(T&))0; }
|
||||
|
||||
template<class U>
|
||||
static by_value<U> get(void(*)(U&))
|
||||
{ return by_value<U>(); }
|
||||
#endif
|
||||
};
|
||||
|
||||
template<>
|
||||
struct decorated_type_value_impl<void>
|
||||
{
|
||||
static by_value<void> get(int)
|
||||
{
|
||||
return by_value<void>();
|
||||
}
|
||||
static int data() { return 0; }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct decorated_type_array_impl
|
||||
{
|
||||
template<class U>
|
||||
static by_pointer<U> get(U*)
|
||||
{
|
||||
return by_pointer<U>();
|
||||
}
|
||||
|
||||
template<class U>
|
||||
static by_pointer<U> get(void(*)(U))
|
||||
{ return by_pointer<U>(); }
|
||||
|
||||
static T& data() { return reinterpret_cast<T&>(decorated_type_array); }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct decorated_type
|
||||
// : boost::mpl::if_<boost::is_array<T>
|
||||
// , decorated_type_array_impl<T>
|
||||
: boost::mpl::if_<luabind::detail::is_const_reference<T>
|
||||
, decorated_type_cref_impl<T>
|
||||
, typename boost::mpl::if_<luabind::detail::is_nonconst_reference<T>
|
||||
, decorated_type_ref_impl<T>
|
||||
, typename boost::mpl::if_<luabind::detail::is_nonconst_pointer<T>
|
||||
, decorated_type_ptr_impl<T>
|
||||
, typename boost::mpl::if_<luabind::detail::is_const_pointer<T>
|
||||
, decorated_type_cptr_impl<T>
|
||||
, decorated_type_value_impl<T>
|
||||
>::type
|
||||
>::type
|
||||
>::type
|
||||
>::type
|
||||
// >::type
|
||||
{
|
||||
};
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC == 1200
|
||||
#define LUABIND_DECORATE_TYPE(t) luabind::detail::decorated_type<t>::get(luabind::detail::decorated_type<t>::data())
|
||||
#else
|
||||
// #define LUABIND_DECORATE_TYPE(t) luabind::detail::decorated_type<t>::get((void(*)(type<t>))0)
|
||||
#define LUABIND_DECORATE_TYPE(t) luabind::detail::decorated_type<t>::get(luabind::detail::decorated_type<t>::data())
|
||||
//#define LUABIND_DECORATE_TYPE(t) luabind::detail::decorated_type<t>::get(type<t>())
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
}}
|
||||
|
||||
#endif // LUABIND_DECORATE_TYPE_HPP_INCLUDED
|
||||
@@ -0,0 +1,118 @@
|
||||
// Copyright Daniel Wallin 2008. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#if !BOOST_PP_IS_ITERATING
|
||||
|
||||
# ifndef LUABIND_DEDUCE_SIGNATURE_080911_HPP
|
||||
# define LUABIND_DEDUCE_SIGNATURE_080911_HPP
|
||||
|
||||
# include <luabind/detail/most_derived.hpp>
|
||||
|
||||
# if LUABIND_MAX_ARITY <= 8
|
||||
# include <boost/mpl/vector/vector10.hpp>
|
||||
# else
|
||||
# include <boost/mpl/vector/vector50.hpp>
|
||||
# endif
|
||||
# include <boost/preprocessor/cat.hpp>
|
||||
# include <boost/preprocessor/iteration/iterate.hpp>
|
||||
# include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
namespace mpl = boost::mpl;
|
||||
|
||||
template <class R>
|
||||
mpl::vector1<R> deduce_signature(R(*)(), ...)
|
||||
{
|
||||
return mpl::vector1<R>();
|
||||
}
|
||||
|
||||
template <class R, class T>
|
||||
mpl::vector2<R,T&> deduce_signature(R(T::*)())
|
||||
{
|
||||
return mpl::vector2<R,T&>();
|
||||
}
|
||||
|
||||
template <class R, class T, class Wrapped>
|
||||
mpl::vector2<R,typename most_derived<T,Wrapped>::type&>
|
||||
deduce_signature(R(T::*)(), Wrapped*)
|
||||
{
|
||||
return mpl::vector2<R,typename most_derived<T,Wrapped>::type&>();
|
||||
}
|
||||
|
||||
template <class R, class T>
|
||||
mpl::vector2<R,T const&> deduce_signature(R(T::*)() const)
|
||||
{
|
||||
return mpl::vector2<R,T const&>();
|
||||
}
|
||||
|
||||
template <class R, class T, class Wrapped>
|
||||
mpl::vector2<R,typename most_derived<T,Wrapped>::type const&>
|
||||
deduce_signature(R(T::*)() const, Wrapped*)
|
||||
{
|
||||
return mpl::vector2<R,typename most_derived<T,Wrapped>::type const&>();
|
||||
}
|
||||
|
||||
# define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (1, LUABIND_MAX_ARITY, <luabind/detail/deduce_signature.hpp>))
|
||||
# include BOOST_PP_ITERATE()
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
# endif // LUABIND_DEDUCE_SIGNATURE_080911_HPP
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
# define N BOOST_PP_ITERATION()
|
||||
# define NPLUS1 BOOST_PP_INC(N)
|
||||
|
||||
template <class R, BOOST_PP_ENUM_PARAMS(N,class A)>
|
||||
BOOST_PP_CAT(mpl::vector,NPLUS1)<R, BOOST_PP_ENUM_PARAMS(N,A)>
|
||||
deduce_signature(R(*)(BOOST_PP_ENUM_PARAMS(N,A)), ...)
|
||||
{
|
||||
return BOOST_PP_CAT(mpl::vector,NPLUS1)<R,BOOST_PP_ENUM_PARAMS(N,A)>();
|
||||
}
|
||||
|
||||
# define NPLUS2 BOOST_PP_INC(NPLUS1)
|
||||
|
||||
template <class R, class T, BOOST_PP_ENUM_PARAMS(N,class A)>
|
||||
BOOST_PP_CAT(mpl::vector,NPLUS2)<R, T&, BOOST_PP_ENUM_PARAMS(N,A)>
|
||||
deduce_signature(R(T::*)(BOOST_PP_ENUM_PARAMS(N,A)))
|
||||
{
|
||||
return BOOST_PP_CAT(mpl::vector,NPLUS2)<R,T&,BOOST_PP_ENUM_PARAMS(N,A)>();
|
||||
}
|
||||
|
||||
template <class R, class T, BOOST_PP_ENUM_PARAMS(N,class A), class Wrapped>
|
||||
BOOST_PP_CAT(mpl::vector,NPLUS2)<
|
||||
R, typename most_derived<T,Wrapped>::type&, BOOST_PP_ENUM_PARAMS(N,A)
|
||||
>
|
||||
deduce_signature(R(T::*)(BOOST_PP_ENUM_PARAMS(N,A)), Wrapped*)
|
||||
{
|
||||
return BOOST_PP_CAT(mpl::vector,NPLUS2)<
|
||||
R,typename most_derived<T,Wrapped>::type&,BOOST_PP_ENUM_PARAMS(N,A)>();
|
||||
}
|
||||
|
||||
template <class R, class T, BOOST_PP_ENUM_PARAMS(N,class A)>
|
||||
BOOST_PP_CAT(mpl::vector,NPLUS2)<R, T const&, BOOST_PP_ENUM_PARAMS(N,A)>
|
||||
deduce_signature(R(T::*)(BOOST_PP_ENUM_PARAMS(N,A)) const)
|
||||
{
|
||||
return BOOST_PP_CAT(mpl::vector,NPLUS2)<R,T const&,BOOST_PP_ENUM_PARAMS(N,A)>();
|
||||
}
|
||||
|
||||
template <class R, class T, BOOST_PP_ENUM_PARAMS(N,class A), class Wrapped>
|
||||
BOOST_PP_CAT(mpl::vector,NPLUS2)<
|
||||
R, typename most_derived<T,Wrapped>::type const&, BOOST_PP_ENUM_PARAMS(N,A)
|
||||
>
|
||||
deduce_signature(R(T::*)(BOOST_PP_ENUM_PARAMS(N,A)) const, Wrapped*)
|
||||
{
|
||||
return BOOST_PP_CAT(mpl::vector,NPLUS2)<
|
||||
R,typename most_derived<T,Wrapped>::type const&,BOOST_PP_ENUM_PARAMS(N,A)>();
|
||||
}
|
||||
|
||||
# undef NPLUS2
|
||||
# undef NPLUS1
|
||||
# undef N
|
||||
|
||||
#endif // BOOST_PP_IS_ITERATING
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_ENUM_MAKER_HPP_INCLUDED
|
||||
#define LUABIND_ENUM_MAKER_HPP_INCLUDED
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/detail/class_rep.hpp>
|
||||
|
||||
namespace luabind
|
||||
{
|
||||
struct value;
|
||||
|
||||
struct value_vector : public std::vector<value>
|
||||
{
|
||||
// a bug in intel's compiler forces us to declare these constructors explicitly.
|
||||
value_vector();
|
||||
virtual ~value_vector();
|
||||
value_vector(const value_vector& v);
|
||||
value_vector& operator,(const value& rhs);
|
||||
};
|
||||
|
||||
struct value
|
||||
{
|
||||
friend class std::vector<value>;
|
||||
template<class T>
|
||||
value(const char* name, T v)
|
||||
: name_(name)
|
||||
, val_(v)
|
||||
{}
|
||||
|
||||
const char* name_;
|
||||
int val_;
|
||||
|
||||
value_vector operator,(const value& rhs) const
|
||||
{
|
||||
value_vector v;
|
||||
|
||||
v.push_back(*this);
|
||||
v.push_back(rhs);
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
value() {}
|
||||
};
|
||||
|
||||
inline value_vector::value_vector()
|
||||
: std::vector<value>()
|
||||
{
|
||||
}
|
||||
|
||||
inline value_vector::~value_vector() {}
|
||||
|
||||
inline value_vector::value_vector(const value_vector& rhs)
|
||||
: std::vector<value>(rhs)
|
||||
{
|
||||
}
|
||||
|
||||
inline value_vector& value_vector::operator,(const value& rhs)
|
||||
{
|
||||
push_back(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<class From>
|
||||
struct enum_maker
|
||||
{
|
||||
explicit enum_maker(From& from): from_(from) {}
|
||||
|
||||
From& operator[](const value& val)
|
||||
{
|
||||
from_.add_static_constant(val.name_, val.val_);
|
||||
return from_;
|
||||
}
|
||||
|
||||
From& operator[](const value_vector& values)
|
||||
{
|
||||
for (value_vector::const_iterator i = values.begin(); i != values.end(); ++i)
|
||||
{
|
||||
from_.add_static_constant(i->name_, i->val_);
|
||||
}
|
||||
|
||||
return from_;
|
||||
}
|
||||
|
||||
From& from_;
|
||||
|
||||
private:
|
||||
void operator=(enum_maker const&); // C4512, assignment operator could not be generated
|
||||
template<class T> void operator,(T const&) const;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#endif // LUABIND_ENUM_MAKER_HPP_INCLUDED
|
||||
@@ -0,0 +1,153 @@
|
||||
// Copyright Daniel Wallin 2008. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef LUABIND_FORMAT_SIGNATURE_081014_HPP
|
||||
# define LUABIND_FORMAT_SIGNATURE_081014_HPP
|
||||
|
||||
# include <luabind/config.hpp>
|
||||
# include <luabind/lua_include.hpp>
|
||||
# include <luabind/typeid.hpp>
|
||||
|
||||
# include <boost/mpl/begin_end.hpp>
|
||||
# include <boost/mpl/next.hpp>
|
||||
# include <boost/mpl/size.hpp>
|
||||
|
||||
namespace luabind { namespace adl {
|
||||
|
||||
class object;
|
||||
class argument;
|
||||
template <class Base>
|
||||
struct table;
|
||||
} // namespace adl
|
||||
|
||||
using adl::object;
|
||||
using adl::argument;
|
||||
using adl::table;
|
||||
|
||||
} // namespace luabind
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
LUABIND_API std::string get_class_name(lua_State* L, type_id const& i);
|
||||
|
||||
template <class T>
|
||||
struct type_to_string
|
||||
{
|
||||
static void get(lua_State* L)
|
||||
{
|
||||
lua_pushstring(L, get_class_name(L, typeid(T)).c_str());
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct type_to_string<T*>
|
||||
{
|
||||
static void get(lua_State* L)
|
||||
{
|
||||
type_to_string<T>::get(L);
|
||||
lua_pushstring(L, "*");
|
||||
lua_concat(L, 2);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct type_to_string<T&>
|
||||
{
|
||||
static void get(lua_State* L)
|
||||
{
|
||||
type_to_string<T>::get(L);
|
||||
lua_pushstring(L, "&");
|
||||
lua_concat(L, 2);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct type_to_string<T const>
|
||||
{
|
||||
static void get(lua_State* L)
|
||||
{
|
||||
type_to_string<T>::get(L);
|
||||
lua_pushstring(L, " const");
|
||||
lua_concat(L, 2);
|
||||
}
|
||||
};
|
||||
|
||||
# define LUABIND_TYPE_TO_STRING(x) \
|
||||
template <> \
|
||||
struct type_to_string<x> \
|
||||
{ \
|
||||
static void get(lua_State* L) \
|
||||
{ \
|
||||
lua_pushstring(L, #x); \
|
||||
} \
|
||||
};
|
||||
|
||||
# define LUABIND_INTEGRAL_TYPE_TO_STRING(x) \
|
||||
LUABIND_TYPE_TO_STRING(x) \
|
||||
LUABIND_TYPE_TO_STRING(unsigned x)
|
||||
|
||||
LUABIND_INTEGRAL_TYPE_TO_STRING(char)
|
||||
LUABIND_INTEGRAL_TYPE_TO_STRING(short)
|
||||
LUABIND_INTEGRAL_TYPE_TO_STRING(int)
|
||||
LUABIND_INTEGRAL_TYPE_TO_STRING(long)
|
||||
|
||||
LUABIND_TYPE_TO_STRING(void)
|
||||
LUABIND_TYPE_TO_STRING(bool)
|
||||
LUABIND_TYPE_TO_STRING(std::string)
|
||||
LUABIND_TYPE_TO_STRING(lua_State)
|
||||
|
||||
LUABIND_TYPE_TO_STRING(luabind::object)
|
||||
LUABIND_TYPE_TO_STRING(luabind::argument)
|
||||
|
||||
# undef LUABIND_INTEGRAL_TYPE_TO_STRING
|
||||
# undef LUABIND_TYPE_TO_STRING
|
||||
|
||||
template <class Base>
|
||||
struct type_to_string<table<Base> >
|
||||
{
|
||||
static void get(lua_State* L)
|
||||
{
|
||||
lua_pushstring(L, "table");
|
||||
}
|
||||
};
|
||||
|
||||
template <class End>
|
||||
void format_signature_aux(lua_State*, bool, End, End)
|
||||
{}
|
||||
|
||||
template <class Iter, class End>
|
||||
void format_signature_aux(lua_State* L, bool first, Iter, End end)
|
||||
{
|
||||
if (!first)
|
||||
lua_pushstring(L, ",");
|
||||
type_to_string<typename Iter::type>::get(L);
|
||||
format_signature_aux(L, false, typename mpl::next<Iter>::type(), end);
|
||||
}
|
||||
|
||||
template <class Signature>
|
||||
void format_signature(lua_State* L, char const* function, Signature)
|
||||
{
|
||||
typedef typename mpl::begin<Signature>::type first;
|
||||
|
||||
type_to_string<typename first::type>::get(L);
|
||||
|
||||
lua_pushstring(L, " ");
|
||||
lua_pushstring(L, function);
|
||||
|
||||
lua_pushstring(L, "(");
|
||||
format_signature_aux(
|
||||
L
|
||||
, true
|
||||
, typename mpl::next<first>::type()
|
||||
, typename mpl::end<Signature>::type()
|
||||
);
|
||||
lua_pushstring(L, ")");
|
||||
|
||||
lua_concat(L, static_cast<int>(mpl::size<Signature>()) * 2 + 2);
|
||||
}
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // LUABIND_FORMAT_SIGNATURE_081014_HPP
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_GARBAGE_COLLECTOR_HPP_INCLUDED
|
||||
#define LUABIND_GARBAGE_COLLECTOR_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
// function that is used as __gc metafunction on several objects
|
||||
template<class T>
|
||||
inline int garbage_collector(lua_State* L)
|
||||
{
|
||||
T* obj = static_cast<T*>(lua_touserdata(L, -1));
|
||||
obj->~T();
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
struct garbage_collector_s
|
||||
{
|
||||
static int apply(lua_State* L)
|
||||
{
|
||||
T* obj = static_cast<T*>(lua_touserdata(L, -1));
|
||||
obj->~T();
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#endif // LUABIND_GARBAGE_COLLECTOR_HPP_INCLUDED
|
||||
@@ -0,0 +1,107 @@
|
||||
// Copyright (c) 2005 Daniel Wallin
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef LUABIND_HAS_GET_POINTER_051022_HPP
|
||||
# define LUABIND_HAS_GET_POINTER_051022_HPP
|
||||
|
||||
# include <boost/type_traits/add_reference.hpp>
|
||||
|
||||
# ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
# include <memory>
|
||||
# endif
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
namespace has_get_pointer_
|
||||
{
|
||||
|
||||
struct any
|
||||
{
|
||||
template<class T> any(T const&);
|
||||
};
|
||||
|
||||
struct no_overload_tag
|
||||
{};
|
||||
|
||||
typedef char (&yes)[1];
|
||||
typedef char (&no)[2];
|
||||
|
||||
no_overload_tag operator,(no_overload_tag, int);
|
||||
|
||||
//
|
||||
// On compilers with ADL, we need these generic overloads in this
|
||||
// namespace as well as in luabind::. Otherwise get_pointer(any)
|
||||
// will be found before them.
|
||||
//
|
||||
# ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
|
||||
template<class T>
|
||||
T* get_pointer(T const volatile*);
|
||||
|
||||
template<class T>
|
||||
T* get_pointer(std::auto_ptr<T> const&);
|
||||
|
||||
# endif
|
||||
|
||||
//
|
||||
// On compilers that doesn't support ADL, the overload below has to
|
||||
// live in luabind::.
|
||||
//
|
||||
# ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
}} // namespace detail::has_get_pointer_
|
||||
# endif
|
||||
|
||||
detail::has_get_pointer_::no_overload_tag
|
||||
get_pointer(detail::has_get_pointer_::any);
|
||||
|
||||
# ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
namespace detail { namespace has_get_pointer_
|
||||
{
|
||||
# endif
|
||||
|
||||
template<class T>
|
||||
yes check(T const&);
|
||||
no check(no_overload_tag);
|
||||
|
||||
template<class T>
|
||||
struct impl
|
||||
{
|
||||
static typename boost::add_reference<T>::type x;
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool,
|
||||
value = sizeof(has_get_pointer_::check( (get_pointer(x),0) )) == 1
|
||||
);
|
||||
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
};
|
||||
|
||||
} // namespace has_get_pointer_
|
||||
|
||||
template<class T>
|
||||
struct has_get_pointer
|
||||
: has_get_pointer_::impl<T>::type
|
||||
{};
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // LUABIND_HAS_GET_POINTER_051022_HPP
|
||||
|
||||
@@ -0,0 +1,168 @@
|
||||
// Copyright Daniel Wallin 2009. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef LUABIND_INHERITANCE_090217_HPP
|
||||
# define LUABIND_INHERITANCE_090217_HPP
|
||||
|
||||
# include <cassert>
|
||||
# include <limits>
|
||||
# include <map>
|
||||
# include <memory>
|
||||
# include <vector>
|
||||
# include <luabind/typeid.hpp>
|
||||
# include <boost/scoped_ptr.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
typedef void*(*cast_function)(void*);
|
||||
typedef std::size_t class_id;
|
||||
|
||||
class_id const unknown_class = (std::numeric_limits<class_id>::max)();
|
||||
|
||||
class class_rep;
|
||||
|
||||
class LUABIND_API cast_graph
|
||||
{
|
||||
public:
|
||||
cast_graph();
|
||||
~cast_graph();
|
||||
|
||||
// `src` and `p` here describe the *most derived* object. This means that
|
||||
// for a polymorphic type, the pointer must be cast with
|
||||
// dynamic_cast<void*> before being passed in here, and `src` has to
|
||||
// match typeid(*p).
|
||||
std::pair<void*, int> cast(
|
||||
void* p, class_id src, class_id target
|
||||
, class_id dynamic_id, void const* dynamic_ptr) const;
|
||||
void insert(class_id src, class_id target, cast_function cast);
|
||||
|
||||
private:
|
||||
class impl;
|
||||
boost::scoped_ptr<impl> m_impl;
|
||||
};
|
||||
|
||||
// Maps a type_id to a class_id. Note that this actually partitions the
|
||||
// id-space into two, using one half for "local" ids; ids that are used only as
|
||||
// keys into the conversion cache. This is needed because we need a unique key
|
||||
// even for types that hasn't been registered explicitly.
|
||||
class LUABIND_API class_id_map
|
||||
{
|
||||
public:
|
||||
class_id_map();
|
||||
|
||||
class_id get(type_id const& type) const;
|
||||
class_id get_local(type_id const& type);
|
||||
void put(class_id id, type_id const& type);
|
||||
|
||||
private:
|
||||
typedef std::map<type_id, class_id> map_type;
|
||||
map_type m_classes;
|
||||
class_id m_local_id;
|
||||
|
||||
static class_id const local_id_base;
|
||||
};
|
||||
|
||||
inline class_id_map::class_id_map()
|
||||
: m_local_id(local_id_base)
|
||||
{}
|
||||
|
||||
inline class_id class_id_map::get(type_id const& type) const
|
||||
{
|
||||
map_type::const_iterator i = m_classes.find(type);
|
||||
if (i == m_classes.end() || i->second >= local_id_base)
|
||||
return unknown_class;
|
||||
return i->second;
|
||||
}
|
||||
|
||||
inline class_id class_id_map::get_local(type_id const& type)
|
||||
{
|
||||
std::pair<map_type::iterator, bool> result = m_classes.insert(
|
||||
std::make_pair(type, 0));
|
||||
|
||||
if (result.second)
|
||||
result.first->second = m_local_id++;
|
||||
|
||||
assert(m_local_id >= local_id_base);
|
||||
|
||||
return result.first->second;
|
||||
}
|
||||
|
||||
inline void class_id_map::put(class_id id, type_id const& type)
|
||||
{
|
||||
assert(id < local_id_base);
|
||||
|
||||
std::pair<map_type::iterator, bool> result = m_classes.insert(
|
||||
std::make_pair(type, 0));
|
||||
|
||||
assert(
|
||||
result.second
|
||||
|| result.first->second == id
|
||||
|| result.first->second >= local_id_base
|
||||
);
|
||||
|
||||
result.first->second = id;
|
||||
}
|
||||
|
||||
class class_map
|
||||
{
|
||||
public:
|
||||
class_rep* get(class_id id) const;
|
||||
void put(class_id id, class_rep* cls);
|
||||
|
||||
private:
|
||||
std::vector<class_rep*> m_classes;
|
||||
};
|
||||
|
||||
inline class_rep* class_map::get(class_id id) const
|
||||
{
|
||||
if (id >= m_classes.size())
|
||||
return 0;
|
||||
return m_classes[id];
|
||||
}
|
||||
|
||||
inline void class_map::put(class_id id, class_rep* cls)
|
||||
{
|
||||
if (id >= m_classes.size())
|
||||
m_classes.resize(id + 1);
|
||||
m_classes[id] = cls;
|
||||
}
|
||||
|
||||
template <class S, class T>
|
||||
struct static_cast_
|
||||
{
|
||||
static void* execute(void* p)
|
||||
{
|
||||
return static_cast<T*>(static_cast<S*>(p));
|
||||
}
|
||||
};
|
||||
|
||||
template <class S, class T>
|
||||
struct dynamic_cast_
|
||||
{
|
||||
static void* execute(void* p)
|
||||
{
|
||||
return dynamic_cast<T*>(static_cast<S*>(p));
|
||||
}
|
||||
};
|
||||
|
||||
// Thread safe class_id allocation.
|
||||
LUABIND_API class_id allocate_class_id(type_id const& cls);
|
||||
|
||||
template <class T>
|
||||
struct registered_class
|
||||
{
|
||||
static class_id const id;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
class_id const registered_class<T>::id = allocate_class_id(typeid(T));
|
||||
|
||||
template <class T>
|
||||
struct registered_class<T const>
|
||||
: registered_class<T>
|
||||
{};
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // LUABIND_INHERITANCE_090217_HPP
|
||||
@@ -0,0 +1,131 @@
|
||||
// Copyright Daniel Wallin 2008. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef LUABIND_INSTANCE_HOLDER_081024_HPP
|
||||
# define LUABIND_INSTANCE_HOLDER_081024_HPP
|
||||
|
||||
# include <luabind/detail/inheritance.hpp>
|
||||
# include <luabind/detail/class_rep.hpp> // TODO
|
||||
# include <luabind/get_pointer.hpp>
|
||||
# include <luabind/typeid.hpp>
|
||||
# include <boost/type_traits/is_polymorphic.hpp>
|
||||
# include <stdexcept>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
class instance_holder
|
||||
{
|
||||
public:
|
||||
instance_holder(class_rep* cls, bool pointee_const)
|
||||
: m_cls(cls)
|
||||
, m_pointee_const(pointee_const)
|
||||
{}
|
||||
|
||||
virtual ~instance_holder()
|
||||
{}
|
||||
|
||||
virtual std::pair<void*, int> get(class_id target) const = 0;
|
||||
|
||||
virtual void release() = 0;
|
||||
|
||||
class_rep* get_class() const
|
||||
{
|
||||
return m_cls;
|
||||
}
|
||||
|
||||
bool pointee_const() const
|
||||
{
|
||||
return m_pointee_const;
|
||||
}
|
||||
|
||||
private:
|
||||
class_rep* m_cls;
|
||||
bool m_pointee_const;
|
||||
};
|
||||
|
||||
namespace mpl = boost::mpl;
|
||||
|
||||
inline mpl::false_ check_const_pointer(void*)
|
||||
{
|
||||
return mpl::false_();
|
||||
}
|
||||
|
||||
inline mpl::true_ check_const_pointer(void const*)
|
||||
{
|
||||
return mpl::true_();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void release_ownership(std::auto_ptr<T>& p)
|
||||
{
|
||||
p.release();
|
||||
}
|
||||
|
||||
template <class P>
|
||||
void release_ownership(P const&)
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"luabind: smart pointer does not allow ownership transfer");
|
||||
}
|
||||
|
||||
template <class T>
|
||||
class_id static_class_id(T*)
|
||||
{
|
||||
return registered_class<T>::id;
|
||||
}
|
||||
|
||||
template <class P, class Pointee = void const>
|
||||
class pointer_holder : public instance_holder
|
||||
{
|
||||
public:
|
||||
pointer_holder(
|
||||
P p, class_id dynamic_id, void* dynamic_ptr, class_rep* cls
|
||||
)
|
||||
: instance_holder(cls, check_const_pointer(false ? get_pointer(p) : 0))
|
||||
, p(p)
|
||||
, weak(0)
|
||||
, dynamic_id(dynamic_id)
|
||||
, dynamic_ptr(dynamic_ptr)
|
||||
{}
|
||||
|
||||
std::pair<void*, int> get(class_id target) const
|
||||
{
|
||||
if (target == registered_class<P>::id)
|
||||
return std::pair<void*, int>(&this->p, 0);
|
||||
|
||||
void* naked_ptr = const_cast<void*>(static_cast<void const*>(
|
||||
weak ? weak : get_pointer(p)));
|
||||
|
||||
if (!naked_ptr)
|
||||
return std::pair<void*, int>((void*)0, 0);
|
||||
|
||||
return get_class()->casts().cast(
|
||||
naked_ptr
|
||||
, static_class_id(false ? get_pointer(p) : 0)
|
||||
, target
|
||||
, dynamic_id
|
||||
, dynamic_ptr
|
||||
);
|
||||
}
|
||||
|
||||
void release()
|
||||
{
|
||||
weak = const_cast<void*>(static_cast<void const*>(
|
||||
get_pointer(p)));
|
||||
release_ownership(p);
|
||||
}
|
||||
|
||||
private:
|
||||
mutable P p;
|
||||
// weak will hold a possibly stale pointer to the object owned
|
||||
// by p once p has released it's owership. This is a workaround
|
||||
// to make adopt() work with virtual function wrapper classes.
|
||||
void* weak;
|
||||
class_id dynamic_id;
|
||||
void* dynamic_ptr;
|
||||
};
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // LUABIND_INSTANCE_HOLDER_081024_HPP
|
||||
@@ -0,0 +1,70 @@
|
||||
// Copyright (c) 2004 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef IS_INDIRECT_CONST_040211_HPP
|
||||
#define IS_INDIRECT_CONST_040211_HPP
|
||||
|
||||
#include <luabind/detail/yes_no.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
|
||||
namespace luabind {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T>
|
||||
typename boost::is_const<T>::type
|
||||
is_indirect_const_check(T(*)(), int);
|
||||
|
||||
template<class T>
|
||||
typename boost::is_const<T>::type
|
||||
is_indirect_const_check(T*(*)(), long);
|
||||
|
||||
template<class T>
|
||||
typename boost::is_const<T>::type
|
||||
is_indirect_const_check(T&(*)(), long);
|
||||
|
||||
yes_t to_yes_no(boost::mpl::true_);
|
||||
no_t to_yes_no(boost::mpl::false_);
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// returns true for:
|
||||
// T = U* is_const<U>
|
||||
// T = U& is_const<U>
|
||||
// T = U is_const<U>
|
||||
template<class T>
|
||||
struct is_indirect_const
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(int, value = (
|
||||
sizeof(
|
||||
detail::to_yes_no(
|
||||
detail::is_indirect_const_check((T(*)())0, 0L)
|
||||
))
|
||||
== sizeof(detail::yes_t)
|
||||
));
|
||||
};
|
||||
|
||||
} // namespace luabind
|
||||
|
||||
#endif // IS_INDIRECT_CONST_040211_HPP
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef LUABIND_LINK_COMPATIBILITY_HPP_INCLUDED
|
||||
#define LUABIND_LINK_COMPATIBILITY_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
|
||||
#ifdef LUABIND_NOT_THREADSAFE
|
||||
LUABIND_API void not_threadsafe_defined_conflict();
|
||||
#else
|
||||
LUABIND_API void not_threadsafe_not_defined_conflict();
|
||||
#endif
|
||||
|
||||
#ifdef LUABIND_NO_ERROR_CHECKING
|
||||
LUABIND_API void no_error_checking_defined_conflict();
|
||||
#else
|
||||
LUABIND_API void no_error_checking_not_defined_conflict();
|
||||
#endif
|
||||
|
||||
inline void check_link_compatibility()
|
||||
{
|
||||
#ifdef LUABIND_NOT_THREADSAFE
|
||||
not_threadsafe_defined_conflict();
|
||||
#else
|
||||
not_threadsafe_not_defined_conflict();
|
||||
#endif
|
||||
|
||||
#ifdef LUABIND_NO_ERROR_CHECKING
|
||||
no_error_checking_defined_conflict();
|
||||
#else
|
||||
no_error_checking_not_defined_conflict();
|
||||
#endif
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,105 @@
|
||||
// Copyright Daniel Wallin 2009. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef LUABIND_DETAIL_MAKE_INSTANCE_090310_HPP
|
||||
# define LUABIND_DETAIL_MAKE_INSTANCE_090310_HPP
|
||||
|
||||
# include <boost/type_traits/is_polymorphic.hpp>
|
||||
# include <luabind/detail/inheritance.hpp>
|
||||
# include <luabind/detail/object_rep.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
template <class T>
|
||||
std::pair<class_id, void*> get_dynamic_class_aux(
|
||||
lua_State* L, T const* p, mpl::true_)
|
||||
{
|
||||
lua_pushliteral(L, "__luabind_class_id_map");
|
||||
lua_rawget(L, LUA_REGISTRYINDEX);
|
||||
|
||||
class_id_map& class_ids = *static_cast<class_id_map*>(
|
||||
lua_touserdata(L, -1));
|
||||
|
||||
lua_pop(L, 1);
|
||||
|
||||
return std::make_pair(
|
||||
class_ids.get_local(typeid(*p))
|
||||
, dynamic_cast<void*>(const_cast<T*>(p))
|
||||
);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
std::pair<class_id, void*> get_dynamic_class_aux(
|
||||
lua_State*, T const* p, mpl::false_)
|
||||
{
|
||||
return std::make_pair(registered_class<T>::id, (void*)p);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
std::pair<class_id, void*> get_dynamic_class(lua_State* L, T* p)
|
||||
{
|
||||
return get_dynamic_class_aux(L, p, boost::is_polymorphic<T>());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
class_rep* get_pointee_class(class_map const& classes, T*)
|
||||
{
|
||||
return classes.get(registered_class<T>::id);
|
||||
}
|
||||
|
||||
template <class P>
|
||||
class_rep* get_pointee_class(lua_State* L, P const& p, class_id dynamic_id)
|
||||
{
|
||||
lua_pushliteral(L, "__luabind_class_map");
|
||||
lua_rawget(L, LUA_REGISTRYINDEX);
|
||||
|
||||
class_map const& classes = *static_cast<class_map*>(
|
||||
lua_touserdata(L, -1));
|
||||
|
||||
lua_pop(L, 1);
|
||||
|
||||
class_rep* cls = classes.get(dynamic_id);
|
||||
|
||||
if (!cls)
|
||||
cls = get_pointee_class(classes, get_pointer(p));
|
||||
|
||||
return cls;
|
||||
}
|
||||
|
||||
// Create an appropriate instance holder for the given pointer like object.
|
||||
template <class P>
|
||||
void make_instance(lua_State* L, P p)
|
||||
{
|
||||
std::pair<class_id, void*> dynamic = get_dynamic_class(L, get_pointer(p));
|
||||
|
||||
class_rep* cls = get_pointee_class(L, p, dynamic.first);
|
||||
|
||||
if (!cls)
|
||||
{
|
||||
throw std::runtime_error("Trying to use unregistered class");
|
||||
}
|
||||
|
||||
object_rep* instance = push_new_instance(L, cls);
|
||||
|
||||
typedef pointer_holder<P> holder_type;
|
||||
|
||||
void* storage = instance->allocate(sizeof(holder_type));
|
||||
|
||||
try
|
||||
{
|
||||
new (storage) holder_type(p, dynamic.first, dynamic.second, cls);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
instance->deallocate(storage);
|
||||
lua_pop(L, 1);
|
||||
throw;
|
||||
}
|
||||
|
||||
instance->set_instance(static_cast<holder_type*>(storage));
|
||||
}
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // LUABIND_DETAIL_MAKE_INSTANCE_090310_HPP
|
||||
@@ -0,0 +1,44 @@
|
||||
// Copyright (c) 2005 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef MOST_DERIVED_051018_HPP
|
||||
# define MOST_DERIVED_051018_HPP
|
||||
|
||||
# include <boost/mpl/if.hpp>
|
||||
# include <boost/type_traits/is_base_and_derived.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
template<class Class, class WrappedClass>
|
||||
struct most_derived
|
||||
{
|
||||
typedef typename boost::mpl::if_<
|
||||
boost::is_base_and_derived<Class, WrappedClass>
|
||||
, WrappedClass
|
||||
, Class
|
||||
>::type type;
|
||||
};
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // MOST_DERIVED_051018_HPP
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
// Copyright (c) 2005 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#if !BOOST_PP_IS_ITERATING
|
||||
# error Do not include object_call.hpp directly!
|
||||
#endif
|
||||
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS(N, class A)>
|
||||
call_proxy<
|
||||
Derived
|
||||
, boost::tuples::tuple<
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(N, A, const* BOOST_PP_INTERCEPT)
|
||||
>
|
||||
> operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a))
|
||||
{
|
||||
typedef boost::tuples::tuple<
|
||||
BOOST_PP_ENUM_BINARY_PARAMS(N, A, const* BOOST_PP_INTERCEPT)
|
||||
> arguments;
|
||||
|
||||
return call_proxy<Derived, arguments>(
|
||||
derived()
|
||||
, arguments(BOOST_PP_ENUM_PARAMS(N, &a))
|
||||
);
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
@@ -0,0 +1,224 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef LUABIND_OBJECT_PROXY_HPP_INCLUDED
|
||||
#define LUABIND_OBJECT_PROXY_HPP_INCLUDED
|
||||
|
||||
#include <boost/optional.hpp>
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/detail/policy.hpp>
|
||||
#include <luabind/error.hpp>
|
||||
#include <luabind/detail/convert_to_lua.hpp>
|
||||
#include <luabind/detail/debug.hpp>
|
||||
#include <luabind/detail/stack_utils.hpp>
|
||||
|
||||
#include <boost/mpl/apply_wrap.hpp>
|
||||
|
||||
namespace luabind
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
namespace mpl = boost::mpl;
|
||||
|
||||
template<class T, class Obj, class Policies>
|
||||
inline T object_cast_impl(const Obj& obj, const Policies&)
|
||||
{
|
||||
if (obj.lua_state() == 0)
|
||||
{
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw cast_failed(0, typeid(T));
|
||||
#else
|
||||
lua_State* L = obj.lua_state();
|
||||
cast_failed_callback_fun e = get_cast_failed_callback();
|
||||
if (e) e(L, typeid(T));
|
||||
|
||||
assert(0 && "object_cast failed. If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
|
||||
LUABIND_CHECK_STACK(obj.lua_state());
|
||||
|
||||
typedef typename detail::find_conversion_policy<0, Policies>::type converter_policy;
|
||||
typename mpl::apply_wrap2<converter_policy,T,lua_to_cpp>::type converter;
|
||||
|
||||
obj.pushvalue();
|
||||
|
||||
lua_State* L = obj.lua_state();
|
||||
detail::stack_pop p(L, 1);
|
||||
|
||||
#ifndef LUABIND_NO_ERROR_CHECKING
|
||||
|
||||
if (converter.match(L, LUABIND_DECORATE_TYPE(T), -1) < 0)
|
||||
{
|
||||
#ifndef LUABIND_NO_EXCEPTIONS
|
||||
throw cast_failed(L, typeid(T));
|
||||
#else
|
||||
cast_failed_callback_fun e = get_cast_failed_callback();
|
||||
if (e) e(L, typeid(T));
|
||||
|
||||
assert(0 && "object_cast failed. If you want to handle this error use luabind::set_error_callback()");
|
||||
std::terminate();
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
return converter.apply(L, LUABIND_DECORATE_TYPE(T), -1);
|
||||
}
|
||||
|
||||
template<class T, class Obj, class Policies>
|
||||
boost::optional<T> object_cast_nothrow_impl(const Obj& obj, const Policies&)
|
||||
{
|
||||
typedef typename detail::find_conversion_policy<0, Policies>::type converter_policy;
|
||||
typename mpl::apply_wrap2<converter_policy,T,lua_to_cpp>::type converter;
|
||||
|
||||
if (obj.lua_state() == 0) return boost::optional<T>();
|
||||
LUABIND_CHECK_STACK(obj.lua_state());
|
||||
|
||||
obj.pushvalue();
|
||||
|
||||
lua_State* L = obj.lua_state();
|
||||
detail::stack_pop p(L, 1);
|
||||
|
||||
#ifndef LUABIND_NO_ERROR_CHECKING
|
||||
|
||||
if (converter.match(L, LUABIND_DECORATE_TYPE(T), -1) < 0)
|
||||
return boost::optional<T>();
|
||||
#endif
|
||||
|
||||
return boost::optional<T>(converter.apply(L, LUABIND_DECORATE_TYPE(T), -1));
|
||||
}
|
||||
}
|
||||
|
||||
template<class T>
|
||||
T object_cast(const object& obj)
|
||||
{ return detail::object_cast_impl<T>(obj, detail::null_type()); }
|
||||
|
||||
template<class T, class Policies>
|
||||
T object_cast(const object& obj, const Policies& p)
|
||||
{ return detail::object_cast_impl<T>(obj, p); }
|
||||
|
||||
template<class T>
|
||||
boost::optional<T> object_cast_nothrow(const object& obj)
|
||||
{ return detail::object_cast_nothrow_impl<T>(obj, detail::null_type()); }
|
||||
|
||||
template<class T, class Policies>
|
||||
boost::optional<T> object_cast_nothrow(const object& obj, const Policies& p)
|
||||
{ return detail::object_cast_nothrow_impl<T>(obj, p); }
|
||||
|
||||
|
||||
template<class T>
|
||||
T object_cast(const detail::proxy_object& obj)
|
||||
{ return detail::object_cast_impl<T>(obj, detail::null_type()); }
|
||||
|
||||
template<class T, class Policies>
|
||||
T object_cast(const detail::proxy_object& obj, const Policies& p)
|
||||
{ return detail::object_cast_impl<T>(obj, p); }
|
||||
|
||||
template<class T>
|
||||
boost::optional<T> object_cast_nothrow(const detail::proxy_object& obj)
|
||||
{ return detail::object_cast_nothrow_impl<T>(obj, detail::null_type()); }
|
||||
|
||||
template<class T, class Policies>
|
||||
boost::optional<T> object_cast_nothrow(const detail::proxy_object& obj, const Policies& p)
|
||||
{ return detail::object_cast_nothrow_impl<T>(obj, p); }
|
||||
|
||||
|
||||
template<class T>
|
||||
T object_cast(const detail::proxy_raw_object& obj)
|
||||
{ return detail::object_cast_impl<T>(obj, detail::null_type()); }
|
||||
|
||||
template<class T, class Policies>
|
||||
T object_cast(const detail::proxy_raw_object& obj, const Policies& p)
|
||||
{ return detail::object_cast_impl<T>(obj, p); }
|
||||
|
||||
template<class T>
|
||||
boost::optional<T> object_cast_nothrow(const detail::proxy_raw_object& obj)
|
||||
{ return detail::object_cast_nothrow_impl<T>(obj, detail::null_type()); }
|
||||
|
||||
template<class T, class Policies>
|
||||
boost::optional<T> object_cast_nothrow(const detail::proxy_raw_object& obj, const Policies& p)
|
||||
{ return detail::object_cast_nothrow_impl<T>(obj, p); }
|
||||
|
||||
|
||||
template<class T>
|
||||
T object_cast(const detail::proxy_array_object& obj)
|
||||
{ return detail::object_cast_impl<T>(obj, detail::null_type()); }
|
||||
|
||||
template<class T, class Policies>
|
||||
T object_cast(const detail::proxy_array_object& obj, const Policies& p)
|
||||
{ return detail::object_cast_impl<T>(obj, p); }
|
||||
|
||||
template<class T>
|
||||
boost::optional<T> object_cast_nothrow(const detail::proxy_array_object& obj)
|
||||
{ return detail::object_cast_nothrow_impl<T>(obj, detail::null_type()); }
|
||||
|
||||
template<class T, class Policies>
|
||||
boost::optional<T> object_cast_nothrow(const detail::proxy_array_object& obj, const Policies& p)
|
||||
{ return detail::object_cast_nothrow_impl<T>(obj, p); }
|
||||
|
||||
|
||||
|
||||
|
||||
inline object get_globals(lua_State* L)
|
||||
{
|
||||
lua_pushvalue(L, LUA_GLOBALSINDEX);
|
||||
detail::lua_reference ref;
|
||||
ref.set(L);
|
||||
return object(L, ref, true/*object::reference()*/);
|
||||
}
|
||||
|
||||
inline object get_registry(lua_State* L)
|
||||
{
|
||||
lua_pushvalue(L, LUA_REGISTRYINDEX);
|
||||
detail::lua_reference ref;
|
||||
ref.set(L);
|
||||
return object(L, ref, true/*object::reference()*/);
|
||||
}
|
||||
|
||||
inline object newtable(lua_State* L)
|
||||
{
|
||||
lua_newtable(L);
|
||||
detail::lua_reference ref;
|
||||
ref.set(L);
|
||||
return object(L, ref, true/*object::reference()*/);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
struct A
|
||||
{
|
||||
};
|
||||
|
||||
object f = class_<A>();
|
||||
|
||||
A* ptr = object_cast<A*>(f(), adopt(_1));
|
||||
|
||||
delete ptr;
|
||||
|
||||
*/
|
||||
|
||||
#endif // LUABIND_OBJECT_PROXY_HPP_INCLUDED
|
||||
@@ -0,0 +1,133 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_OBJECT_REP_HPP_INCLUDED
|
||||
#define LUABIND_OBJECT_REP_HPP_INCLUDED
|
||||
|
||||
#include <boost/aligned_storage.hpp>
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/detail/instance_holder.hpp>
|
||||
#include <luabind/detail/ref.hpp>
|
||||
#include <cstdlib>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
class class_rep;
|
||||
|
||||
void finalize(lua_State* L, class_rep* crep);
|
||||
|
||||
// this class is allocated inside lua for each pointer.
|
||||
// it contains the actual c++ object-pointer.
|
||||
// it also tells if it is const or not.
|
||||
class LUABIND_API object_rep
|
||||
{
|
||||
public:
|
||||
object_rep(instance_holder* instance, class_rep* crep);
|
||||
~object_rep();
|
||||
|
||||
const class_rep* crep() const { return m_classrep; }
|
||||
class_rep* crep() { return m_classrep; }
|
||||
|
||||
void set_instance(instance_holder* instance) { m_instance = instance; }
|
||||
|
||||
void add_dependency(lua_State* L, int index);
|
||||
void release_dependency_refs(lua_State* L);
|
||||
|
||||
std::pair<void*, int> get_instance(class_id target) const
|
||||
{
|
||||
if (m_instance == 0)
|
||||
return std::pair<void*, int>((void*)0, -1);
|
||||
return m_instance->get(target);
|
||||
}
|
||||
|
||||
bool is_const() const
|
||||
{
|
||||
return m_instance && m_instance->pointee_const();
|
||||
}
|
||||
|
||||
void release()
|
||||
{
|
||||
if (m_instance)
|
||||
m_instance->release();
|
||||
}
|
||||
|
||||
void* allocate(std::size_t size)
|
||||
{
|
||||
if (size <= 32)
|
||||
return &m_instance_buffer;
|
||||
return std::malloc(size);
|
||||
}
|
||||
|
||||
void deallocate(void* storage)
|
||||
{
|
||||
if (storage == &m_instance_buffer)
|
||||
return;
|
||||
std::free(storage);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
object_rep(object_rep const&)
|
||||
{}
|
||||
|
||||
void operator=(object_rep const&)
|
||||
{}
|
||||
|
||||
instance_holder* m_instance;
|
||||
boost::aligned_storage<32> m_instance_buffer;
|
||||
class_rep* m_classrep; // the class information about this object's type
|
||||
std::size_t m_dependency_cnt; // counts dependencies
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct delete_s
|
||||
{
|
||||
static void apply(void* ptr)
|
||||
{
|
||||
delete static_cast<T*>(ptr);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct destruct_only_s
|
||||
{
|
||||
static void apply(void* ptr)
|
||||
{
|
||||
// Removes unreferenced formal parameter warning on VC7.
|
||||
(void)ptr;
|
||||
#ifndef NDEBUG
|
||||
int completeness_check[sizeof(T)];
|
||||
(void)completeness_check;
|
||||
#endif
|
||||
static_cast<T*>(ptr)->~T();
|
||||
}
|
||||
};
|
||||
|
||||
LUABIND_API object_rep* get_instance(lua_State* L, int index);
|
||||
LUABIND_API void push_instance_metatable(lua_State* L);
|
||||
LUABIND_API object_rep* push_new_instance(lua_State* L, class_rep* cls);
|
||||
|
||||
}}
|
||||
|
||||
#endif // LUABIND_OBJECT_REP_HPP_INCLUDED
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_OPEN_HPP_INCLUDED
|
||||
#define LUABIND_OPEN_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
|
||||
namespace luabind
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
LUABIND_API void add_operator_to_metatable(lua_State* L, int op_index);
|
||||
LUABIND_API int create_cpp_class_metatable(lua_State* L);
|
||||
LUABIND_API int create_cpp_instance_metatable(lua_State* L);
|
||||
LUABIND_API int create_lua_class_metatable(lua_State* L);
|
||||
LUABIND_API int create_lua_instance_metatable(lua_State* L);
|
||||
LUABIND_API int create_lua_function_metatable(lua_State* L);
|
||||
}
|
||||
|
||||
LUABIND_API void open(lua_State* L);
|
||||
}
|
||||
|
||||
#endif // LUABIND_OPEN_HPP_INCLUDED
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_OPERATOR_ID_HPP_INCLUDED
|
||||
#define LUABIND_OPERATOR_ID_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
enum operator_id
|
||||
{
|
||||
op_add = 0,
|
||||
op_sub,
|
||||
op_mul,
|
||||
op_div,
|
||||
op_pow,
|
||||
op_lt,
|
||||
op_le,
|
||||
op_eq,
|
||||
op_call,
|
||||
op_unm,
|
||||
op_tostring,
|
||||
op_concat,
|
||||
op_len,
|
||||
|
||||
number_of_operators
|
||||
};
|
||||
|
||||
inline const char* get_operator_name(int i)
|
||||
{
|
||||
static const char* a[number_of_operators] = {
|
||||
"__add", "__sub", "__mul", "__div", "__pow",
|
||||
"__lt", "__le", "__eq", "__call", "__unm",
|
||||
"__tostring", "__concat", "__len" };
|
||||
return a[i];
|
||||
}
|
||||
|
||||
inline const char* get_operator_symbol(int i)
|
||||
{
|
||||
static const char* a[number_of_operators] = {
|
||||
"+", "-", "*", "/", "^", "<",
|
||||
"<=", "==", "()", "- (unary)",
|
||||
"tostring", "..", "#" };
|
||||
return a[i];
|
||||
}
|
||||
|
||||
inline bool is_unary(int i)
|
||||
{
|
||||
// the reason why unary minus is not considered a unary operator here is
|
||||
// that it always is given two parameters, where the second parameter always
|
||||
// is nil.
|
||||
return i == op_tostring;
|
||||
}
|
||||
|
||||
|
||||
}}
|
||||
|
||||
#endif // LUABIND_OPERATOR_ID_HPP_INCLUDED
|
||||
@@ -0,0 +1,119 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_OTHER_HPP_INCLUDED
|
||||
#define LUABIND_OTHER_HPP_INCLUDED
|
||||
|
||||
// header derived from source code found in Boost.Python
|
||||
|
||||
// Copyright David Abrahams 2002. Permission to copy, use,
|
||||
// modify, sell and distribute this software is granted provided this
|
||||
// copyright notice appears in all copies. This software is provided
|
||||
// "as is" without express or implied warranty, and with no claim as
|
||||
// to its suitability for any purpose.
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <boost/config.hpp>
|
||||
|
||||
namespace luabind
|
||||
{
|
||||
template<class T>
|
||||
struct other
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
template<typename T>
|
||||
class unwrap_other
|
||||
{
|
||||
public:
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class unwrap_other<other<T> >
|
||||
{
|
||||
public:
|
||||
typedef T type;
|
||||
};
|
||||
}} // namespace luabind::detail
|
||||
|
||||
# else // no partial specialization
|
||||
|
||||
#include <boost/type.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
typedef char (&yes_other_t)[1];
|
||||
typedef char (&no_other_t)[2];
|
||||
|
||||
no_other_t is_other_test(...);
|
||||
|
||||
template<typename T>
|
||||
yes_other_t is_other_test(type_< other<T> >);
|
||||
|
||||
template<bool wrapped>
|
||||
struct other_unwrapper
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct other_unwrapper<true>
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
typedef typename T::type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class is_other
|
||||
{
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = (
|
||||
sizeof(detail::is_other_test(type_<T>()))
|
||||
== sizeof(detail::yes_other_t)));
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class unwrap_other
|
||||
: public detail::other_unwrapper<
|
||||
is_other<T>::value
|
||||
>::template apply<T>
|
||||
{};
|
||||
|
||||
}} // namespace luabind::detail
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
#endif // LUABIND_OTHER_HPP_INCLUDED
|
||||
@@ -0,0 +1,36 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef LUABIND_PCALL_HPP_INCLUDED
|
||||
#define LUABIND_PCALL_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
|
||||
struct lua_State;
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
LUABIND_API int pcall(lua_State *L, int nargs, int nresults);
|
||||
LUABIND_API int resume_impl(lua_State *L, int nargs, int nresults);
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,54 @@
|
||||
// Copyright (c) 2004 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef POINTEE_SIZEOF_040211_HPP
|
||||
#define POINTEE_SIZEOF_040211_HPP
|
||||
|
||||
#include <boost/mpl/int.hpp>
|
||||
|
||||
namespace luabind {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T> T& deref_type(T(*)(), int);
|
||||
template<class T> T& deref_type(T*(*)(), long);
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// returns the indirect sizeof U, as in
|
||||
// sizeof(T*) = sizeof(T)
|
||||
// sizeof(T&) = sizeof(T)
|
||||
// sizeof(T) = sizeof(T)
|
||||
template<class T>
|
||||
struct pointee_sizeof
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(int, value = (
|
||||
sizeof(detail::deref_type((T(*)())0), 0L)
|
||||
));
|
||||
|
||||
typedef boost::mpl::int_<value> type;
|
||||
};
|
||||
|
||||
} // namespace luabind
|
||||
|
||||
#endif // POINTEE_SIZEOF_040211_HPP
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
// Copyright (c) 2004 Daniel Wallin
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef POINTEE_TYPEID_040211_HPP
|
||||
#define POINTEE_TYPEID_040211_HPP
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/typeid.hpp>
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
template<class T>
|
||||
type_id pointee_typeid(T*)
|
||||
{
|
||||
return typeid(T);
|
||||
}
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // POINTEE_TYPEID_040211_HPP
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,85 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_PRIMITIVES_HPP_INCLUDED
|
||||
#define LUABIND_PRIMITIVES_HPP_INCLUDED
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/detail/yes_no.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
template<class T>
|
||||
struct identity
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct type_ {};
|
||||
|
||||
struct null_type {};
|
||||
|
||||
/* typedef char yes_t;
|
||||
typedef double no_t;*/
|
||||
|
||||
struct lua_to_cpp {};
|
||||
struct cpp_to_lua {};
|
||||
|
||||
template<class T> struct by_value {};
|
||||
template<class T> struct by_reference {};
|
||||
template<class T> struct by_const_reference {};
|
||||
template<class T> struct by_pointer {};
|
||||
template<class T> struct by_const_pointer {};
|
||||
|
||||
struct converter_policy_tag {};
|
||||
|
||||
struct ltstr
|
||||
{
|
||||
bool operator()(const char* s1, const char* s2) const { return std::strcmp(s1, s2) < 0; }
|
||||
};
|
||||
|
||||
template<int N>
|
||||
struct aligned
|
||||
{
|
||||
char storage[N];
|
||||
};
|
||||
|
||||
// returns the offset added to a Derived* when cast to a Base*
|
||||
// TODO: return ptrdiff
|
||||
template<class Derived, class Base>
|
||||
int ptr_offset(type_<Derived>, type_<Base>)
|
||||
{
|
||||
aligned<sizeof(Derived)> obj;
|
||||
Derived* ptr = reinterpret_cast<Derived*>(&obj);
|
||||
|
||||
return int(static_cast<char*>(static_cast<void*>(static_cast<Base*>(ptr)))
|
||||
- static_cast<char*>(static_cast<void*>(ptr)));
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif // LUABIND_PRIMITIVES_HPP_INCLUDED
|
||||
@@ -0,0 +1,33 @@
|
||||
// Copyright Daniel Wallin 2008. Use, modification and distribution is
|
||||
// subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef LUABIND_PROPERTY_081020_HPP
|
||||
# define LUABIND_PROPERTY_081020_HPP
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
template <class Class, class T, class Result = T>
|
||||
struct access_member_ptr
|
||||
{
|
||||
access_member_ptr(T Class::* mem_ptr)
|
||||
: mem_ptr(mem_ptr)
|
||||
{}
|
||||
|
||||
Result operator()(Class const& x) const
|
||||
{
|
||||
return const_cast<Class&>(x).*mem_ptr;
|
||||
}
|
||||
|
||||
void operator()(Class& x, T const& value) const
|
||||
{
|
||||
x.*mem_ptr = value;
|
||||
}
|
||||
|
||||
T Class::* mem_ptr;
|
||||
};
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // LUABIND_PROPERTY_081020_HPP
|
||||
|
||||
@@ -0,0 +1,112 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_REF_HPP_INCLUDED
|
||||
#define LUABIND_REF_HPP_INCLUDED
|
||||
|
||||
#include <cassert>
|
||||
#include <algorithm>
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <luabind/lua_include.hpp>
|
||||
|
||||
namespace luabind
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
struct lua_reference
|
||||
{
|
||||
lua_reference(lua_State* L_ = 0)
|
||||
: L(L_)
|
||||
, m_ref(LUA_NOREF)
|
||||
{}
|
||||
lua_reference(lua_reference const& r)
|
||||
: L(r.L)
|
||||
, m_ref(LUA_NOREF)
|
||||
{
|
||||
if (!r.is_valid()) return;
|
||||
r.get(L);
|
||||
set(L);
|
||||
}
|
||||
~lua_reference() { reset(); }
|
||||
|
||||
lua_State* state() const { return L; }
|
||||
|
||||
void operator=(lua_reference const& r)
|
||||
{
|
||||
// TODO: self assignment problems
|
||||
reset();
|
||||
if (!r.is_valid()) return;
|
||||
r.get(r.state());
|
||||
set(r.state());
|
||||
}
|
||||
|
||||
bool is_valid() const
|
||||
{ return m_ref != LUA_NOREF; }
|
||||
|
||||
void set(lua_State* L_)
|
||||
{
|
||||
reset();
|
||||
L = L_;
|
||||
m_ref = luaL_ref(L, LUA_REGISTRYINDEX);
|
||||
}
|
||||
|
||||
void replace(lua_State* L_)
|
||||
{
|
||||
lua_rawseti(L_, LUA_REGISTRYINDEX, m_ref);
|
||||
}
|
||||
|
||||
// L may not be the same pointer as
|
||||
// was used when creating this reference
|
||||
// since it may be a thread that shares
|
||||
// the same globals table.
|
||||
void get(lua_State* L_) const
|
||||
{
|
||||
assert(m_ref != LUA_NOREF);
|
||||
assert(L_);
|
||||
lua_rawgeti(L_, LUA_REGISTRYINDEX, m_ref);
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
if (L && m_ref != LUA_NOREF) luaL_unref(L, LUA_REGISTRYINDEX, m_ref);
|
||||
m_ref = LUA_NOREF;
|
||||
}
|
||||
|
||||
void swap(lua_reference& r)
|
||||
{
|
||||
assert(r.L == L);
|
||||
std::swap(r.m_ref, m_ref);
|
||||
}
|
||||
|
||||
private:
|
||||
lua_State* L;
|
||||
int m_ref;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#endif // LUABIND_REF_HPP_INCLUDED
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef LUABIND_SIGNATURE_MATCH_HPP_INCLUDED
|
||||
#define LUABIND_SIGNATURE_MATCH_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
|
||||
#include <boost/mpl/vector.hpp>
|
||||
#include <boost/mpl/size.hpp>
|
||||
#include <boost/mpl/remove.hpp>
|
||||
|
||||
namespace luabind
|
||||
{
|
||||
|
||||
namespace adl
|
||||
{
|
||||
class argument;
|
||||
}
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(LUABIND_MAX_ARITY, class A, detail::null_type)>
|
||||
struct constructor
|
||||
{
|
||||
typedef BOOST_PP_CAT(
|
||||
boost::mpl::vector, BOOST_PP_INC(BOOST_PP_INC(LUABIND_MAX_ARITY)))<
|
||||
void, argument const&, BOOST_PP_ENUM_PARAMS(LUABIND_MAX_ARITY, A)
|
||||
> signature0;
|
||||
|
||||
typedef typename boost::mpl::remove<
|
||||
signature0, detail::null_type>::type signature;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // LUABIND_SIGNATURE_MATCH_HPP_INCLUDED
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef LUABIND_STACK_UTILS_HPP_INCLUDED
|
||||
#define LUABIND_STACK_UTILS_HPP_INCLUDED
|
||||
|
||||
#include <cassert>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
|
||||
struct stack_pop
|
||||
{
|
||||
stack_pop(lua_State* L, int n)
|
||||
: m_state(L)
|
||||
, m_n(n)
|
||||
{
|
||||
}
|
||||
|
||||
~stack_pop()
|
||||
{
|
||||
lua_pop(m_state, m_n);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
lua_State* m_state;
|
||||
int m_n;
|
||||
};
|
||||
}}
|
||||
|
||||
#endif // LUABIND_STACK_UTILS_HPP_INCLUDED
|
||||
|
||||
@@ -0,0 +1,190 @@
|
||||
// Copyright (c) 2003 Daniel Wallin and Arvid Norberg
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
#ifndef LUABIND_TYPETRAITS_HPP_INCLUDED
|
||||
#define LUABIND_TYPETRAITS_HPP_INCLUDED
|
||||
|
||||
#include <luabind/config.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/type_traits/is_reference.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <luabind/detail/primitives.hpp>
|
||||
|
||||
namespace luabind { namespace detail
|
||||
{
|
||||
|
||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
template<class T>
|
||||
struct is_const_type
|
||||
{
|
||||
typedef typename boost::mpl::if_<boost::is_const<T>
|
||||
, yes_t
|
||||
, no_t
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template<bool is_Reference = false>
|
||||
struct is_const_reference_helper
|
||||
{
|
||||
template<class>
|
||||
struct apply
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = false
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
template<class T>
|
||||
typename is_const_type<T>::type is_const_reference_tester(T&);
|
||||
no_t is_const_reference_tester(...);
|
||||
|
||||
template<>
|
||||
struct is_const_reference_helper<true>
|
||||
{
|
||||
template<class T>
|
||||
struct apply
|
||||
{
|
||||
static T getT();
|
||||
|
||||
enum
|
||||
{
|
||||
value = sizeof(is_const_reference_tester(getT())) == sizeof(yes_t)
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct is_const_reference
|
||||
: is_const_reference_helper<boost::is_reference<T>::value>::template apply<T>
|
||||
{
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
template<class T>
|
||||
struct is_const_reference
|
||||
{
|
||||
enum { value = false };
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct is_const_reference<const T&>
|
||||
{
|
||||
enum { value = true };
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
template<class T>
|
||||
struct is_nonconst_reference
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = boost::is_reference<T>::value && !is_const_reference<T>::value
|
||||
};
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
};
|
||||
|
||||
template<class A>
|
||||
yes_t is_const_pointer_helper(void(*)(const A*));
|
||||
no_t is_const_pointer_helper(...);
|
||||
|
||||
template<class T>
|
||||
struct is_const_pointer
|
||||
{
|
||||
enum { value = sizeof(is_const_pointer_helper((void(*)(T))0)) == sizeof(yes_t) };
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
};
|
||||
|
||||
template<class A>
|
||||
yes_t is_nonconst_pointer_helper(void(*)(A*));
|
||||
no_t is_nonconst_pointer_helper(...);
|
||||
|
||||
template<class T>
|
||||
struct is_nonconst_pointer
|
||||
{
|
||||
enum { value = sizeof(is_nonconst_pointer_helper((void(*)(T))0)) == sizeof(yes_t) && !is_const_pointer<T>::value };
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
};
|
||||
/*
|
||||
template<class T>
|
||||
struct is_constructable_from_helper
|
||||
{
|
||||
static yes_t check(const T&);
|
||||
static no_t check(...);
|
||||
};
|
||||
|
||||
template<class T, class From>
|
||||
struct is_constructable_from
|
||||
{
|
||||
static From getFrom();
|
||||
|
||||
enum
|
||||
{
|
||||
value = sizeof(is_constructable_from_helper<T>::check(getFrom())) == sizeof(yes_t)
|
||||
};
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct is_const_member_function_helper
|
||||
{
|
||||
static no_t test(...);
|
||||
template<class R>
|
||||
static yes_t test(R(T::*)() const);
|
||||
template<class R, class A1>
|
||||
static yes_t test(R(T::*)(A1) const);
|
||||
template<class R, class A1, class A2>
|
||||
static yes_t test(R(T::*)(A1,A2) const);
|
||||
template<class R, class A1, class A2, class A3>
|
||||
static yes_t test(R(T::*)(A1,A2,A3) const);
|
||||
};
|
||||
|
||||
template<class T, class U>
|
||||
struct is_const_member_function
|
||||
{
|
||||
static U getU();
|
||||
|
||||
enum
|
||||
{
|
||||
value = sizeof(is_const_member_function_helper<T>::test(getU())) == sizeof(yes_t)
|
||||
};
|
||||
};
|
||||
*/
|
||||
|
||||
template<int v1, int v2>
|
||||
struct max_c
|
||||
{
|
||||
enum { value = (v1>v2)?v1:v2 };
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#endif // LUABIND_TYPETRAITS_HPP_INCLUDED
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
// Copyright (c) 2004 Daniel Wallin
|
||||
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the "Software"),
|
||||
// to deal in the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
|
||||
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
// OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
#ifndef YES_NO_040211_HPP
|
||||
#define YES_NO_040211_HPP
|
||||
|
||||
namespace luabind { namespace detail {
|
||||
|
||||
typedef char(&yes_t)[1];
|
||||
typedef char(&no_t)[2];
|
||||
|
||||
}} // namespace luabind::detail
|
||||
|
||||
#endif // YES_NO_040211_HPP
|
||||
|
||||
Reference in New Issue
Block a user