jni: implement RegisterNatives

Author: Serial-ATA

jni/src/env/mod.rs

@@ -9,6 +9,7 @@ mod object;
 mod references;
 mod reflection;
 mod register;
+pub use register::*;
 mod string;
 mod version;
 mod vm;

jni/src/env/register.rs

@@ -1,4 +1,177 @@
+use crate::env::JniEnv;
+use crate::error::{JniError, Result};
+use crate::objects::{
+	JArray, JBooleanArray, JByteArray, JCharArray, JClass, JDoubleArray, JFloatArray, JIntArray,
+	JLongArray, JObject, JObjectArray, JShortArray, JString, JThrowable, JWeak,
+};
+use crate::string::JniString;
+
+use std::ffi::c_void;
+
+use jni_sys::{jboolean, jbyte, jchar, jdouble, jfloat, jint, jlong, jshort};
+
+pub struct JniNativeMethod {
+	name: JniString,
+	signature: JniString,
+	fn_ptr: *mut c_void,
+}
+
+impl JniNativeMethod {
+	pub fn from<F, N, S>(name: N, signature: S, fn_ptr: F) -> Self
+	where
+		F: JniMethod,
+		N: Into<JniString>,
+		S: Into<JniString>,
+	{
+		Self {
+			name: name.into(),
+			signature: signature.into(),
+			fn_ptr: fn_ptr.raw(),
+		}
+	}
+
+	fn raw(&self) -> jni_sys::JNINativeMethod {
+		jni_sys::JNINativeMethod {
+			name: self.name.as_cstr().as_ptr().cast_mut(),
+			signature: self.signature.as_cstr().as_ptr().cast_mut(),
+			fnPtr: self.fn_ptr.cast(),
+		}
+	}
+}
+
+pub trait JniMethod {
+	fn raw(self) -> *mut c_void;
+}
+
+macro_rules! impl_jni_method {
+    (
+        $(($($params:ident),*)),* $(,)?
+    ) => {
+        $(
+        impl<R, $($params),*> JniMethod for fn(JniEnv, JObject, $($params),*) -> R
+        where
+            R: JniMethodReturnType,
+            $($params: JniMethodParameter),*
+        {
+            fn raw(self) -> *mut c_void {
+                self as _
+            }
+        }
+
+        impl<R, $($params),*> JniMethod for fn(JniEnv, JClass, $($params),*) -> R
+        where
+            R: JniMethodReturnType,
+            $($params: JniMethodParameter),*
+        {
+            fn raw(self) -> *mut c_void {
+                self as _
+            }
+        }
+        )*
+    }
+}
+
+impl_jni_method!(
+	(),
+	(T),
+	(T, U),
+	(T, U, V),
+	(T, U, V, W),
+	(T, U, V, W, X),
+	(T, U, V, W, X, Y),
+	(T, U, V, W, X, Y, Z),
+	(T, U, V, W, X, Y, Z, A),
+	(T, U, V, W, X, Y, Z, A, B),
+	(T, U, V, W, X, Y, Z, A, B, C),
+	(T, U, V, W, X, Y, Z, A, B, C, D),
+	(T, U, V, W, X, Y, Z, A, B, C, D, E),
+	(T, U, V, W, X, Y, Z, A, B, C, D, E, F),
+	(T, U, V, W, X, Y, Z, A, B, C, D, E, F, G),
+);
+
+pub trait JniMethodParameter: sealed::Sealed {}
+macro_rules! params {
+    ($($ty:ident),* $(,)*) => {
+        $(
+            impl JniMethodParameter for $ty {}
+            impl sealed::Sealed for $ty {}
+        )*
+    }
+}
+
+params!(
+	jbyte,
+	jchar,
+	jdouble,
+	jfloat,
+	jint,
+	jlong,
+	jshort,
+	jboolean,
+	JObject,
+	JClass,
+	JThrowable,
+	JString,
+	JWeak,
+	JArray,
+	JBooleanArray,
+	JByteArray,
+	JCharArray,
+	JShortArray,
+	JIntArray,
+	JLongArray,
+	JFloatArray,
+	JDoubleArray,
+	JObjectArray,
+);
+
+pub trait JniMethodReturnType: sealed::Sealed {}
+
+impl<T> JniMethodReturnType for T where T: JniMethodParameter {}
+
+impl JniMethodReturnType for () {}
+
+mod sealed {
+	pub(super) trait Sealed {}
+	impl Sealed for () {}
+}
+
 impl super::JniEnv {
-	// TODO: RegisterNatives
+	/// Registers native methods with the class specified by the `clazz` argument.
+	///
+	/// ## PARAMETERS
+	///
+	/// `clazz`: a Java class object.
+	/// `methods`: the native methods in the class.
+	///
+	/// ## THROWS
+	///
+	/// `NoSuchMethodError`: if a specified method cannot be found or if the method is not native.
+	pub fn register_natives(&self, clazz: JClass, methods: &[JniNativeMethod]) -> Result<()> {
+		assert!(!self.raw().is_null());
+
+		let methods = methods.iter().map(JniNativeMethod::raw).collect::<Vec<_>>();
+
+		let ret;
+		unsafe {
+			let invoke_interface = self.as_native_interface();
+			ret = ((*invoke_interface).RegisterNatives)(
+				self.0.cast::<jni_sys::JNIEnv>(),
+				clazz.raw(),
+				methods.as_ptr(),
+				methods.len() as jint,
+			);
+		}
+
+		if self.exception_check() {
+			return Err(JniError::ExceptionThrown);
+		}
+
+		if ret != 0 {
+			return Err(JniError::Unknown);
+		}
+
+		Ok(())
+	}
 	// TODO: UnregisterNatives
 }

runtime/src/native/jni/register.rs

@@ -1,4 +1,14 @@
-use jni::sys::{JNIEnv, JNINativeMethod, jclass, jint};
+use crate::native::jni::reference_from_jobject;
+use crate::native::method::NativeMethodPtr;
+use crate::objects::method::MethodEntryPoint;
+use crate::symbols::Symbol;
+use crate::thread::JavaThread;
+use crate::thread::exceptions::{Throws, throw_with_ret};
+
+use std::ffi::CStr;
+
+use ::jni::sys::{JNI_ERR, JNI_OK, JNIEnv, JNINativeMethod, jclass, jint};
+use common::unicode;
 
 #[unsafe(no_mangle)]
 pub extern "system" fn RegisterNatives(
@@ -7,7 +17,57 @@ pub extern "system" fn RegisterNatives(
 	methods: *const JNINativeMethod,
 	nMethods: jint,
 ) -> jint {
-	unimplemented!("jni::RegisterNatives")
+	let thread = JavaThread::current();
+	assert_eq!(thread.env().raw(), env);
+
+	let Some(mirror) = (unsafe { reference_from_jobject(clazz) }) else {
+		panic!("Invalid arguments to `GetSuperclass`");
+	};
+
+	let class = mirror.extract_target_class();
+	if class.is_array() || class.is_interface() {
+		return JNI_ERR;
+	}
+
+	// SAFETY: It's up to the caller to provide a valid array
+	let methods = unsafe { std::slice::from_raw_parts(methods, nMethods as usize) };
+
+	for raw_method in methods {
+		// SAFETY: It's up to the caller to provide valid strings
+		let name_c = unsafe { CStr::from_ptr(raw_method.name) };
+		let signature_c = unsafe { CStr::from_ptr(raw_method.signature) };
+
+		let (Ok(name), Ok(signature)) = (
+			unicode::decode(name_c.to_bytes()),
+			unicode::decode(signature_c.to_bytes()),
+		) else {
+			return JNI_ERR;
+		};
+
+		match class.resolve_method(Symbol::intern(name), Symbol::intern(signature)) {
+			Throws::Ok(method) => {
+				if !method.is_native() {
+					throw_with_ret!(
+						0,
+						thread,
+						NoSuchMethodError,
+						"Method '{}' is not declared as native",
+						method.external_name()
+					);
+				}
+
+				method.set_entry_point(MethodEntryPoint::NativeMethod(NativeMethodPtr::External(
+					raw_method.fnPtr,
+				)));
+			},
+			Throws::Exception(e) => {
+				e.throw(thread);
+				return 0;
+			},
+		}
+	}
+
+	JNI_OK
 }
 
 #[unsafe(no_mangle)]