jni: implement Throw and ThrowNew

Author: Serial-ATA

jni/src/env/exceptions.rs

@@ -1,6 +1,54 @@
+use crate::error::{JniError, Result};
+use crate::objects::{JClass, JThrowable};
+use crate::string::JniString;
+
 impl super::JniEnv {
-	// TODO: Throw
-	// TODO: ThrowNew
+	/// Causes `exception` to be thrown
+	///
+	/// # Errors
+	///
+	/// If the VM returns an error, then the exception was likely not thrown.
+	pub fn throw(&self, exception: JThrowable) -> Result<()> {
+		let ret;
+		unsafe {
+			let invoke_interface = self.as_native_interface();
+			ret = ((*invoke_interface).Throw)(self.0.cast::<jni_sys::JNIEnv>(), exception.raw());
+		}
+
+		if ret != 0 {
+			return Err(JniError::Unknown);
+		}
+
+		Ok(())
+	}
+
+	/// Constructs an object of type `class` with the `message` specified, and causes that exception to be thrown.
+	///
+	/// ## Parameters
+	///
+	/// `class`: a subclass of `java.lang.Throwable`
+	/// `message`: the message used to construct the java.lang.Throwable object
+	///
+	/// ## Errors
+	///
+	/// If the VM returns an error, then the exception was likely not thrown.
+	pub fn throw_new(&self, class: JClass, message: Option<JniString>) -> Result<()> {
+		let ret;
+		unsafe {
+			let invoke_interface = self.as_native_interface();
+			ret = ((*invoke_interface).ThrowNew)(
+				self.0.cast::<jni_sys::JNIEnv>(),
+				class.raw(),
+				message.map_or_else(core::ptr::null, |message| message.as_cstr().as_ptr()),
+			);
+		}
+
+		if ret != 0 {
+			return Err(JniError::Unknown);
+		}
+
+		Ok(())
+	}
 	// TODO: ExceptionOccurred
 
 	/// Prints an exception and a backtrace of the stack to a system error-reporting channel, such as stderr.

runtime/src/native/java/lang/String.rs

@@ -3,6 +3,7 @@ use crate::objects::instance::class::ClassInstanceRef;
 use crate::objects::reference::Reference;
 use crate::symbols::Symbol;
 
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::sync::{LazyLock, RwLock};
@@ -94,6 +95,11 @@ impl<'a> StringHashDerivable<&'a str> for &'a str {
 		<&[u1] as StringHashDerivable<&[u1]>>::string_hash(&value.as_bytes())
 	}
 }
+impl<'a> StringHashDerivable<Cow<'a, str>> for Cow<'a, str> {
+	fn string_hash(value: &Cow<'a, str>) -> StringHash {
+		<&str as StringHashDerivable<&str>>::string_hash(&&**value)
+	}
+}
 impl<'a> StringHashDerivable<&'a [u1]> for &'a [u1] {
 	fn string_hash(value: &Self) -> StringHash {
 		let mut h = 0;

runtime/src/native/jni/exceptions.rs

@@ -1,18 +1,93 @@
-use crate::classes;
+use crate::native::java;
+use crate::native::java::lang::String::StringInterner;
+use crate::native::jni::reference_from_jobject;
+use crate::objects::method::Method;
+use crate::objects::reference::Reference;
+use crate::symbols::sym;
 use crate::thread::JavaThread;
+use crate::thread::exceptions::Throws;
+use crate::{classes, java_call};
 
 use core::ffi::c_char;
+use std::{ptr, slice};
 
-use jni::sys::{JNIEnv, jboolean, jclass, jint, jthrowable};
+use ::jni::sys::{JNI_ERR, JNI_OK, JNIEnv, jboolean, jclass, jint, jthrowable};
+use common::unicode;
+use instructions::Operand;
+use libc::strlen;
 
 #[unsafe(no_mangle)]
 pub extern "system" fn Throw(env: *mut JNIEnv, obj: jthrowable) -> jint {
-	unimplemented!("jni::Throw");
+	let thread = JavaThread::current();
+	assert_eq!(thread.env().raw(), env);
+
+	let Some(throwable) = (unsafe { reference_from_jobject(obj) }) else {
+		return JNI_ERR;
+	};
+
+	if !throwable.is_instance_of(crate::globals::classes::java_lang_Throwable()) {
+		return JNI_ERR;
+	}
+
+	thread.set_pending_exception(throwable);
+
+	JNI_OK
 }
 
 #[unsafe(no_mangle)]
 pub extern "system" fn ThrowNew(env: *mut JNIEnv, clazz: jclass, msg: *const c_char) -> jint {
-	unimplemented!("jni::ThrowNew");
+	let thread = JavaThread::current();
+	assert_eq!(thread.env().raw(), env);
+
+	let Some(mirror) = (unsafe { reference_from_jobject(clazz) }) else {
+		return JNI_ERR;
+	};
+
+	let mut message = None;
+	if !msg.is_null() {
+		// SAFETY: It's entirely up to the caller to pass in a valid string
+		let len = unsafe { strlen(msg) };
+
+		// SAFETY: c_char is always 8 bits
+		let utf = unsafe { slice::from_raw_parts(msg.cast::<u8>(), len) };
+
+		if let Ok(utf_8) = unicode::decode(utf) {
+			message = Some(utf_8);
+		};
+	}
+
+	let throwable_class = mirror.extract_target_class();
+
+	let constructor;
+	if message.is_none() {
+		constructor = throwable_class
+			.resolve_method(sym!(object_initializer_name), sym!(void_method_signature));
+	} else {
+		constructor = throwable_class
+			.resolve_method(sym!(object_initializer_name), sym!(String_void_signature));
+	}
+
+	match constructor {
+		Throws::Ok(constructor) => match message {
+			Some(message) => {
+				let string = StringInterner::intern(message);
+				java_call!(
+					thread,
+					constructor,
+					Operand::Reference(Reference::class(string))
+				);
+			},
+			None => {
+				java_call!(thread, constructor);
+			},
+		},
+		Throws::Exception(e) => {
+			e.throw(thread);
+			return JNI_ERR;
+		},
+	}
+
+	JNI_OK
 }
 
 #[unsafe(no_mangle)]