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
15pub 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 if stream.is_null() {
225 return Err(jvm.exception("java/lang/NullPointerException", "stream is null").await);
226 }
227
228 Self::do_print_stack_trace(jvm, this, stream.into()).await?;
229
230 Ok(())
231 }
232
233 async fn print_stack_trace_to_print_writer(
234 jvm: &Jvm,
235 _: &mut RuntimeContext,
236 this: ClassInstanceRef<Self>,
237 writer: ClassInstanceRef<PrintWriter>,
238 ) -> Result<()> {
239 tracing::debug!("java.lang.Throwable::printStackTrace({this:?}, {writer:?})");
240
241 if writer.is_null() {
242 return Err(jvm.exception("java/lang/NullPointerException", "writer is null").await);
243 }
244
245 Self::do_print_stack_trace(jvm, this, writer.into()).await?;
246
247 Ok(())
248 }
249
250 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
251 tracing::debug!("java.lang.Throwable::toString({this:?})");
252
253 let class = jvm
254 .invoke_virtual(&this, "java/lang/Object", "getClass", "()Ljava/lang/Class;", ())
255 .await?;
256 let class_name = jvm
257 .invoke_virtual(&class, "java/lang/Class", "getName", "()Ljava/lang/String;", ())
258 .await?;
259
260 let message: ClassInstanceRef<String> = jvm.get_field(&this, "java/lang/Throwable", "detailMessage", "Ljava/lang/String;").await?;
261
262 let class_name = JavaLangString::to_rust_string(jvm, &class_name).await?;
263 let message = if message.is_null() {
264 class_name
265 } else {
266 let message = JavaLangString::to_rust_string(jvm, &message).await?;
267 if message.is_empty() {
268 class_name
269 } else {
270 format!("{class_name}: {message}")
271 }
272 };
273
274 let message = JavaLangString::from_rust_string(jvm, &message).await?;
275
276 Ok(message.into())
277 }
278
279 async fn do_print_stack_trace(jvm: &Jvm, this: ClassInstanceRef<Self>, stream_or_writer: Box<dyn ClassInstance>) -> Result<()> {
280 let mut current: ClassInstanceRef<Self> = this;
281 let mut header: Option<&str> = None;
282
283 for _ in 0..32 {
285 let string: ClassInstanceRef<String> = jvm
286 .invoke_virtual(¤t, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
287 .await?;
288 let prefix: ClassInstanceRef<String> = match header {
289 Some(x) => {
290 let string = JavaLangString::to_rust_string(jvm, &string).await?;
291 JavaLangString::from_rust_string(jvm, &format!("{x}{string}")).await?.into()
292 }
293 None => string,
294 };
295 let _: () = jvm
296 .invoke_virtual(
297 &stream_or_writer,
298 &stream_or_writer.class_definition().name(),
299 "println",
300 "(Ljava/lang/String;)V",
301 (prefix,),
302 )
303 .await?;
304
305 let stack_trace: ClassInstanceRef<Array<ClassInstanceRef<String>>> = jvm
306 .get_field(¤t, "java/lang/Throwable", "stackTrace", "[Ljava/lang/String;")
307 .await?;
308 if !stack_trace.is_null() {
309 let length = jvm.array_length(&stack_trace).await?;
310 let lines: Vec<ClassInstanceRef<String>> = jvm.load_array(&stack_trace, 0, length).await?;
311 for line_ref in lines {
312 let line = JavaLangString::to_rust_string(jvm, &line_ref).await?;
313 let line = format!("\tat {line}");
314 let line = JavaLangString::from_rust_string(jvm, &line).await?;
315 let _: () = jvm
316 .invoke_virtual(
317 &stream_or_writer,
318 &stream_or_writer.class_definition().name(),
319 "println",
320 "(Ljava/lang/String;)V",
321 (line,),
322 )
323 .await?;
324 }
325 }
326
327 let cause: ClassInstanceRef<Self> = jvm
328 .invoke_virtual(¤t, "java/lang/Throwable", "getCause", "()Ljava/lang/Throwable;", ())
329 .await?;
330 if cause.is_null() {
331 break;
332 }
333 current = cause;
334 header = Some("Caused by: ");
335 }
336
337 Ok(())
338 }
339}