152 lines
4.7 KiB
C++
152 lines
4.7 KiB
C++
// This file is distributed under the BSD License.
|
|
// See "license.txt" for details.
|
|
// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
|
|
// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
|
|
// http://www.chaiscript.com
|
|
|
|
#ifndef CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
|
|
#define CHAISCRIPT_PROXY_FUNCTIONS_DETAIL_HPP_
|
|
|
|
#include <functional>
|
|
#include <stdexcept>
|
|
#include <vector>
|
|
#include <array>
|
|
|
|
#include "../chaiscript_defines.hpp"
|
|
#include "boxed_cast.hpp"
|
|
#include "boxed_value.hpp"
|
|
#include "handle_return.hpp"
|
|
#include "type_info.hpp"
|
|
#include "callable_traits.hpp"
|
|
|
|
namespace chaiscript {
|
|
class Type_Conversions_State;
|
|
namespace exception {
|
|
class bad_boxed_cast;
|
|
} // namespace exception
|
|
} // namespace chaiscript
|
|
|
|
namespace chaiscript
|
|
{
|
|
namespace exception
|
|
{
|
|
/**
|
|
* Exception thrown when there is a mismatch in number of
|
|
* parameters during Proxy_Function execution
|
|
*/
|
|
struct arity_error : std::range_error
|
|
{
|
|
arity_error(int t_got, int t_expected)
|
|
: std::range_error("Function dispatch arity mismatch"),
|
|
got(t_got), expected(t_expected)
|
|
{
|
|
}
|
|
|
|
arity_error(const arity_error &) = default;
|
|
|
|
virtual ~arity_error() noexcept {}
|
|
|
|
int got;
|
|
int expected;
|
|
};
|
|
}
|
|
|
|
namespace dispatch
|
|
{
|
|
namespace detail
|
|
{
|
|
/**
|
|
* Used by Proxy_Function_Impl to return a list of all param types
|
|
* it contains.
|
|
*/
|
|
template<typename Ret, typename ... Params>
|
|
std::vector<Type_Info> build_param_type_list(Ret (*)(Params...))
|
|
{
|
|
/// \note somehow this is responsible for a large part of the code generation
|
|
return { user_type<Ret>(), user_type<Params>()... };
|
|
}
|
|
|
|
|
|
/**
|
|
* Used by Proxy_Function_Impl to determine if it is equivalent to another
|
|
* Proxy_Function_Impl object. This function is primarily used to prevent
|
|
* registration of two functions with the exact same signatures
|
|
*/
|
|
template<typename Ret, typename ... Params>
|
|
bool compare_types_cast(Ret (*)(Params...),
|
|
const std::vector<Boxed_Value> ¶ms, const Type_Conversions_State &t_conversions)
|
|
{
|
|
try {
|
|
std::vector<Boxed_Value>::size_type i = 0;
|
|
(void)i;
|
|
(void)params; (void)t_conversions;
|
|
// this is ok because the order of evaluation of initializer lists is well defined
|
|
(void)std::initializer_list<int>{(boxed_cast<Params>(params[i++], &t_conversions), 0)...};
|
|
return true;
|
|
} catch (const exception::bad_boxed_cast &) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
template<typename Callable, typename Ret, typename ... Params, size_t ... I>
|
|
Ret call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &,
|
|
std::index_sequence<I...>, const Callable &f,
|
|
const std::vector<Boxed_Value> ¶ms, const Type_Conversions_State &t_conversions)
|
|
{
|
|
(void)params; (void)t_conversions;
|
|
return f(boxed_cast<Params>(params[I], &t_conversions)...);
|
|
}
|
|
|
|
|
|
/**
|
|
* Used by Proxy_Function_Impl to perform typesafe execution of a function.
|
|
* The function attempts to unbox each parameter to the expected type.
|
|
* if any unboxing fails the execution of the function fails and
|
|
* the bad_boxed_cast is passed up to the caller.
|
|
*/
|
|
template<typename Callable, typename Ret, typename ... Params>
|
|
Ret call_func(const chaiscript::dispatch::detail::Function_Signature<Ret (Params...)> &sig, const Callable &f,
|
|
const std::vector<Boxed_Value> ¶ms, const Type_Conversions_State &t_conversions)
|
|
{
|
|
return call_func(sig, std::index_sequence_for<Params...>{}, f, params, t_conversions);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
namespace chaiscript
|
|
{
|
|
namespace dispatch
|
|
{
|
|
namespace detail
|
|
{
|
|
template<typename Ret>
|
|
struct Do_Call
|
|
{
|
|
template<typename Signature, typename Callable>
|
|
static Boxed_Value go(const Callable &fun, const std::vector<Boxed_Value> ¶ms, const Type_Conversions_State &t_conversions)
|
|
{
|
|
return Handle_Return<Ret>::handle(call_func(Function_Signature<Signature>(), fun, params, t_conversions));
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct Do_Call<void>
|
|
{
|
|
template<typename Signature, typename Callable>
|
|
static Boxed_Value go(const Callable &fun, const std::vector<Boxed_Value> ¶ms, const Type_Conversions_State &t_conversions)
|
|
{
|
|
call_func(Function_Signature<Signature>(), fun, params, t_conversions);
|
|
return Handle_Return<void>::handle();
|
|
}
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|