From db2394dbe76e0df9ac6933c38af7e7635367ee7b Mon Sep 17 00:00:00 2001 From: Andy Maloney Date: Thu, 16 Feb 2023 10:38:38 -0500 Subject: [PATCH] Identifiers containing double underscore are reserved according to the C++ standard Rename __* to _gde_* https://timsong-cpp.github.io/cppwp/n3337/global.names https://en.cppreference.com/w/cpp/language/identifiers Identifiers appearing as a token or preprocessing token (i.e., not in user-defined-string-literal like operator ""id) (since C++11) of one of the following forms are reserved: - identifiers with a double underscore anywhere; - identifiers that begin with an underscore followed by an uppercase letter; - in the global namespace, identifiers that begin with an underscore. --- binding_generator.py | 66 +++++----- include/godot_cpp/classes/ref.hpp | 2 +- include/godot_cpp/classes/wrapped.hpp | 162 ++++++++++++------------- include/godot_cpp/core/class_db.hpp | 20 +-- include/godot_cpp/core/method_bind.hpp | 4 +- include/godot_cpp/core/type_info.hpp | 4 +- src/core/object.cpp | 2 +- 7 files changed, 130 insertions(+), 130 deletions(-) diff --git a/binding_generator.py b/binding_generator.py index 3a00049b..4aff96e0 100644 --- a/binding_generator.py +++ b/binding_generator.py @@ -791,24 +791,24 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl result.append("\tString::_init_bindings_constructors_destructor();") result.append(f"\t{class_name}::_init_bindings_constructors_destructor();") - result.append("\tStringName __name;") + result.append("\tStringName _gde_name;") if "methods" in builtin_api: for method in builtin_api["methods"]: # TODO: Add error check for hash mismatch. - result.append(f'\t__name = StringName("{method["name"]}");') + result.append(f'\t_gde_name = StringName("{method["name"]}");') result.append( - f'\t_method_bindings.method_{method["name"]} = internal::gdextension_interface_variant_get_ptr_builtin_method({enum_type_name}, __name._native_ptr(), {method["hash"]});' + f'\t_method_bindings.method_{method["name"]} = internal::gdextension_interface_variant_get_ptr_builtin_method({enum_type_name}, _gde_name._native_ptr(), {method["hash"]});' ) if "members" in builtin_api: for member in builtin_api["members"]: - result.append(f'\t__name = StringName("{member["name"]}");') + result.append(f'\t_gde_name = StringName("{member["name"]}");') result.append( - f'\t_method_bindings.member_{member["name"]}_setter = internal::gdextension_interface_variant_get_ptr_setter({enum_type_name}, __name._native_ptr());' + f'\t_method_bindings.member_{member["name"]}_setter = internal::gdextension_interface_variant_get_ptr_setter({enum_type_name}, _gde_name._native_ptr());' ) result.append( - f'\t_method_bindings.member_{member["name"]}_getter = internal::gdextension_interface_variant_get_ptr_getter({enum_type_name}, __name._native_ptr());' + f'\t_method_bindings.member_{member["name"]}_getter = internal::gdextension_interface_variant_get_ptr_getter({enum_type_name}, _gde_name._native_ptr());' ) if "indexing_return_type" in builtin_api: @@ -1443,15 +1443,15 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us if is_singleton: result.append(f"{class_name} *{class_name}::get_singleton() {{") - result.append(f"\tconst StringName __class_name = {class_name}::get_class_static();") + result.append(f"\tconst StringName _gde_class_name = {class_name}::get_class_static();") result.append( - "\tstatic GDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton(__class_name._native_ptr());" + "\tstatic GDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton(_gde_class_name._native_ptr());" ) result.append("#ifdef DEBUG_ENABLED") result.append("\tERR_FAIL_COND_V(singleton_obj == nullptr, nullptr);") result.append("#endif // DEBUG_ENABLED") result.append( - f"\tstatic {class_name} *singleton = reinterpret_cast<{class_name} *>(internal::gdextension_interface_object_get_instance_binding(singleton_obj, internal::token, &{class_name}::___binding_callbacks));" + f"\tstatic {class_name} *singleton = reinterpret_cast<{class_name} *>(internal::gdextension_interface_object_get_instance_binding(singleton_obj, internal::token, &{class_name}::_gde_binding_callbacks));" ) result.append("\treturn singleton;") result.append("}") @@ -1470,20 +1470,20 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us result.append(method_signature + " {") # Method body. - result.append(f"\tconst StringName __class_name = {class_name}::get_class_static();") - result.append(f'\tconst StringName __method_name = "{method["name"]}";') + result.append(f"\tconst StringName _gde_class_name = {class_name}::get_class_static();") + result.append(f'\tconst StringName _gde_method_name = "{method["name"]}";') result.append( - f'\tstatic GDExtensionMethodBindPtr ___method_bind = internal::gdextension_interface_classdb_get_method_bind(__class_name._native_ptr(), __method_name._native_ptr(), {method["hash"]});' + f'\tstatic GDExtensionMethodBindPtr _gde_method_bind = internal::gdextension_interface_classdb_get_method_bind(_gde_class_name._native_ptr(), _gde_method_name._native_ptr(), {method["hash"]});' ) method_call = "\t" has_return = "return_value" in method and method["return_value"]["type"] != "void" if has_return: result.append( - f'\tCHECK_METHOD_BIND_RET(___method_bind, {get_default_value_for_type(method["return_value"]["type"])});' + f'\tCHECK_METHOD_BIND_RET(_gde_method_bind, {get_default_value_for_type(method["return_value"]["type"])});' ) else: - result.append("\tCHECK_METHOD_BIND(___method_bind);") + result.append("\tCHECK_METHOD_BIND(_gde_method_bind);") is_ref = False if not vararg: @@ -1492,34 +1492,34 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us meta_type = method["return_value"]["meta"] if "meta" in method["return_value"] else None if is_enum(return_type): if method["is_static"]: - method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret(___method_bind, nullptr" + method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret(_gde_method_bind, nullptr" else: - method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret(___method_bind, _owner" + method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret(_gde_method_bind, _owner" elif is_pod_type(return_type) or is_variant(return_type): if method["is_static"]: - method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(___method_bind, nullptr" + method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(_gde_method_bind, nullptr" else: - method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(___method_bind, _owner" + method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(_gde_method_bind, _owner" elif is_refcounted(return_type): if method["is_static"]: - method_call += f"return Ref<{return_type}>::___internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, nullptr" + method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, nullptr" else: - method_call += f"return Ref<{return_type}>::___internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, _owner" + method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, _owner" is_ref = True else: if method["is_static"]: method_call += ( - f"return internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, nullptr" + f"return internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, nullptr" ) else: method_call += ( - f"return internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, _owner" + f"return internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, _owner" ) else: if method["is_static"]: - method_call += "internal::_call_native_mb_no_ret(___method_bind, nullptr" + method_call += "internal::_call_native_mb_no_ret(_gde_method_bind, nullptr" else: - method_call += "internal::_call_native_mb_no_ret(___method_bind, _owner" + method_call += "internal::_call_native_mb_no_ret(_gde_method_bind, _owner" if "arguments" in method: method_call += ", " @@ -1536,7 +1536,7 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us else: # vararg. result.append("\tGDExtensionCallError error;") result.append("\tVariant ret;") - method_call += "internal::gdextension_interface_object_method_bind_call(___method_bind, _owner, reinterpret_cast(args), arg_count, &ret, &error" + method_call += "internal::gdextension_interface_object_method_bind_call(_gde_method_bind, _owner, reinterpret_cast(args), arg_count, &ret, &error" if is_ref: method_call += ")" # Close Ref<> constructor. @@ -1763,28 +1763,28 @@ def generate_utility_functions(api, output_dir): # Function body. - source.append(f'\tconst StringName __function_name = "{function["name"]}";') + source.append(f'\tconst StringName _gde_function_name = "{function["name"]}";') source.append( - f'\tstatic GDExtensionPtrUtilityFunction ___function = internal::gdextension_interface_variant_get_ptr_utility_function(__function_name._native_ptr(), {function["hash"]});' + f'\tstatic GDExtensionPtrUtilityFunction _gde_function = internal::gdextension_interface_variant_get_ptr_utility_function(_gde_function_name._native_ptr(), {function["hash"]});' ) has_return = "return_type" in function and function["return_type"] != "void" if has_return: source.append( - f'\tCHECK_METHOD_BIND_RET(___function, {get_default_value_for_type(function["return_type"])});' + f'\tCHECK_METHOD_BIND_RET(_gde_function, {get_default_value_for_type(function["return_type"])});' ) else: - source.append("\tCHECK_METHOD_BIND(___function);") + source.append("\tCHECK_METHOD_BIND(_gde_function);") function_call = "\t" if not vararg: if has_return: function_call += "return " if function["return_type"] == "Object": - function_call += "internal::_call_utility_ret_obj(___function" + function_call += "internal::_call_utility_ret_obj(_gde_function" else: - function_call += f'internal::_call_utility_ret<{get_gdextension_type(correct_type(function["return_type"]))}>(___function' + function_call += f'internal::_call_utility_ret<{get_gdextension_type(correct_type(function["return_type"]))}>(_gde_function' else: - function_call += "internal::_call_utility_no_ret(___function" + function_call += "internal::_call_utility_no_ret(_gde_function" if "arguments" in function: function_call += ", " @@ -1803,7 +1803,7 @@ def generate_utility_functions(api, output_dir): source.append(f'\t{get_gdextension_type(correct_type(function["return_type"]))} ret;') else: source.append("\tVariant ret;") - function_call += "___function(&ret, reinterpret_cast(args), arg_count" + function_call += "_gde_function(&ret, reinterpret_cast(args), arg_count" function_call += ");" source.append(function_call) diff --git a/include/godot_cpp/classes/ref.hpp b/include/godot_cpp/classes/ref.hpp index 92a1e7f7..f30928ac 100644 --- a/include/godot_cpp/classes/ref.hpp +++ b/include/godot_cpp/classes/ref.hpp @@ -219,7 +219,7 @@ public: // Used exclusively in the bindings to recreate the Ref Godot encapsulates in return values, // without adding to the refcount. - inline static Ref ___internal_constructor(Object *obj) { + inline static Ref _gde_internal_constructor(Object *obj) { Ref r; r.reference = (T *)obj; return r; diff --git a/include/godot_cpp/classes/wrapped.hpp b/include/godot_cpp/classes/wrapped.hpp index 17a742c1..9a01672f 100644 --- a/include/godot_cpp/classes/wrapped.hpp +++ b/include/godot_cpp/classes/wrapped.hpp @@ -109,7 +109,7 @@ protected: } \ \ virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override { \ - return &___binding_callbacks; \ + return &_gde_binding_callbacks; \ } \ \ static void (*_get_bind_methods())() { \ @@ -288,97 +288,97 @@ public: } \ } \ \ - static void *___binding_create_callback(void *p_token, void *p_instance) { \ + static void *_gde_binding_create_callback(void *p_token, void *p_instance) { \ return nullptr; \ } \ \ - static void ___binding_free_callback(void *p_token, void *p_instance, void *p_binding) { \ + static void _gde_binding_free_callback(void *p_token, void *p_instance, void *p_binding) { \ } \ \ - static GDExtensionBool ___binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \ + static GDExtensionBool _gde_binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \ return true; \ } \ \ - static constexpr GDExtensionInstanceBindingCallbacks ___binding_callbacks = { \ - ___binding_create_callback, \ - ___binding_free_callback, \ - ___binding_reference_callback, \ + static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = { \ + _gde_binding_create_callback, \ + _gde_binding_free_callback, \ + _gde_binding_reference_callback, \ }; // Don't use this for your classes, use GDCLASS() instead. -#define GDEXTENSION_CLASS(m_class, m_inherits) \ -private: \ - void operator=(const m_class &p_rval) {} \ - \ -protected: \ - virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override { \ - return &___binding_callbacks; \ - } \ - \ - m_class(const char *p_godot_class) : m_inherits(p_godot_class) {} \ - m_class(GodotObject *p_godot_object) : m_inherits(p_godot_object) {} \ - \ - static void (*_get_bind_methods())() { \ - return nullptr; \ - } \ - \ - static void (Wrapped::*_get_notification())(int) { \ - return nullptr; \ - } \ - \ - static bool (Wrapped::*_get_set())(const ::godot::StringName &p_name, const Variant &p_property) { \ - return nullptr; \ - } \ - \ - static bool (Wrapped::*_get_get())(const ::godot::StringName &p_name, Variant &r_ret) const { \ - return nullptr; \ - } \ - \ - static void (Wrapped::*_get_get_property_list())(List * p_list) const { \ - return nullptr; \ - } \ - \ - static bool (Wrapped::*_get_property_can_revert())(const ::godot::StringName &p_name) { \ - return nullptr; \ - } \ - \ - static bool (Wrapped::*_get_property_get_revert())(const ::godot::StringName &p_name, Variant &) { \ - return nullptr; \ - } \ - \ - static String (Wrapped::*_get_to_string())() { \ - return nullptr; \ - } \ - \ -public: \ - static void initialize_class() {} \ - \ - static ::godot::StringName &get_class_static() { \ - static ::godot::StringName string_name = ::godot::StringName(#m_class); \ - return string_name; \ - } \ - \ - static ::godot::StringName &get_parent_class_static() { \ - return m_inherits::get_class_static(); \ - } \ - \ - static void *___binding_create_callback(void *p_token, void *p_instance) { \ - /* Do not call memnew here, we don't want the postinitializer to be called */ \ - return new ("") m_class((GodotObject *)p_instance); \ - } \ - static void ___binding_free_callback(void *p_token, void *p_instance, void *p_binding) { \ - /* Explicitly call the deconstructor to ensure proper lifecycle for non-trivial members */ \ - reinterpret_cast(p_binding)->~m_class(); \ - Memory::free_static(reinterpret_cast(p_binding)); \ - } \ - static GDExtensionBool ___binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \ - return true; \ - } \ - static constexpr GDExtensionInstanceBindingCallbacks ___binding_callbacks = { \ - ___binding_create_callback, \ - ___binding_free_callback, \ - ___binding_reference_callback, \ - }; \ +#define GDEXTENSION_CLASS(m_class, m_inherits) \ +private: \ + void operator=(const m_class &p_rval) {} \ + \ +protected: \ + virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override { \ + return &_gde_binding_callbacks; \ + } \ + \ + m_class(const char *p_godot_class) : m_inherits(p_godot_class) {} \ + m_class(GodotObject *p_godot_object) : m_inherits(p_godot_object) {} \ + \ + static void (*_get_bind_methods())() { \ + return nullptr; \ + } \ + \ + static void (Wrapped::*_get_notification())(int) { \ + return nullptr; \ + } \ + \ + static bool (Wrapped::*_get_set())(const ::godot::StringName &p_name, const Variant &p_property) { \ + return nullptr; \ + } \ + \ + static bool (Wrapped::*_get_get())(const ::godot::StringName &p_name, Variant &r_ret) const { \ + return nullptr; \ + } \ + \ + static void (Wrapped::*_get_get_property_list())(List * p_list) const { \ + return nullptr; \ + } \ + \ + static bool (Wrapped::*_get_property_can_revert())(const ::godot::StringName &p_name) { \ + return nullptr; \ + } \ + \ + static bool (Wrapped::*_get_property_get_revert())(const ::godot::StringName &p_name, Variant &) { \ + return nullptr; \ + } \ + \ + static String (Wrapped::*_get_to_string())() { \ + return nullptr; \ + } \ + \ +public: \ + static void initialize_class() {} \ + \ + static ::godot::StringName &get_class_static() { \ + static ::godot::StringName string_name = ::godot::StringName(#m_class); \ + return string_name; \ + } \ + \ + static ::godot::StringName &get_parent_class_static() { \ + return m_inherits::get_class_static(); \ + } \ + \ + static void *_gde_binding_create_callback(void *p_token, void *p_instance) { \ + /* Do not call memnew here, we don't want the post-initializer to be called */ \ + return new ("") m_class((GodotObject *)p_instance); \ + } \ + static void _gde_binding_free_callback(void *p_token, void *p_instance, void *p_binding) { \ + /* Explicitly call the deconstructor to ensure proper lifecycle for non-trivial members */ \ + reinterpret_cast(p_binding)->~m_class(); \ + Memory::free_static(reinterpret_cast(p_binding)); \ + } \ + static GDExtensionBool _gde_binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \ + return true; \ + } \ + static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = { \ + _gde_binding_create_callback, \ + _gde_binding_free_callback, \ + _gde_binding_reference_callback, \ + }; \ m_class() : m_class(#m_class) {} #endif // GODOT_WRAPPED_HPP diff --git a/include/godot_cpp/core/class_db.hpp b/include/godot_cpp/core/class_db.hpp index 46fbd42d..425d5a21 100644 --- a/include/godot_cpp/core/class_db.hpp +++ b/include/godot_cpp/core/class_db.hpp @@ -150,22 +150,22 @@ public: godot::ClassDB::bind_integer_constant(get_class_static(), "", #m_constant, m_constant); #define BIND_ENUM_CONSTANT(m_constant) \ - godot::ClassDB::bind_integer_constant(get_class_static(), godot::__constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant); + godot::ClassDB::bind_integer_constant(get_class_static(), godot::_gde_constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant); #define BIND_BITFIELD_FLAG(m_constant) \ - godot::ClassDB::bind_integer_constant(get_class_static(), godot::__constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true); + godot::ClassDB::bind_integer_constant(get_class_static(), godot::_gde_constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true); -#define BIND_VIRTUAL_METHOD(m_class, m_method) \ - { \ - auto ___call##m_method = [](GDExtensionObjectPtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr p_ret) -> void { \ - call_with_ptr_args(reinterpret_cast(p_instance), &m_class::m_method, p_args, p_ret); \ - }; \ - godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, ___call##m_method); \ +#define BIND_VIRTUAL_METHOD(m_class, m_method) \ + { \ + auto _call##m_method = [](GDExtensionObjectPtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr p_ret) -> void { \ + call_with_ptr_args(reinterpret_cast(p_instance), &m_class::m_method, p_args, p_ret); \ + }; \ + godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, _call##m_method); \ } template void ClassDB::_register_class(bool p_virtual) { - instance_binding_callbacks[T::get_class_static()] = &T::___binding_callbacks; + instance_binding_callbacks[T::get_class_static()] = &T::_gde_binding_callbacks; // Register this class within our plugin ClassInfo cl; @@ -221,7 +221,7 @@ void ClassDB::register_abstract_class() { template void ClassDB::register_engine_class() { - instance_binding_callbacks[T::get_class_static()] = &T::___binding_callbacks; + instance_binding_callbacks[T::get_class_static()] = &T::_gde_binding_callbacks; } template diff --git a/include/godot_cpp/core/method_bind.hpp b/include/godot_cpp/core/method_bind.hpp index ae2142a2..37ae7317 100644 --- a/include/godot_cpp/core/method_bind.hpp +++ b/include/godot_cpp/core/method_bind.hpp @@ -268,8 +268,8 @@ MethodBind *create_vararg_method_bind(R (T::*p_method)(const Variant **, GDExten } #ifndef TYPED_METHOD_BIND -class ___UnexistingClass; -#define MB_T ___UnexistingClass +class _gde_UnexistingClass; +#define MB_T _gde_UnexistingClass #else #define MB_T T #endif diff --git a/include/godot_cpp/core/type_info.hpp b/include/godot_cpp/core/type_info.hpp index 039cb2e6..f0edda5c 100644 --- a/include/godot_cpp/core/type_info.hpp +++ b/include/godot_cpp/core/type_info.hpp @@ -241,7 +241,7 @@ inline String enum_qualified_name_to_class_info_name(const String &p_qualified_n TEMPL_MAKE_ENUM_TYPE_INFO(m_enum, const m_enum &) template -inline StringName __constant_get_enum_name(T param, StringName p_constant) { +inline StringName _gde_constant_get_enum_name(T param, StringName p_constant) { if (GetTypeInfo::VARIANT_TYPE == Variant::NIL) { ERR_PRINT(("Missing VARIANT_ENUM_CAST for constant's enum: " + String(p_constant)).utf8().get_data()); } @@ -288,7 +288,7 @@ public: TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, const m_enum &) template -inline StringName __constant_get_bitfield_name(T param, StringName p_constant) { +inline StringName _gde_constant_get_bitfield_name(T param, StringName p_constant) { if (GetTypeInfo::VARIANT_TYPE == Variant::NIL) { ERR_PRINT(("Missing VARIANT_ENUM_CAST for constant's bitfield: " + String(p_constant)).utf8().get_data()); } diff --git a/src/core/object.cpp b/src/core/object.cpp index 54cc013f..dc3c8798 100644 --- a/src/core/object.cpp +++ b/src/core/object.cpp @@ -54,7 +54,7 @@ Object *get_object_instance_binding(GodotObject *p_engine_object) { binding_callbacks = ClassDB::get_instance_binding_callbacks(class_name); } if (binding_callbacks == nullptr) { - binding_callbacks = &Object::___binding_callbacks; + binding_callbacks = &Object::_gde_binding_callbacks; } return reinterpret_cast(gdextension_interface_object_get_instance_binding(p_engine_object, token, binding_callbacks));