Add module init; move symbols from macros + export

Author: Bromeon

gdnative-async/src/rt.rs

@@ -4,8 +4,8 @@ use gdnative_bindings::Object;
 use gdnative_core::object::SubClass;
 
 use gdnative_core::core_types::{GodotError, Variant};
-use gdnative_core::export::InitHandle;
 use gdnative_core::export::{Instance, RefInstance};
+use gdnative_core::init::InitHandle;
 use gdnative_core::object::ownership::Shared;
 use gdnative_core::object::TRef;
 

gdnative-core/src/export/class_builder.rs

@@ -38,185 +38,15 @@ use std::marker::PhantomData;
 use std::ptr;
 
 use crate::core_types::{GodotString, Variant};
-use crate::export::user_data::UserData;
 use crate::export::*;
-use crate::object::{GodotObject, NewRef, RawObject, TRef};
+use crate::object::NewRef;
 use crate::private::get_api;
 
-/// A handle that can register new classes to the engine during initialization.
-///
-/// See [`godot_nativescript_init`](macro.godot_nativescript_init.html) and
-/// [`godot_init`](macro.godot_init.html).
-#[derive(Copy, Clone)]
-pub struct InitHandle {
-    #[doc(hidden)]
-    handle: *mut libc::c_void,
-}
-
-impl InitHandle {
-    #[doc(hidden)]
-    #[inline]
-    pub unsafe fn new(handle: *mut libc::c_void) -> Self {
-        InitHandle { handle }
-    }
-
-    /// Registers a new class to the engine.
-    #[inline]
-    pub fn add_class<C>(self)
-    where
-        C: NativeClassMethods,
-    {
-        self.add_maybe_tool_class::<C>(false)
-    }
-
-    /// Registers a new tool class to the engine.
-    #[inline]
-    pub fn add_tool_class<C>(self)
-    where
-        C: NativeClassMethods,
-    {
-        self.add_maybe_tool_class::<C>(true)
-    }
-
-    #[inline]
-    fn add_maybe_tool_class<C>(self, is_tool: bool)
-    where
-        C: NativeClassMethods,
-    {
-        if !class_registry::register_class::<C>() {
-            panic!(
-                "`{type_name}` has already been registered",
-                type_name = std::any::type_name::<C>()
-            );
-        }
-        unsafe {
-            let class_name = CString::new(C::class_name()).unwrap();
-            let base_name = CString::new(C::Base::class_name()).unwrap();
-
-            let create = {
-                unsafe extern "C" fn constructor<C: NativeClass>(
-                    this: *mut sys::godot_object,
-                    _method_data: *mut libc::c_void,
-                ) -> *mut libc::c_void {
-                    use std::panic::{self, AssertUnwindSafe};
-
-                    let this = match ptr::NonNull::new(this) {
-                        Some(this) => this,
-                        None => {
-                            godot_error!(
-                                "gdnative-core: error constructing {}: owner pointer is null",
-                                C::class_name(),
-                            );
-
-                            return ptr::null_mut();
-                        }
-                    };
-
-                    let owner = match RawObject::<C::Base>::try_from_sys_ref(this) {
-                        Some(owner) => owner,
-                        None => {
-                            godot_error!(
-                                "gdnative-core: error constructing {}: incompatible owner type, expecting {}",
-                                C::class_name(),
-                                C::Base::class_name(),
-                            );
-                            return ptr::null_mut();
-                        }
-                    };
-
-                    let val = match panic::catch_unwind(AssertUnwindSafe(|| {
-                        emplace::take()
-                            .unwrap_or_else(|| C::init(TRef::new(C::Base::cast_ref(owner))))
-                    })) {
-                        Ok(val) => val,
-                        Err(_) => {
-                            godot_error!(
-                                "gdnative-core: error constructing {}: constructor panicked",
-                                C::class_name(),
-                            );
-                            return ptr::null_mut();
-                        }
-                    };
-
-                    let wrapper = C::UserData::new(val);
-                    C::UserData::into_user_data(wrapper) as *mut _
-                }
-
-                sys::godot_instance_create_func {
-                    create_func: Some(constructor::<C>),
-                    method_data: ptr::null_mut(),
-                    free_func: None,
-                }
-            };
-
-            let destroy = {
-                unsafe extern "C" fn destructor<C: NativeClass>(
-                    _this: *mut sys::godot_object,
-                    _method_data: *mut libc::c_void,
-                    user_data: *mut libc::c_void,
-                ) {
-                    if user_data.is_null() {
-                        godot_error!(
-                            "gdnative-core: user data pointer for {} is null (did the constructor fail?)",
-                            C::class_name(),
-                        );
-                        return;
-                    }
-
-                    let wrapper = C::UserData::consume_user_data_unchecked(user_data);
-                    drop(wrapper)
-                }
-
-                sys::godot_instance_destroy_func {
-                    destroy_func: Some(destructor::<C>),
-                    method_data: ptr::null_mut(),
-                    free_func: None,
-                }
-            };
-
-            if is_tool {
-                (get_api().godot_nativescript_register_tool_class)(
-                    self.handle as *mut _,
-                    class_name.as_ptr() as *const _,
-                    base_name.as_ptr() as *const _,
-                    create,
-                    destroy,
-                );
-            } else {
-                (get_api().godot_nativescript_register_class)(
-                    self.handle as *mut _,
-                    class_name.as_ptr() as *const _,
-                    base_name.as_ptr() as *const _,
-                    create,
-                    destroy,
-                );
-            }
-
-            (get_api().godot_nativescript_set_type_tag)(
-                self.handle as *mut _,
-                class_name.as_ptr() as *const _,
-                crate::export::type_tag::create::<C>(),
-            );
-
-            let builder = ClassBuilder {
-                init_handle: self.handle,
-                class_name,
-                _marker: PhantomData,
-            };
-
-            C::register_properties(&builder);
-
-            // register methods
-            C::register(&builder);
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct ClassBuilder<C> {
-    pub(super) init_handle: *mut libc::c_void,
-    pub(super) class_name: CString,
-    _marker: PhantomData<C>,
+    pub(crate) init_handle: *mut libc::c_void,
+    pub(crate) class_name: CString,
+    pub(crate) _marker: PhantomData<C>,
 }
 
 impl<C: NativeClass> ClassBuilder<C> {

gdnative-core/src/export/macros.rs

@@ -1,74 +1,5 @@
 #![macro_use]
 
-/// Declare the API endpoint to initialize export classes on startup.
-///
-/// By default this declares an extern function named `godot_nativescript_init`.
-/// This can be overridden, for example:
-///
-/// ```ignore
-/// // Declares an extern function named custom_nativescript_init instead of
-/// // godot_nativescript_init.
-/// godot_gdnative_terminate!(my_registration_callback as custom_nativescript_init);
-/// ```
-///
-/// Overriding the default entry point names can be useful if several gdnative
-/// libraries are linked statically  to avoid name clashes.
-#[macro_export]
-macro_rules! godot_nativescript_init {
-    () => {
-        fn godot_nativescript_init_empty(_init: $crate::export::InitHandle) {}
-        $crate::godot_nativescript_init!(godot_nativescript_init_empty);
-    };
-    ($callback:ident) => {
-        $crate::godot_nativescript_init!($callback as godot_nativescript_init);
-    };
-    (_ as $fn_name:ident) => {
-        fn godot_nativescript_init_empty(_init: $crate::export::InitHandle) {}
-        $crate::godot_nativescript_init!(godot_nativescript_init_empty as $fn_name);
-    };
-    ($callback:ident as $fn_name:ident) => {
-        #[no_mangle]
-        #[doc(hidden)]
-        #[allow(unused_unsafe)]
-        pub unsafe extern "C" fn $fn_name(handle: *mut $crate::libc::c_void) {
-            if !$crate::private::is_api_bound() {
-                return;
-            }
-
-            let __result = ::std::panic::catch_unwind(|| {
-                $callback($crate::export::InitHandle::new(handle));
-            });
-
-            if __result.is_err() {
-                $crate::godot_error!("gdnative-core: nativescript_init callback panicked");
-            }
-        }
-    };
-}
-
-/// Declare all the API endpoints necessary to initialize a NativeScript library.
-///
-/// `godot_init!(init)` is a shorthand for:
-///
-/// ```ignore
-/// godot_gdnative_init!();
-/// godot_nativescript_init!(init);
-/// godot_gdnative_terminate!();
-/// ```
-///
-/// This declares three extern functions, named `godot_gdnative_init`,
-/// `godot_nativescript_init`, and `godot_gdnative_terminate`. If you need different prefixes
-/// to avoid name clashes when multiple GDNative libraries are linked statically, please use
-/// the respective macros directly.
-#[macro_export]
-macro_rules! godot_init {
-    ($callback:ident) => {
-        $crate::godot_gdnative_init!();
-        $crate::godot_nativescript_init!($callback);
-        $crate::godot_gdnative_terminate!();
-    };
-}
-
 #[doc(hidden)]
 #[macro_export]
 macro_rules! godot_wrap_method_parameter_count {

gdnative-core/src/export/mod.rs

@@ -11,12 +11,12 @@
 
 mod class;
 mod class_builder;
-mod emplace;
 mod macros;
 mod method;
 mod property;
 
 pub(crate) mod class_registry;
+pub(crate) mod emplace;
 pub(crate) mod type_tag;
 
 pub use class::*;

gdnative-core/src/init/info.rs

@@ -0,0 +1,96 @@
+use crate::core_types::GodotString;
+
+/// Context for the [`godot_gdnative_init`][crate::init::godot_gdnative_init] callback.
+pub struct InitializeInfo {
+    in_editor: bool,
+    active_library_path: GodotString,
+    options: *mut crate::sys::godot_gdnative_init_options,
+}
+
+impl InitializeInfo {
+    /// Returns true if the library is loaded in the Godot Editor.
+    #[inline]
+    pub fn in_editor(&self) -> bool {
+        self.in_editor
+    }
+
+    /// Returns a path to the library relative to the project.
+    ///
+    /// Example: `res://../../target/debug/libhello_world.dylib`
+    #[inline]
+    pub fn active_library_path(&self) -> &GodotString {
+        &self.active_library_path
+    }
+
+    /// Internal interface.
+    ///
+    /// # Safety
+    ///
+    /// Will `panic!()` if options is NULL, UB if invalid.
+    #[inline]
+    #[doc(hidden)]
+    pub unsafe fn new(options: *mut crate::sys::godot_gdnative_init_options) -> Self {
+        assert!(!options.is_null(), "options were NULL");
+        let crate::sys::godot_gdnative_init_options {
+            in_editor,
+            active_library_path,
+            ..
+        } = *options;
+
+        let active_library_path = GodotString::clone_from_sys(*active_library_path);
+
+        Self {
+            in_editor,
+            active_library_path,
+            options,
+        }
+    }
+
+    #[inline]
+    pub fn report_loading_error<T>(&self, message: T)
+    where
+        T: std::fmt::Display,
+    {
+        let crate::sys::godot_gdnative_init_options {
+            report_loading_error,
+            gd_native_library,
+            ..
+        } = unsafe { *self.options };
+
+        if let Some(report_loading_error_fn) = report_loading_error {
+            // Add the trailing zero and convert Display => String
+            let message = format!("{}\0", message);
+
+            // Convert to FFI compatible string
+            let message = std::ffi::CStr::from_bytes_with_nul(message.as_bytes())
+                .expect("message should not have a NULL");
+
+            unsafe {
+                report_loading_error_fn(gd_native_library, message.as_ptr());
+            }
+        }
+    }
+}
+
+/// Context for the [`godot_gdnative_terminate`][crate::init::godot_gdnative_terminate] callback.
+pub struct TerminateInfo {
+    in_editor: bool,
+}
+
+impl TerminateInfo {
+    #[inline]
+    #[doc(hidden)] // avoids clippy warning: unsafe function's docs miss `# Safety` section
+    pub unsafe fn new(options: *mut crate::sys::godot_gdnative_terminate_options) -> Self {
+        assert!(!options.is_null(), "options were NULL");
+
+        let crate::sys::godot_gdnative_terminate_options { in_editor } = *options;
+
+        Self { in_editor }
+    }
+
+    /// Returns `true` if the library is loaded in the Godot Editor.
+    #[inline]
+    pub fn in_editor(&self) -> bool {
+        self.in_editor
+    }
+}