mirror of
https://github.com/godotengine/godot.git
synced 2024-12-03 09:52:18 +08:00
d76806d322
ptrcall is now also used to optimize calls in GDScript, on top of the existing use by the GDNative and Mono modules. It no longer makes sense to make it optional.
667 lines
25 KiB
C++
667 lines
25 KiB
C++
/*************************************************************************/
|
|
/* binder_common.h */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* 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 BINDER_COMMON_H
|
|
#define BINDER_COMMON_H
|
|
|
|
#include "core/object/object.h"
|
|
#include "core/templates/list.h"
|
|
#include "core/templates/simple_type.h"
|
|
#include "core/typedefs.h"
|
|
#include "core/variant/method_ptrcall.h"
|
|
#include "core/variant/type_info.h"
|
|
#include "core/variant/variant.h"
|
|
#include "core/variant/variant_internal.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
template <class T>
|
|
struct VariantCaster {
|
|
static _FORCE_INLINE_ T cast(const Variant &p_variant) {
|
|
return p_variant;
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct VariantCaster<T &> {
|
|
static _FORCE_INLINE_ T cast(const Variant &p_variant) {
|
|
return p_variant;
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct VariantCaster<const T &> {
|
|
static _FORCE_INLINE_ T cast(const Variant &p_variant) {
|
|
return p_variant;
|
|
}
|
|
};
|
|
|
|
#define VARIANT_ENUM_CAST(m_enum) \
|
|
MAKE_ENUM_TYPE_INFO(m_enum) \
|
|
template <> \
|
|
struct VariantCaster<m_enum> { \
|
|
static _FORCE_INLINE_ m_enum cast(const Variant &p_variant) { \
|
|
return (m_enum)p_variant.operator int(); \
|
|
} \
|
|
}; \
|
|
template <> \
|
|
struct PtrToArg<m_enum> { \
|
|
_FORCE_INLINE_ static m_enum convert(const void *p_ptr) { \
|
|
return m_enum(*reinterpret_cast<const int *>(p_ptr)); \
|
|
} \
|
|
_FORCE_INLINE_ static void encode(m_enum p_val, const void *p_ptr) { \
|
|
*(int *)p_ptr = p_val; \
|
|
} \
|
|
};
|
|
|
|
// Object enum casts must go here
|
|
VARIANT_ENUM_CAST(Object::ConnectFlags);
|
|
|
|
VARIANT_ENUM_CAST(Vector3::Axis);
|
|
|
|
VARIANT_ENUM_CAST(Error);
|
|
VARIANT_ENUM_CAST(Margin);
|
|
VARIANT_ENUM_CAST(Corner);
|
|
VARIANT_ENUM_CAST(Orientation);
|
|
VARIANT_ENUM_CAST(HAlign);
|
|
VARIANT_ENUM_CAST(VAlign);
|
|
VARIANT_ENUM_CAST(PropertyHint);
|
|
VARIANT_ENUM_CAST(PropertyUsageFlags);
|
|
VARIANT_ENUM_CAST(Variant::Type);
|
|
VARIANT_ENUM_CAST(Variant::Operator);
|
|
|
|
template <>
|
|
struct VariantCaster<char32_t> {
|
|
static _FORCE_INLINE_ char32_t cast(const Variant &p_variant) {
|
|
return (char32_t)p_variant.operator int();
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct PtrToArg<char32_t> {
|
|
_FORCE_INLINE_ static char32_t convert(const void *p_ptr) {
|
|
return char32_t(*reinterpret_cast<const int *>(p_ptr));
|
|
}
|
|
_FORCE_INLINE_ static void encode(char32_t p_val, const void *p_ptr) {
|
|
*(int *)p_ptr = p_val;
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct VariantObjectClassChecker {
|
|
static _FORCE_INLINE_ bool check(const Variant &p_variant) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct VariantObjectClassChecker<Node *> {
|
|
static _FORCE_INLINE_ bool check(const Variant &p_variant) {
|
|
Object *obj = p_variant;
|
|
Node *node = p_variant;
|
|
return node || !obj;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct VariantObjectClassChecker<Control *> {
|
|
static _FORCE_INLINE_ bool check(const Variant &p_variant) {
|
|
Object *obj = p_variant;
|
|
Control *control = p_variant;
|
|
return control || !obj;
|
|
}
|
|
};
|
|
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
|
|
template <class T>
|
|
struct VariantCasterAndValidate {
|
|
static _FORCE_INLINE_ T cast(const Variant **p_args, uint32_t p_arg_idx, Callable::CallError &r_error) {
|
|
Variant::Type argtype = GetTypeInfo<T>::VARIANT_TYPE;
|
|
if (!Variant::can_convert_strict(p_args[p_arg_idx]->get_type(), argtype) ||
|
|
!VariantObjectClassChecker<T>::check(p_args[p_arg_idx])) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
|
r_error.argument = p_arg_idx;
|
|
r_error.expected = argtype;
|
|
}
|
|
|
|
return VariantCaster<T>::cast(*p_args[p_arg_idx]);
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct VariantCasterAndValidate<T &> {
|
|
static _FORCE_INLINE_ T cast(const Variant **p_args, uint32_t p_arg_idx, Callable::CallError &r_error) {
|
|
Variant::Type argtype = GetTypeInfo<T>::VARIANT_TYPE;
|
|
if (!Variant::can_convert_strict(p_args[p_arg_idx]->get_type(), argtype) ||
|
|
!VariantObjectClassChecker<T>::check(p_args[p_arg_idx])) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
|
r_error.argument = p_arg_idx;
|
|
r_error.expected = argtype;
|
|
}
|
|
|
|
return VariantCaster<T>::cast(*p_args[p_arg_idx]);
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct VariantCasterAndValidate<const T &> {
|
|
static _FORCE_INLINE_ T cast(const Variant **p_args, uint32_t p_arg_idx, Callable::CallError &r_error) {
|
|
Variant::Type argtype = GetTypeInfo<T>::VARIANT_TYPE;
|
|
if (!Variant::can_convert_strict(p_args[p_arg_idx]->get_type(), argtype) ||
|
|
!VariantObjectClassChecker<T>::check(p_args[p_arg_idx])) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
|
r_error.argument = p_arg_idx;
|
|
r_error.expected = argtype;
|
|
}
|
|
|
|
return VariantCaster<T>::cast(*p_args[p_arg_idx]);
|
|
}
|
|
};
|
|
|
|
#endif // DEBUG_METHODS_ENABLED
|
|
|
|
template <class T, class... P, size_t... Is>
|
|
void call_with_variant_args_helper(T *p_instance, void (T::*p_method)(P...), const Variant **p_args, Callable::CallError &r_error, IndexSequence<Is...>) {
|
|
r_error.error = Callable::CallError::CALL_OK;
|
|
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
(p_instance->*p_method)(VariantCasterAndValidate<P>::cast(p_args, Is, r_error)...);
|
|
#else
|
|
(p_instance->*p_method)(VariantCaster<P>::cast(*p_args[Is])...);
|
|
#endif
|
|
(void)(p_args); //avoid warning
|
|
}
|
|
|
|
template <class T, class... P, size_t... Is>
|
|
void call_with_variant_argsc_helper(T *p_instance, void (T::*p_method)(P...) const, const Variant **p_args, Callable::CallError &r_error, IndexSequence<Is...>) {
|
|
r_error.error = Callable::CallError::CALL_OK;
|
|
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
(p_instance->*p_method)(VariantCasterAndValidate<P>::cast(p_args, Is, r_error)...);
|
|
#else
|
|
(p_instance->*p_method)(VariantCaster<P>::cast(*p_args[Is])...);
|
|
#endif
|
|
(void)(p_args); //avoid warning
|
|
}
|
|
|
|
template <class T, class... P, size_t... Is>
|
|
void call_with_ptr_args_helper(T *p_instance, void (T::*p_method)(P...), const void **p_args, IndexSequence<Is...>) {
|
|
(p_instance->*p_method)(PtrToArg<P>::convert(p_args[Is])...);
|
|
}
|
|
|
|
template <class T, class... P, size_t... Is>
|
|
void call_with_ptr_argsc_helper(T *p_instance, void (T::*p_method)(P...) const, const void **p_args, IndexSequence<Is...>) {
|
|
(p_instance->*p_method)(PtrToArg<P>::convert(p_args[Is])...);
|
|
}
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_ptr_args_ret_helper(T *p_instance, R (T::*p_method)(P...), const void **p_args, void *r_ret, IndexSequence<Is...>) {
|
|
PtrToArg<R>::encode((p_instance->*p_method)(PtrToArg<P>::convert(p_args[Is])...), r_ret);
|
|
}
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_ptr_args_retc_helper(T *p_instance, R (T::*p_method)(P...) const, const void **p_args, void *r_ret, IndexSequence<Is...>) {
|
|
PtrToArg<R>::encode((p_instance->*p_method)(PtrToArg<P>::convert(p_args[Is])...), r_ret);
|
|
}
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_ptr_args_static_retc_helper(T *p_instance, R (*p_method)(T *, P...), const void **p_args, void *r_ret, IndexSequence<Is...>) {
|
|
PtrToArg<R>::encode(p_method(p_instance, PtrToArg<P>::convert(p_args[Is])...), r_ret);
|
|
}
|
|
|
|
template <class T, class... P, size_t... Is>
|
|
void call_with_validated_variant_args_helper(T *p_instance, void (T::*p_method)(P...), const Variant **p_args, IndexSequence<Is...>) {
|
|
(p_instance->*p_method)((VariantInternalAccessor<typename GetSimpleTypeT<P>::type_t>::get(p_args[Is]))...);
|
|
}
|
|
|
|
template <class T, class... P, size_t... Is>
|
|
void call_with_validated_variant_argsc_helper(T *p_instance, void (T::*p_method)(P...) const, const Variant **p_args, IndexSequence<Is...>) {
|
|
(p_instance->*p_method)((VariantInternalAccessor<typename GetSimpleTypeT<P>::type_t>::get(p_args[Is]))...);
|
|
}
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_validated_variant_args_ret_helper(T *p_instance, R (T::*p_method)(P...), const Variant **p_args, Variant *r_ret, IndexSequence<Is...>) {
|
|
VariantInternalAccessor<typename GetSimpleTypeT<R>::type_t>::set(r_ret, (p_instance->*p_method)((VariantInternalAccessor<typename GetSimpleTypeT<P>::type_t>::get(p_args[Is]))...));
|
|
}
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_validated_variant_args_retc_helper(T *p_instance, R (T::*p_method)(P...) const, const Variant **p_args, Variant *r_ret, IndexSequence<Is...>) {
|
|
VariantInternalAccessor<typename GetSimpleTypeT<R>::type_t>::set(r_ret, (p_instance->*p_method)((VariantInternalAccessor<typename GetSimpleTypeT<P>::type_t>::get(p_args[Is]))...));
|
|
}
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_validated_variant_args_static_retc_helper(T *p_instance, R (*p_method)(T *, P...), const Variant **p_args, Variant *r_ret, IndexSequence<Is...>) {
|
|
VariantInternalAccessor<typename GetSimpleTypeT<R>::type_t>::set(r_ret, p_method(p_instance, (VariantInternalAccessor<typename GetSimpleTypeT<P>::type_t>::get(p_args[Is]))...));
|
|
}
|
|
|
|
template <class T, class... P>
|
|
void call_with_variant_args(T *p_instance, void (T::*p_method)(P...), const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
|
|
if ((size_t)p_argcount < sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
call_with_variant_args_helper<T, P...>(p_instance, p_method, p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class... P>
|
|
void call_with_variant_args_dv(T *p_instance, void (T::*p_method)(P...), const Variant **p_args, int p_argcount, Callable::CallError &r_error, const Vector<Variant> &default_values) {
|
|
#ifdef DEBUG_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
int32_t missing = (int32_t)sizeof...(P) - (int32_t)p_argcount;
|
|
|
|
int32_t dvs = default_values.size();
|
|
#ifdef DEBUG_ENABLED
|
|
if (missing > dvs) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
const Variant *args[sizeof...(P) == 0 ? 1 : sizeof...(P)]; //avoid zero sized array
|
|
for (int32_t i = 0; i < (int32_t)sizeof...(P); i++) {
|
|
if (i < p_argcount) {
|
|
args[i] = p_args[i];
|
|
} else {
|
|
args[i] = &default_values[i - p_argcount + (dvs - missing)];
|
|
}
|
|
}
|
|
|
|
call_with_variant_args_helper(p_instance, p_method, args, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class... P>
|
|
void call_with_variant_argsc(T *p_instance, void (T::*p_method)(P...) const, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
|
|
if ((size_t)p_argcount < sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
call_with_variant_args_helper<T, P...>(p_instance, p_method, p_args, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class... P>
|
|
void call_with_variant_argsc_dv(T *p_instance, void (T::*p_method)(P...) const, const Variant **p_args, int p_argcount, Callable::CallError &r_error, const Vector<Variant> &default_values) {
|
|
#ifdef DEBUG_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
int32_t missing = (int32_t)sizeof...(P) - (int32_t)p_argcount;
|
|
|
|
int32_t dvs = default_values.size();
|
|
#ifdef DEBUG_ENABLED
|
|
if (missing > dvs) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
const Variant *args[sizeof...(P) == 0 ? 1 : sizeof...(P)]; //avoid zero sized array
|
|
for (int32_t i = 0; i < (int32_t)sizeof...(P); i++) {
|
|
if (i < p_argcount) {
|
|
args[i] = p_args[i];
|
|
} else {
|
|
args[i] = &default_values[i - p_argcount + (dvs - missing)];
|
|
}
|
|
}
|
|
|
|
call_with_variant_argsc_helper(p_instance, p_method, args, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_variant_args_ret_dv(T *p_instance, R (T::*p_method)(P...), const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error, const Vector<Variant> &default_values) {
|
|
#ifdef DEBUG_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
int32_t missing = (int32_t)sizeof...(P) - (int32_t)p_argcount;
|
|
|
|
int32_t dvs = default_values.size();
|
|
#ifdef DEBUG_ENABLED
|
|
if (missing > dvs) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
const Variant *args[sizeof...(P) == 0 ? 1 : sizeof...(P)]; //avoid zero sized array
|
|
for (int32_t i = 0; i < (int32_t)sizeof...(P); i++) {
|
|
if (i < p_argcount) {
|
|
args[i] = p_args[i];
|
|
} else {
|
|
args[i] = &default_values[i - p_argcount + (dvs - missing)];
|
|
}
|
|
}
|
|
|
|
call_with_variant_args_ret_helper(p_instance, p_method, args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_variant_args_retc_dv(T *p_instance, R (T::*p_method)(P...) const, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error, const Vector<Variant> &default_values) {
|
|
#ifdef DEBUG_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
int32_t missing = (int32_t)sizeof...(P) - (int32_t)p_argcount;
|
|
|
|
int32_t dvs = default_values.size();
|
|
#ifdef DEBUG_ENABLED
|
|
if (missing > dvs) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
const Variant *args[sizeof...(P) == 0 ? 1 : sizeof...(P)]; //avoid zero sized array
|
|
for (int32_t i = 0; i < (int32_t)sizeof...(P); i++) {
|
|
if (i < p_argcount) {
|
|
args[i] = p_args[i];
|
|
} else {
|
|
args[i] = &default_values[i - p_argcount + (dvs - missing)];
|
|
}
|
|
}
|
|
|
|
call_with_variant_args_retc_helper(p_instance, p_method, args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class... P>
|
|
void call_with_ptr_args(T *p_instance, void (T::*p_method)(P...), const void **p_args) {
|
|
call_with_ptr_args_helper<T, P...>(p_instance, p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class... P>
|
|
void call_with_ptr_argsc(T *p_instance, void (T::*p_method)(P...) const, const void **p_args) {
|
|
call_with_ptr_argsc_helper<T, P...>(p_instance, p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_ptr_args_ret(T *p_instance, R (T::*p_method)(P...), const void **p_args, void *r_ret) {
|
|
call_with_ptr_args_ret_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_ptr_args_retc(T *p_instance, R (T::*p_method)(P...) const, const void **p_args, void *r_ret) {
|
|
call_with_ptr_args_retc_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_ptr_args_static_retc(T *p_instance, R (*p_method)(T *, P...), const void **p_args, void *r_ret) {
|
|
call_with_ptr_args_static_retc_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class... P>
|
|
void call_with_validated_variant_args(Variant *base, void (T::*p_method)(P...), const Variant **p_args) {
|
|
call_with_validated_variant_args_helper<T, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_validated_variant_args_ret(Variant *base, R (T::*p_method)(P...), const Variant **p_args, Variant *r_ret) {
|
|
call_with_validated_variant_args_ret_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_validated_variant_args_retc(Variant *base, R (T::*p_method)(P...) const, const Variant **p_args, Variant *r_ret) {
|
|
call_with_validated_variant_args_retc_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_validated_variant_args_static_retc(Variant *base, R (*p_method)(T *, P...), const Variant **p_args, Variant *r_ret) {
|
|
call_with_validated_variant_args_static_retc_helper<T, R, P...>(VariantGetInternalPtr<T>::get_ptr(base), p_method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
// GCC raises "parameter 'p_args' set but not used" when P = {},
|
|
// it's not clever enough to treat other P values as making this branch valid.
|
|
#if defined(DEBUG_METHODS_ENABLED) && defined(__GNUC__) && !defined(__clang__)
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
|
|
#endif
|
|
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
|
|
template <class Q>
|
|
void call_get_argument_type_helper(int p_arg, int &index, Variant::Type &type) {
|
|
if (p_arg == index) {
|
|
type = GetTypeInfo<Q>::VARIANT_TYPE;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
template <class... P>
|
|
Variant::Type call_get_argument_type(int p_arg) {
|
|
Variant::Type type = Variant::NIL;
|
|
int index = 0;
|
|
// I think rocket science is simpler than modern C++.
|
|
using expand_type = int[];
|
|
expand_type a{ 0, (call_get_argument_type_helper<P>(p_arg, index, type), 0)... };
|
|
(void)a; // Suppress (valid, but unavoidable) -Wunused-variable warning.
|
|
(void)index; // Suppress GCC warning.
|
|
return type;
|
|
}
|
|
|
|
template <class Q>
|
|
void call_get_argument_type_info_helper(int p_arg, int &index, PropertyInfo &info) {
|
|
if (p_arg == index) {
|
|
info = GetTypeInfo<Q>::get_class_info();
|
|
}
|
|
index++;
|
|
}
|
|
|
|
template <class... P>
|
|
void call_get_argument_type_info(int p_arg, PropertyInfo &info) {
|
|
int index = 0;
|
|
// I think rocket science is simpler than modern C++.
|
|
using expand_type = int[];
|
|
expand_type a{ 0, (call_get_argument_type_info_helper<P>(p_arg, index, info), 0)... };
|
|
(void)a; // Suppress (valid, but unavoidable) -Wunused-variable warning.
|
|
(void)index; // Suppress GCC warning.
|
|
}
|
|
|
|
template <class Q>
|
|
void call_get_argument_metadata_helper(int p_arg, int &index, GodotTypeInfo::Metadata &md) {
|
|
if (p_arg == index) {
|
|
md = GetTypeInfo<Q>::METADATA;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
template <class... P>
|
|
GodotTypeInfo::Metadata call_get_argument_metadata(int p_arg) {
|
|
GodotTypeInfo::Metadata md = GodotTypeInfo::METADATA_NONE;
|
|
|
|
int index = 0;
|
|
// I think rocket science is simpler than modern C++.
|
|
using expand_type = int[];
|
|
expand_type a{ 0, (call_get_argument_metadata_helper<P>(p_arg, index, md), 0)... };
|
|
(void)a; // Suppress (valid, but unavoidable) -Wunused-variable warning.
|
|
(void)index;
|
|
return md;
|
|
}
|
|
|
|
#else
|
|
|
|
template <class... P>
|
|
Variant::Type call_get_argument_type(int p_arg) {
|
|
return Variant::NIL;
|
|
}
|
|
|
|
#endif // DEBUG_METHODS_ENABLED
|
|
|
|
//////////////////////
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_variant_args_ret_helper(T *p_instance, R (T::*p_method)(P...), const Variant **p_args, Variant &r_ret, Callable::CallError &r_error, IndexSequence<Is...>) {
|
|
r_error.error = Callable::CallError::CALL_OK;
|
|
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
r_ret = (p_instance->*p_method)(VariantCasterAndValidate<P>::cast(p_args, Is, r_error)...);
|
|
#else
|
|
r_ret = (p_instance->*p_method)(VariantCaster<P>::cast(*p_args[Is])...);
|
|
#endif
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_variant_args_ret(T *p_instance, R (T::*p_method)(P...), const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
|
|
if ((size_t)p_argcount < sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
call_with_variant_args_ret_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_variant_args_retc_helper(T *p_instance, R (T::*p_method)(P...) const, const Variant **p_args, Variant &r_ret, Callable::CallError &r_error, IndexSequence<Is...>) {
|
|
r_error.error = Callable::CallError::CALL_OK;
|
|
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
r_ret = (p_instance->*p_method)(VariantCasterAndValidate<P>::cast(p_args, Is, r_error)...);
|
|
#else
|
|
r_ret = (p_instance->*p_method)(VariantCaster<P>::cast(*p_args[Is])...);
|
|
#endif
|
|
(void)p_args;
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_variant_args_retc(T *p_instance, R (T::*p_method)(P...) const, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
|
|
if ((size_t)p_argcount < sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
call_with_variant_args_retc_helper<T, R, P...>(p_instance, p_method, p_args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
template <class T, class R, class... P, size_t... Is>
|
|
void call_with_variant_args_retc_static_helper(T *p_instance, R (*p_method)(T *, P...), const Variant **p_args, Variant &r_ret, Callable::CallError &r_error, IndexSequence<Is...>) {
|
|
r_error.error = Callable::CallError::CALL_OK;
|
|
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
r_ret = (p_method)(p_instance, VariantCasterAndValidate<P>::cast(p_args, Is, r_error)...);
|
|
#else
|
|
r_ret = (p_method)(p_instance, VariantCaster<P>::cast(*p_args[Is])...);
|
|
#endif
|
|
|
|
(void)p_args;
|
|
}
|
|
|
|
template <class T, class R, class... P>
|
|
void call_with_variant_args_retc_static_helper_dv(T *p_instance, R (*p_method)(T *, P...), const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &default_values, Callable::CallError &r_error) {
|
|
#ifdef DEBUG_ENABLED
|
|
if ((size_t)p_argcount > sizeof...(P)) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
int32_t missing = (int32_t)sizeof...(P) - (int32_t)p_argcount;
|
|
|
|
int32_t dvs = default_values.size();
|
|
#ifdef DEBUG_ENABLED
|
|
if (missing > dvs) {
|
|
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
|
|
r_error.argument = sizeof...(P);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
const Variant *args[sizeof...(P) == 0 ? 1 : sizeof...(P)]; //avoid zero sized array
|
|
for (int32_t i = 0; i < (int32_t)sizeof...(P); i++) {
|
|
if (i < p_argcount) {
|
|
args[i] = p_args[i];
|
|
} else {
|
|
args[i] = &default_values[i - p_argcount + (dvs - missing)];
|
|
}
|
|
}
|
|
|
|
call_with_variant_args_retc_static_helper(p_instance, p_method, args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
|
|
}
|
|
|
|
#if defined(DEBUG_METHODS_ENABLED) && defined(__GNUC__) && !defined(__clang__)
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
#endif // BINDER_COMMON_H
|