use alloc::{boxed::Box, format, vec, vec::Vec};
use jvm::{Array, ClassInstance, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use crate::{
RuntimeClassProto, RuntimeContext,
classes::java::{
io::{PrintStream, PrintWriter},
lang::String,
},
};
pub struct Throwable;
impl Throwable {
pub fn as_proto() -> RuntimeClassProto {
RuntimeClassProto {
name: "java/lang/Throwable",
parent_class: Some("java/lang/Object"),
interfaces: vec!["java/io/Serializable"],
methods: vec![
JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_message, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("<init>", "(Ljava/lang/Throwable;)V", Self::init_with_cause, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"<init>",
"(Ljava/lang/String;Ljava/lang/Throwable;)V",
Self::init_with_message_and_cause,
MethodAccessFlags::PUBLIC,
),
JavaMethodProto::new(
"getCause",
"()Ljava/lang/Throwable;",
Self::get_cause,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("getMessage", "()Ljava/lang/String;", Self::get_message, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"getLocalizedMessage",
"()Ljava/lang/String;",
Self::get_localized_message,
MethodAccessFlags::PUBLIC,
),
JavaMethodProto::new(
"initCause",
"(Ljava/lang/Throwable;)Ljava/lang/Throwable;",
Self::init_cause,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"fillInStackTrace",
"()Ljava/lang/Throwable;",
Self::fill_in_stack_trace,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("printStackTrace", "()V", Self::print_stack_trace, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"printStackTrace",
"(Ljava/io/PrintStream;)V",
Self::print_stack_trace_to_print_stream,
MethodAccessFlags::PUBLIC,
),
JavaMethodProto::new(
"printStackTrace",
"(Ljava/io/PrintWriter;)V",
Self::print_stack_trace_to_print_writer,
MethodAccessFlags::PUBLIC,
),
],
fields: vec![
JavaFieldProto::new("detailMessage", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
JavaFieldProto::new("cause", "Ljava/lang/Throwable;", FieldAccessFlags::PRIVATE),
JavaFieldProto::new("stackTrace", "[Ljava/lang/String;", FieldAccessFlags::PRIVATE),
],
access_flags: ClassAccessFlags::PUBLIC,
}
}
async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.lang.Throwable::<init>({this:?})");
let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
let _: ClassInstanceRef<Self> = jvm
.invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
.await?;
Ok(())
}
async fn init_with_message(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
tracing::debug!("java.lang.Throwable::<init>({this:?}, {message:?})");
let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
jvm.put_field(&mut this, "detailMessage", "Ljava/lang/String;", message).await?;
let _: ClassInstanceRef<Self> = jvm
.invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
.await?;
Ok(())
}
async fn init_with_cause(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, cause: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.lang.Throwable::<init>({this:?}, {cause:?})");
let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
let message: ClassInstanceRef<String> = if cause.is_null() {
None.into()
} else {
jvm.invoke_virtual(&cause, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
.await?
};
jvm.put_field(&mut this, "detailMessage", "Ljava/lang/String;", message).await?;
jvm.put_field(&mut this, "cause", "Ljava/lang/Throwable;", cause).await?;
let _: ClassInstanceRef<Self> = jvm
.invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
.await?;
Ok(())
}
async fn init_with_message_and_cause(
jvm: &Jvm,
_: &mut RuntimeContext,
mut this: ClassInstanceRef<Self>,
message: ClassInstanceRef<String>,
cause: ClassInstanceRef<Self>,
) -> Result<()> {
tracing::debug!("java.lang.Throwable::<init>({this:?}, {message:?}, {cause:?})");
let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
jvm.put_field(&mut this, "detailMessage", "Ljava/lang/String;", message).await?;
jvm.put_field(&mut this, "cause", "Ljava/lang/Throwable;", cause).await?;
let _: ClassInstanceRef<Self> = jvm
.invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
.await?;
Ok(())
}
async fn get_cause(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
tracing::debug!("java.lang.Throwable::getCause({this:?})");
jvm.get_field(&this, "cause", "Ljava/lang/Throwable;").await
}
async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
tracing::debug!("java.lang.Throwable::getMessage({this:?})");
jvm.get_field(&this, "detailMessage", "Ljava/lang/String;").await
}
async fn get_localized_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
tracing::debug!("java.lang.Throwable::getLocalizedMessage({this:?})");
jvm.invoke_virtual(&this, "java/lang/Throwable", "getMessage", "()Ljava/lang/String;", ())
.await
}
async fn init_cause(
jvm: &Jvm,
_: &mut RuntimeContext,
mut this: ClassInstanceRef<Self>,
cause: ClassInstanceRef<Self>,
) -> Result<ClassInstanceRef<Self>> {
tracing::debug!("java.lang.Throwable::initCause({this:?}, {cause:?})");
jvm.put_field(&mut this, "cause", "Ljava/lang/Throwable;", cause).await?;
Ok(this)
}
async fn fill_in_stack_trace(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
tracing::debug!("java.lang.Throwable::fillInStackTrace({this:?})");
let stack_trace = jvm.stack_trace();
let mut stack_trace_array = jvm.instantiate_array("Ljava/lang/String;", stack_trace.len()).await?;
for (i, line) in stack_trace.iter().enumerate() {
let java_line = JavaLangString::from_rust_string(jvm, line).await?;
jvm.store_array(&mut stack_trace_array, i, core::iter::once(java_line)).await?;
}
jvm.put_field(&mut this, "stackTrace", "[Ljava/lang/String;", stack_trace_array).await?;
Ok(this)
}
async fn print_stack_trace(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.lang.Throwable::printStackTrace({this:?})");
let err: ClassInstanceRef<PrintStream> = jvm.get_static_field("java/lang/System", "err", "Ljava/io/PrintStream;").await?;
let _: () = jvm
.invoke_virtual(&this, "java/lang/Throwable", "printStackTrace", "(Ljava/io/PrintStream;)V", (err,))
.await?;
Ok(())
}
async fn print_stack_trace_to_print_stream(
jvm: &Jvm,
_: &mut RuntimeContext,
this: ClassInstanceRef<Self>,
stream: ClassInstanceRef<PrintStream>,
) -> Result<()> {
tracing::debug!("java.lang.Throwable::printStackTrace({this:?}, {stream:?})");
Self::do_print_stack_trace(jvm, this, stream.into()).await?;
Ok(())
}
async fn print_stack_trace_to_print_writer(
jvm: &Jvm,
_: &mut RuntimeContext,
this: ClassInstanceRef<Self>,
writer: ClassInstanceRef<PrintWriter>,
) -> Result<()> {
tracing::debug!("java.lang.Throwable::printStackTrace({this:?}, {writer:?})");
Self::do_print_stack_trace(jvm, this, writer.into()).await?;
Ok(())
}
async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
tracing::debug!("java.lang.Throwable::toString({this:?})");
let class = jvm
.invoke_virtual(&this, "java/lang/Object", "getClass", "()Ljava/lang/Class;", ())
.await?;
let class_name = jvm
.invoke_virtual(&class, "java/lang/Class", "getName", "()Ljava/lang/String;", ())
.await?;
let message: ClassInstanceRef<String> = jvm.get_field(&this, "detailMessage", "Ljava/lang/String;").await?;
let class_name = JavaLangString::to_rust_string(jvm, &class_name).await?;
let message = if message.is_null() {
class_name
} else {
let message = JavaLangString::to_rust_string(jvm, &message).await?;
if message.is_empty() {
class_name
} else {
format!("{class_name}: {message}")
}
};
let message = JavaLangString::from_rust_string(jvm, &message).await?;
Ok(message.into())
}
async fn do_print_stack_trace(jvm: &Jvm, this: ClassInstanceRef<Self>, stream_or_writer: Box<dyn ClassInstance>) -> Result<()> {
let mut current: ClassInstanceRef<Self> = this;
let mut header: Option<&str> = None;
for _ in 0..32 {
let string: ClassInstanceRef<String> = jvm
.invoke_virtual(¤t, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
.await?;
let prefix: ClassInstanceRef<String> = match header {
Some(x) => {
let string = JavaLangString::to_rust_string(jvm, &string).await?;
JavaLangString::from_rust_string(jvm, &format!("{x}{string}")).await?.into()
}
None => string,
};
let _: () = jvm
.invoke_virtual(
&stream_or_writer,
&stream_or_writer.class_definition().name(),
"println",
"(Ljava/lang/String;)V",
(prefix,),
)
.await?;
let stack_trace: ClassInstanceRef<Array<ClassInstanceRef<String>>> = jvm.get_field(¤t, "stackTrace", "[Ljava/lang/String;").await?;
if !stack_trace.is_null() {
let length = jvm.array_length(&stack_trace).await?;
let lines: Vec<ClassInstanceRef<String>> = jvm.load_array(&stack_trace, 0, length).await?;
for line_ref in lines {
let line = JavaLangString::to_rust_string(jvm, &line_ref).await?;
let line = format!("\tat {line}");
let line = JavaLangString::from_rust_string(jvm, &line).await?;
let _: () = jvm
.invoke_virtual(
&stream_or_writer,
&stream_or_writer.class_definition().name(),
"println",
"(Ljava/lang/String;)V",
(line,),
)
.await?;
}
}
let cause: ClassInstanceRef<Self> = jvm
.invoke_virtual(¤t, "java/lang/Throwable", "getCause", "()Ljava/lang/Throwable;", ())
.await?;
if cause.is_null() {
break;
}
current = cause;
header = Some("Caused by: ");
}
Ok(())
}
}