Merge pull request #309 from stewbasic/master

Report initialization errors to Godot.

Author: toasteater

gdnative-core/src/lib.rs

@@ -185,3 +185,34 @@ pub fn result_from_sys(err: sys::godot_error) -> GodotResult {
 
     Err(unsafe { mem::transmute(err as u32) })
 }
+
+pub unsafe fn report_init_error(
+    options: *const sys::godot_gdnative_init_options,
+    error: sys::InitError,
+) {
+    use std::ffi::CString;
+    match error {
+        sys::InitError::VersionMismatch {
+            api_type,
+            want,
+            got,
+        } => {
+            if let Some(f) = (*options).report_version_mismatch {
+                f(
+                    (*options).gd_native_library,
+                    CString::new(format!("{}", api_type)).unwrap().as_ptr(),
+                    want,
+                    got,
+                );
+            }
+        }
+        sys::InitError::Generic { message } => {
+            if let Some(f) = (*options).report_loading_error {
+                f(
+                    (*options).gd_native_library,
+                    CString::new(message).unwrap().as_ptr(),
+                );
+            }
+        }
+    }
+}

gdnative-core/src/macros.rs

@@ -31,7 +31,14 @@ macro_rules! godot_gdnative_init {
         #[doc(hidden)]
         pub extern "C" fn $fn_name(options: *mut $crate::sys::godot_gdnative_init_options) {
             unsafe {
-                $crate::GODOT_API = Some($crate::GodotApi::from_raw((*options).api_struct));
+                let api = match $crate::GodotApi::from_raw((*options).api_struct) {
+                    Ok(api) => api,
+                    Err(e) => {
+                        $crate::report_init_error(options, e);
+                        return;
+                    }
+                };
+                $crate::GODOT_API = Some(api);
                 $crate::GDNATIVE_LIBRARY_SYS = Some((*options).gd_native_library);
             }
             let api = $crate::get_api();
@@ -81,6 +88,9 @@ macro_rules! godot_gdnative_terminate {
         #[no_mangle]
         #[doc(hidden)]
         pub extern "C" fn $fn_name(options: *mut $crate::sys::godot_gdnative_terminate_options) {
+            if unsafe { $crate::GODOT_API.is_none() } {
+                return;
+            }
             $callback(options);
 
             unsafe {
@@ -120,6 +130,9 @@ macro_rules! godot_nativescript_init {
         #[no_mangle]
         #[doc(hidden)]
         pub extern "C" fn $fn_name(handle: *mut $crate::libc::c_void) {
+            if unsafe { $crate::GODOT_API.is_none() } {
+                return;
+            }
             unsafe {
                 $callback($crate::init::InitHandle::new(handle));
             }

gdnative-sys/build.rs

@@ -337,26 +337,26 @@ mod api_wrapper {
             let v_min = api.version.minor;
             let gd_api_struct = api.godot_api_struct();
             godot_apis.extend(quote! {
-                let #i = find_api_ptr(core_api_struct, #gd_api_type, #v_maj, #v_min) as *const #gd_api_struct;
+                let #i = find_api_ptr(core_api_struct, #gd_api_type, #v_maj, #v_min)? as *const #gd_api_struct;
             });
             for function in &api.functions {
                 let function_name = function.rust_name();
-                let expect_msg = format!(
+                let message = format!(
                     "API function missing: {}.{}",
                     api.godot_api_struct(),
                     function_name
                 );
                 constructed_struct_fields.extend(quote! {
-                    #function_name: (*#i).#function_name.expect(#expect_msg),
+                    #function_name: map_option_to_init_error((*#i).#function_name, #message)?,
                 });
             }
         }
         quote! {
-            pub unsafe fn from_raw(core_api_struct: *const godot_gdnative_core_api_struct) -> Self {
+            pub unsafe fn from_raw(core_api_struct: *const godot_gdnative_core_api_struct) -> Result<Self, InitError> {
                 #godot_apis
-                GodotApi{
+                Ok(GodotApi{
                     #constructed_struct_fields
-                }
+                })
             }
         }
     }

gdnative-sys/src/lib.rs

@@ -7,46 +7,98 @@
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 include!(concat!(env!("OUT_DIR"), "/api_wrapper.rs"));
 
-unsafe fn find_api_ptr(
-    core_api: *const godot_gdnative_core_api_struct,
+pub enum InitError {
+    VersionMismatch {
+        api_type: GDNATIVE_API_TYPES,
+        want: godot_gdnative_api_version,
+        got: godot_gdnative_api_version,
+    },
+    Generic {
+        message: String,
+    },
+}
+
+fn map_option_to_init_error<T>(t: Option<T>, message: &'static str) -> Result<T, InitError> {
+    match t {
+        Some(t) => Ok(t),
+        None => Err(InitError::Generic {
+            message: message.to_string(),
+        }),
+    }
+}
+
+unsafe fn find_version(
+    mut api: *const godot_gdnative_api_struct,
     api_type: GDNATIVE_API_TYPES,
     version_major: u32,
     version_minor: u32,
-) -> *const godot_gdnative_api_struct {
-    let mut api = core_api as *const godot_gdnative_api_struct;
+) -> Option<Result<*const godot_gdnative_api_struct, InitError>> {
+    let mut got = None;
     if (*api).type_ as u32 == api_type as u32 {
         while !api.is_null() {
-            if (*api).version.minor == version_minor
-                && (*api).version.major == version_major
-                // The boolean expression below SHOULD always be true;
-                // we will double check to be safe.
-                && (*api).type_ as u32 == api_type as u32
-            {
-                return api;
+            // The boolean expression below SHOULD always be true;
+            // we will double check to be safe.
+            if (*api).type_ as u32 == api_type as u32 {
+                let (major, minor) = ((*api).version.major, (*api).version.minor);
+                if major == version_major && minor == version_minor {
+                    return Some(Ok(api));
+                } else {
+                    got = Some(godot_gdnative_api_version { major, minor });
+                }
             }
             api = (*api).next;
         }
     }
+    got.map(|got| {
+        Err(InitError::VersionMismatch {
+            want: godot_gdnative_api_version {
+                major: version_major,
+                minor: version_minor,
+            },
+            got,
+            api_type,
+        })
+    })
+}
+
+unsafe fn find_api_ptr(
+    core_api: *const godot_gdnative_core_api_struct,
+    api_type: GDNATIVE_API_TYPES,
+    version_major: u32,
+    version_minor: u32,
+) -> Result<*const godot_gdnative_api_struct, InitError> {
+    let mut last_error = None;
+    match find_version(
+        core_api as *const godot_gdnative_api_struct,
+        api_type,
+        version_major,
+        version_minor,
+    ) {
+        Some(Ok(api)) => {
+            return Ok(api);
+        }
+        Some(Err(error)) => {
+            last_error = Some(error);
+        }
+        None => {}
+    }
     for i in 0..(*core_api).num_extensions {
-        let mut extension =
-            *(*core_api).extensions.offset(i as _) as *const godot_gdnative_api_struct;
-        if (*extension).type_ as u32 == api_type as u32 {
-            while !extension.is_null() {
-                if (*extension).version.minor == version_minor
-                    && (*extension).version.major == version_major
-                    // The boolean expression below SHOULD always be true;
-                    // we will double check to be safe.
-                    && (*extension).type_ as u32 == api_type as u32
-                {
-                    return extension;
-                }
-                extension = (*extension).next;
+        match find_version(
+            *(*core_api).extensions.offset(i as _),
+            api_type,
+            version_major,
+            version_minor,
+        ) {
+            Some(Ok(api)) => {
+                return Ok(api);
+            }
+            Some(Err(error)) => {
+                last_error = Some(error);
             }
+            None => {}
         }
     }
-    panic!(
-        "Couldn't find API struct with type {type}, version {version:?}",
-        type = api_type,
-        version = (version_major, version_minor),
-    );
+    Err(last_error.unwrap_or(InitError::Generic {
+        message: format!("Couldn't find API struct with type {}", api_type),
+    }))
 }