Skip to main content

rustjava_runtime/classes/java/lang/
throwable.rs

1use alloc::{boxed::Box, format, vec, vec::Vec};
2
3use jvm::{Array, ClassInstance, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        io::{PrintStream, PrintWriter},
11        lang::String,
12    },
13};
14
15// class java.lang.Throwable
16pub struct Throwable;
17
18impl Throwable {
19    pub fn as_proto() -> RuntimeClassProto {
20        RuntimeClassProto {
21            name: "java/lang/Throwable",
22            parent_class: Some("java/lang/Object"),
23            interfaces: vec!["java/io/Serializable"],
24            methods: vec![
25                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_message, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("<init>", "(Ljava/lang/Throwable;)V", Self::init_with_cause, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new(
29                    "<init>",
30                    "(Ljava/lang/String;Ljava/lang/Throwable;)V",
31                    Self::init_with_message_and_cause,
32                    MethodAccessFlags::PUBLIC,
33                ),
34                JavaMethodProto::new(
35                    "getCause",
36                    "()Ljava/lang/Throwable;",
37                    Self::get_cause,
38                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
39                ),
40                JavaMethodProto::new("getMessage", "()Ljava/lang/String;", Self::get_message, MethodAccessFlags::PUBLIC),
41                JavaMethodProto::new(
42                    "getLocalizedMessage",
43                    "()Ljava/lang/String;",
44                    Self::get_localized_message,
45                    MethodAccessFlags::PUBLIC,
46                ),
47                JavaMethodProto::new(
48                    "initCause",
49                    "(Ljava/lang/Throwable;)Ljava/lang/Throwable;",
50                    Self::init_cause,
51                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
52                ),
53                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
54                JavaMethodProto::new(
55                    "fillInStackTrace",
56                    "()Ljava/lang/Throwable;",
57                    Self::fill_in_stack_trace,
58                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
59                ),
60                JavaMethodProto::new("printStackTrace", "()V", Self::print_stack_trace, MethodAccessFlags::PUBLIC),
61                JavaMethodProto::new(
62                    "printStackTrace",
63                    "(Ljava/io/PrintStream;)V",
64                    Self::print_stack_trace_to_print_stream,
65                    MethodAccessFlags::PUBLIC,
66                ),
67                JavaMethodProto::new(
68                    "printStackTrace",
69                    "(Ljava/io/PrintWriter;)V",
70                    Self::print_stack_trace_to_print_writer,
71                    MethodAccessFlags::PUBLIC,
72                ),
73            ],
74            fields: vec![
75                JavaFieldProto::new("detailMessage", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
76                JavaFieldProto::new("cause", "Ljava/lang/Throwable;", FieldAccessFlags::PRIVATE),
77                JavaFieldProto::new("stackTrace", "[Ljava/lang/String;", FieldAccessFlags::PRIVATE),
78            ],
79            access_flags: ClassAccessFlags::PUBLIC,
80        }
81    }
82
83    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
84        tracing::debug!("java.lang.Throwable::<init>({this:?})");
85
86        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
87
88        let _: ClassInstanceRef<Self> = jvm
89            .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
90            .await?;
91
92        Ok(())
93    }
94
95    async fn init_with_message(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
96        tracing::debug!("java.lang.Throwable::<init>({this:?}, {message:?})");
97
98        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
99
100        jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message)
101            .await?;
102
103        let _: ClassInstanceRef<Self> = jvm
104            .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
105            .await?;
106
107        Ok(())
108    }
109
110    async fn init_with_cause(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, cause: ClassInstanceRef<Self>) -> Result<()> {
111        tracing::debug!("java.lang.Throwable::<init>({this:?}, {cause:?})");
112
113        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
114
115        let message: ClassInstanceRef<String> = if cause.is_null() {
116            None.into()
117        } else {
118            jvm.invoke_virtual(&cause, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
119                .await?
120        };
121        jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message)
122            .await?;
123        jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause)
124            .await?;
125
126        let _: ClassInstanceRef<Self> = jvm
127            .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
128            .await?;
129
130        Ok(())
131    }
132
133    async fn init_with_message_and_cause(
134        jvm: &Jvm,
135        _: &mut RuntimeContext,
136        mut this: ClassInstanceRef<Self>,
137        message: ClassInstanceRef<String>,
138        cause: ClassInstanceRef<Self>,
139    ) -> Result<()> {
140        tracing::debug!("java.lang.Throwable::<init>({this:?}, {message:?}, {cause:?})");
141
142        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
143
144        jvm.put_field(&mut this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;", message)
145            .await?;
146        jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause)
147            .await?;
148
149        let _: ClassInstanceRef<Self> = jvm
150            .invoke_virtual(&this, "java/lang/Throwable", "fillInStackTrace", "()Ljava/lang/Throwable;", ())
151            .await?;
152
153        Ok(())
154    }
155
156    async fn get_cause(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
157        tracing::debug!("java.lang.Throwable::getCause({this:?})");
158
159        jvm.get_field(&this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;").await
160    }
161
162    async fn get_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
163        tracing::debug!("java.lang.Throwable::getMessage({this:?})");
164
165        jvm.get_field(&this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;").await
166    }
167
168    async fn get_localized_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
169        tracing::debug!("java.lang.Throwable::getLocalizedMessage({this:?})");
170
171        jvm.invoke_virtual(&this, "java/lang/Throwable", "getMessage", "()Ljava/lang/String;", ())
172            .await
173    }
174
175    async fn init_cause(
176        jvm: &Jvm,
177        _: &mut RuntimeContext,
178        mut this: ClassInstanceRef<Self>,
179        cause: ClassInstanceRef<Self>,
180    ) -> Result<ClassInstanceRef<Self>> {
181        tracing::debug!("java.lang.Throwable::initCause({this:?}, {cause:?})");
182
183        jvm.put_field(&mut this, "java/lang/Throwable", "cause", "Ljava/lang/Throwable;", cause)
184            .await?;
185
186        Ok(this)
187    }
188
189    async fn fill_in_stack_trace(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
190        tracing::debug!("java.lang.Throwable::fillInStackTrace({this:?})");
191
192        let stack_trace = jvm.stack_trace();
193        let mut stack_trace_array = jvm.instantiate_array("Ljava/lang/String;", stack_trace.len()).await?;
194        for (i, line) in stack_trace.iter().enumerate() {
195            let java_line = JavaLangString::from_rust_string(jvm, line).await?;
196            jvm.store_array(&mut stack_trace_array, i, core::iter::once(java_line)).await?;
197        }
198        jvm.put_field(&mut this, "java/lang/Throwable", "stackTrace", "[Ljava/lang/String;", stack_trace_array)
199            .await?;
200
201        Ok(this)
202    }
203
204    async fn print_stack_trace(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
205        tracing::debug!("java.lang.Throwable::printStackTrace({this:?})");
206
207        let err: ClassInstanceRef<PrintStream> = jvm.get_static_field("java/lang/System", "err", "Ljava/io/PrintStream;").await?;
208
209        let _: () = jvm
210            .invoke_virtual(&this, "java/lang/Throwable", "printStackTrace", "(Ljava/io/PrintStream;)V", (err,))
211            .await?;
212
213        Ok(())
214    }
215
216    async fn print_stack_trace_to_print_stream(
217        jvm: &Jvm,
218        _: &mut RuntimeContext,
219        this: ClassInstanceRef<Self>,
220        stream: ClassInstanceRef<PrintStream>,
221    ) -> Result<()> {
222        tracing::debug!("java.lang.Throwable::printStackTrace({this:?}, {stream:?})");
223
224        Self::do_print_stack_trace(jvm, this, stream.into()).await?;
225
226        Ok(())
227    }
228
229    async fn print_stack_trace_to_print_writer(
230        jvm: &Jvm,
231        _: &mut RuntimeContext,
232        this: ClassInstanceRef<Self>,
233        writer: ClassInstanceRef<PrintWriter>,
234    ) -> Result<()> {
235        tracing::debug!("java.lang.Throwable::printStackTrace({this:?}, {writer:?})");
236
237        Self::do_print_stack_trace(jvm, this, writer.into()).await?;
238
239        Ok(())
240    }
241
242    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
243        tracing::debug!("java.lang.Throwable::toString({this:?})");
244
245        let class = jvm
246            .invoke_virtual(&this, "java/lang/Object", "getClass", "()Ljava/lang/Class;", ())
247            .await?;
248        let class_name = jvm
249            .invoke_virtual(&class, "java/lang/Class", "getName", "()Ljava/lang/String;", ())
250            .await?;
251
252        let message: ClassInstanceRef<String> = jvm.get_field(&this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;").await?;
253
254        let class_name = JavaLangString::to_rust_string(jvm, &class_name).await?;
255        let message = if message.is_null() {
256            class_name
257        } else {
258            let message = JavaLangString::to_rust_string(jvm, &message).await?;
259            if message.is_empty() {
260                class_name
261            } else {
262                format!("{class_name}: {message}")
263            }
264        };
265
266        let message = JavaLangString::from_rust_string(jvm, &message).await?;
267
268        Ok(message.into())
269    }
270
271    async fn do_print_stack_trace(jvm: &Jvm, this: ClassInstanceRef<Self>, stream_or_writer: Box<dyn ClassInstance>) -> Result<()> {
272        let mut current: ClassInstanceRef<Self> = this;
273        let mut header: Option<&str> = None;
274
275        // a malformed initCause could create a cycle, so cap the depth
276        for _ in 0..32 {
277            let string: ClassInstanceRef<String> = jvm
278                .invoke_virtual(&current, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
279                .await?;
280            let prefix: ClassInstanceRef<String> = match header {
281                Some(x) => {
282                    let string = JavaLangString::to_rust_string(jvm, &string).await?;
283                    JavaLangString::from_rust_string(jvm, &format!("{x}{string}")).await?.into()
284                }
285                None => string,
286            };
287            let _: () = jvm
288                .invoke_virtual(
289                    &stream_or_writer,
290                    &stream_or_writer.class_definition().name(),
291                    "println",
292                    "(Ljava/lang/String;)V",
293                    (prefix,),
294                )
295                .await?;
296
297            let stack_trace: ClassInstanceRef<Array<ClassInstanceRef<String>>> = jvm
298                .get_field(&current, "java/lang/Throwable", "stackTrace", "[Ljava/lang/String;")
299                .await?;
300            if !stack_trace.is_null() {
301                let length = jvm.array_length(&stack_trace).await?;
302                let lines: Vec<ClassInstanceRef<String>> = jvm.load_array(&stack_trace, 0, length).await?;
303                for line_ref in lines {
304                    let line = JavaLangString::to_rust_string(jvm, &line_ref).await?;
305                    let line = format!("\tat {line}");
306                    let line = JavaLangString::from_rust_string(jvm, &line).await?;
307                    let _: () = jvm
308                        .invoke_virtual(
309                            &stream_or_writer,
310                            &stream_or_writer.class_definition().name(),
311                            "println",
312                            "(Ljava/lang/String;)V",
313                            (line,),
314                        )
315                        .await?;
316                }
317            }
318
319            let cause: ClassInstanceRef<Self> = jvm
320                .invoke_virtual(&current, "java/lang/Throwable", "getCause", "()Ljava/lang/Throwable;", ())
321                .await?;
322            if cause.is_null() {
323                break;
324            }
325            current = cause;
326            header = Some("Caused by: ");
327        }
328
329        Ok(())
330    }
331}