1use core::future::Future;
2
3use alloc::{vec, vec::Vec};
4
5use jvm::{Array, ClassInstanceRef, JavaChar, JavaError, Jvm, Result, runtime::JavaLangString};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10 RuntimeClassProto, RuntimeContext,
11 classes::java::{
12 io::{File, OutputStream, OutputStreamWriter},
13 lang::{Appendable, CharSequence, Object, String},
14 util::{Formatter, Locale, Properties},
15 },
16};
17
18pub struct PrintStream;
20
21impl PrintStream {
22 pub fn as_proto() -> RuntimeClassProto {
23 RuntimeClassProto {
24 name: "java/io/PrintStream",
25 parent_class: Some("java/io/FilterOutputStream"),
26 interfaces: vec!["java/lang/Appendable", "java/io/Closeable"],
27 methods: vec![
28 JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
29 JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;Z)V", Self::init_auto_flush, MethodAccessFlags::PUBLIC),
30 JavaMethodProto::new(
31 "<init>",
32 "(Ljava/io/OutputStream;ZLjava/lang/String;)V",
33 Self::init_auto_flush_encoding,
34 MethodAccessFlags::PUBLIC,
35 ),
36 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_path, MethodAccessFlags::PUBLIC),
37 JavaMethodProto::new(
38 "<init>",
39 "(Ljava/lang/String;Ljava/lang/String;)V",
40 Self::init_path_encoding,
41 MethodAccessFlags::PUBLIC,
42 ),
43 JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init_file, MethodAccessFlags::PUBLIC),
44 JavaMethodProto::new(
45 "<init>",
46 "(Ljava/io/File;Ljava/lang/String;)V",
47 Self::init_file_encoding,
48 MethodAccessFlags::PUBLIC,
49 ),
50 JavaMethodProto::new("checkError", "()Z", Self::check_error, MethodAccessFlags::PUBLIC),
51 JavaMethodProto::new("setError", "()V", Self::set_error, MethodAccessFlags::PROTECTED),
52 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
53 JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
54 JavaMethodProto::new("write", "(I)V", Self::write_byte, MethodAccessFlags::PUBLIC),
55 JavaMethodProto::new("write", "([BII)V", Self::write_bytes, MethodAccessFlags::PUBLIC),
56 JavaMethodProto::new("print", "(Ljava/lang/Object;)V", Self::print_object, MethodAccessFlags::PUBLIC),
57 JavaMethodProto::new("print", "(Ljava/lang/String;)V", Self::print_string, MethodAccessFlags::PUBLIC),
58 JavaMethodProto::new("print", "(I)V", Self::print_int, MethodAccessFlags::PUBLIC),
59 JavaMethodProto::new("print", "(J)V", Self::print_long, MethodAccessFlags::PUBLIC),
60 JavaMethodProto::new("print", "(C)V", Self::print_char, MethodAccessFlags::PUBLIC),
61 JavaMethodProto::new("print", "([C)V", Self::print_chars, MethodAccessFlags::PUBLIC),
62 JavaMethodProto::new("print", "(Z)V", Self::print_bool, MethodAccessFlags::PUBLIC),
63 JavaMethodProto::new("print", "(F)V", Self::print_float, MethodAccessFlags::PUBLIC),
64 JavaMethodProto::new("print", "(D)V", Self::print_double, MethodAccessFlags::PUBLIC),
65 JavaMethodProto::new("println", "()V", Self::println, MethodAccessFlags::PUBLIC),
66 JavaMethodProto::new("println", "(Ljava/lang/Object;)V", Self::println_object, MethodAccessFlags::PUBLIC),
67 JavaMethodProto::new("println", "(Ljava/lang/String;)V", Self::println_string, MethodAccessFlags::PUBLIC),
68 JavaMethodProto::new("println", "(I)V", Self::println_int, MethodAccessFlags::PUBLIC),
69 JavaMethodProto::new("println", "(J)V", Self::println_long, MethodAccessFlags::PUBLIC),
70 JavaMethodProto::new("println", "(C)V", Self::println_char, MethodAccessFlags::PUBLIC),
71 JavaMethodProto::new("println", "([C)V", Self::println_chars, MethodAccessFlags::PUBLIC),
72 JavaMethodProto::new("println", "(Z)V", Self::println_bool, MethodAccessFlags::PUBLIC),
73 JavaMethodProto::new("println", "(F)V", Self::println_float, MethodAccessFlags::PUBLIC),
74 JavaMethodProto::new("println", "(D)V", Self::println_double, MethodAccessFlags::PUBLIC),
75 JavaMethodProto::new(
76 "printf",
77 "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
78 Self::printf,
79 MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
80 ),
81 JavaMethodProto::new(
82 "printf",
83 "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
84 Self::printf_with_locale,
85 MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
86 ),
87 JavaMethodProto::new(
88 "format",
89 "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
90 Self::format,
91 MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
92 ),
93 JavaMethodProto::new(
94 "format",
95 "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
96 Self::format_with_locale,
97 MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
98 ),
99 JavaMethodProto::new(
100 "append",
101 "(Ljava/lang/CharSequence;)Ljava/io/PrintStream;",
102 Self::append_char_sequence,
103 MethodAccessFlags::PUBLIC,
104 ),
105 JavaMethodProto::new(
106 "append",
107 "(Ljava/lang/CharSequence;II)Ljava/io/PrintStream;",
108 Self::append_char_sequence_range,
109 MethodAccessFlags::PUBLIC,
110 ),
111 JavaMethodProto::new("append", "(C)Ljava/io/PrintStream;", Self::append_char, MethodAccessFlags::PUBLIC),
112 JavaMethodProto::new(
113 "append",
114 "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
115 Self::append_char_sequence,
116 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
117 ),
118 JavaMethodProto::new(
119 "append",
120 "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
121 Self::append_char_sequence_range,
122 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
123 ),
124 JavaMethodProto::new(
125 "append",
126 "(C)Ljava/lang/Appendable;",
127 Self::append_char,
128 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
129 ),
130 ],
131 fields: vec![
132 JavaFieldProto::new("autoFlush", "Z", FieldAccessFlags::PRIVATE),
133 JavaFieldProto::new("trouble", "Z", FieldAccessFlags::PRIVATE),
134 JavaFieldProto::new("charOut", "Ljava/io/OutputStreamWriter;", FieldAccessFlags::PRIVATE),
135 JavaFieldProto::new("closing", "Z", FieldAccessFlags::PRIVATE),
136 ],
137 access_flags: ClassAccessFlags::PUBLIC,
138 }
139 }
140
141 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, out: ClassInstanceRef<OutputStream>) -> Result<()> {
142 tracing::debug!("java.io.PrintStream::<init>({this:?}, {out:?})");
143 jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/OutputStream;Z)V", (out, false))
144 .await
145 }
146
147 async fn init_auto_flush(
148 jvm: &Jvm,
149 _: &mut RuntimeContext,
150 this: ClassInstanceRef<Self>,
151 out: ClassInstanceRef<OutputStream>,
152 auto_flush: bool,
153 ) -> Result<()> {
154 tracing::debug!("java.io.PrintStream::<init>({this:?}, {out:?}, {auto_flush})");
155
156 let props: ClassInstanceRef<Properties> = jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await?;
157 let encoding: ClassInstanceRef<String> = if props.is_null() {
158 JavaLangString::from_rust_string(jvm, "UTF-8").await?.into()
159 } else {
160 let key = JavaLangString::from_rust_string(jvm, "file.encoding").await?;
161 let encoding: ClassInstanceRef<String> = jvm
162 .invoke_virtual(
163 &props,
164 "java/util/Properties",
165 "getProperty",
166 "(Ljava/lang/String;)Ljava/lang/String;",
167 (key,),
168 )
169 .await?;
170 if encoding.is_null() {
171 JavaLangString::from_rust_string(jvm, "UTF-8").await?.into()
172 } else {
173 encoding
174 }
175 };
176 jvm.invoke_special(
177 &this,
178 "java/io/PrintStream",
179 "<init>",
180 "(Ljava/io/OutputStream;ZLjava/lang/String;)V",
181 (out, auto_flush, encoding),
182 )
183 .await
184 }
185
186 async fn init_auto_flush_encoding(
187 jvm: &Jvm,
188 _: &mut RuntimeContext,
189 mut this: ClassInstanceRef<Self>,
190 out: ClassInstanceRef<OutputStream>,
191 auto_flush: bool,
192 encoding: ClassInstanceRef<String>,
193 ) -> Result<()> {
194 if out.is_null() {
195 return Err(jvm.exception("java/lang/NullPointerException", "output is null").await);
196 }
197 OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
198
199 let _: () = jvm
200 .invoke_special(&this, "java/io/FilterOutputStream", "<init>", "(Ljava/io/OutputStream;)V", (out.clone(),))
201 .await?;
202 let this_output: ClassInstanceRef<OutputStream> = this.instance.clone().into();
203 let char_out = jvm
204 .new_class(
205 "java/io/OutputStreamWriter",
206 "(Ljava/io/OutputStream;Ljava/lang/String;)V",
207 (this_output, encoding),
208 )
209 .await?;
210 jvm.put_field(&mut this, "java/io/PrintStream", "autoFlush", "Z", auto_flush).await?;
211 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", false).await?;
212 jvm.put_field(&mut this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;", char_out)
213 .await?;
214 jvm.put_field(&mut this, "java/io/PrintStream", "closing", "Z", false).await
215 }
216
217 async fn init_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, path: ClassInstanceRef<String>) -> Result<()> {
218 if path.is_null() {
219 return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
220 }
221 let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
222 jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/File;)V", (file,))
223 .await
224 }
225
226 async fn init_path_encoding(
227 jvm: &Jvm,
228 _: &mut RuntimeContext,
229 this: ClassInstanceRef<Self>,
230 path: ClassInstanceRef<String>,
231 encoding: ClassInstanceRef<String>,
232 ) -> Result<()> {
233 if path.is_null() {
234 return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
235 }
236 OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
237 let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
238 jvm.invoke_special(
239 &this,
240 "java/io/PrintStream",
241 "<init>",
242 "(Ljava/io/File;Ljava/lang/String;)V",
243 (file, encoding),
244 )
245 .await
246 }
247
248 async fn init_file(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
249 if file.is_null() {
250 return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
251 }
252 let output: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
253 jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/OutputStream;)V", (output,))
254 .await
255 }
256
257 async fn init_file_encoding(
258 jvm: &Jvm,
259 _: &mut RuntimeContext,
260 this: ClassInstanceRef<Self>,
261 file: ClassInstanceRef<File>,
262 encoding: ClassInstanceRef<String>,
263 ) -> Result<()> {
264 if file.is_null() {
265 return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
266 }
267 OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
268 let output: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
269 jvm.invoke_special(
270 &this,
271 "java/io/PrintStream",
272 "<init>",
273 "(Ljava/io/OutputStream;ZLjava/lang/String;)V",
274 (output, false, encoding),
275 )
276 .await
277 }
278
279 async fn with_monitor<T, F>(jvm: &Jvm, this: &ClassInstanceRef<Self>, operation: F) -> Result<T>
280 where
281 F: Future<Output = Result<T>>,
282 {
283 jvm.monitor_enter(this).await?;
284 match operation.await {
285 Ok(value) => {
286 jvm.monitor_exit(this).await?;
287 Ok(value)
288 }
289 Err(error) => {
290 if let Err(exit_error) = jvm.monitor_exit(this).await {
291 tracing::error!(?exit_error, "failed to release PrintStream monitor");
292 }
293 Err(error)
294 }
295 }
296 }
297
298 async fn check_error(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
299 tracing::debug!("java.io.PrintStream::checkError({this:?})");
300
301 Self::with_monitor(jvm, &this, async {
302 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
303 if !out.is_null() {
304 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "flush", "()V", ()).await?;
305 if jvm.is_instance(&**out, "java/io/PrintStream") {
306 return jvm.invoke_virtual(&out, "java/io/PrintStream", "checkError", "()Z", ()).await;
307 }
308 }
309 jvm.get_field(&this, "java/io/PrintStream", "trouble", "Z").await
310 })
311 .await
312 }
313
314 async fn set_error(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
315 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await
316 }
317
318 async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
319 tracing::debug!("java.io.PrintStream::close({this:?})");
320
321 Self::with_monitor(jvm, &this, async {
322 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
323 if out.is_null() || jvm.get_field::<bool>(&this, "java/io/PrintStream", "closing", "Z").await? {
324 return Ok(());
325 }
326
327 let mut this = this.clone();
328 jvm.put_field(&mut this, "java/io/PrintStream", "closing", "Z", true).await?;
329 let char_out: ClassInstanceRef<OutputStreamWriter> = jvm
330 .get_field(&this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;")
331 .await?;
332 let char_out_result = jvm.invoke_virtual(&char_out, "java/io/OutputStreamWriter", "close", "()V", ()).await;
333 let close_out = match char_out_result {
334 Ok(()) => true,
335 Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
336 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
337 false
338 }
339 Err(error) => return Err(error),
340 };
341
342 if close_out {
343 match jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await {
344 Ok(()) => {}
345 Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
346 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
347 }
348 Err(error) => return Err(error),
349 }
350 }
351
352 let closed_output: ClassInstanceRef<OutputStream> = None.into();
353 let closed_writer: ClassInstanceRef<OutputStreamWriter> = None.into();
354 jvm.put_field(&mut this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;", closed_writer)
355 .await?;
356 jvm.put_field(&mut this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;", closed_output)
357 .await
358 })
359 .await
360 }
361
362 async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
363 tracing::debug!("java.io.PrintStream::flush({this:?})");
364
365 Self::with_monitor(jvm, &this, async {
366 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
367 if out.is_null() {
368 let mut this = this.clone();
369 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
370 return Ok(());
371 }
372
373 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
374 Self::suppress_io_exception(jvm, &this, result).await.map(|_| ())
375 })
376 .await
377 }
378
379 async fn write_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
380 tracing::debug!("java.io.PrintStream::write({this:?}, {value})");
381
382 Self::with_monitor(jvm, &this, async {
383 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
384 if out.is_null() {
385 let mut this = this.clone();
386 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
387 return Ok(());
388 }
389
390 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (value,)).await;
391 if Self::suppress_io_exception(jvm, &this, result).await?
392 && value == b'\n' as i32
393 && jvm.get_field::<bool>(&this, "java/io/PrintStream", "autoFlush", "Z").await?
394 {
395 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
396 Self::suppress_io_exception(jvm, &this, result).await?;
397 }
398 Ok(())
399 })
400 .await
401 }
402
403 async fn write_bytes(
404 jvm: &Jvm,
405 _: &mut RuntimeContext,
406 this: ClassInstanceRef<Self>,
407 bytes: ClassInstanceRef<Array<i8>>,
408 off: i32,
409 len: i32,
410 ) -> Result<()> {
411 tracing::debug!("java.io.PrintStream::write({this:?}, {bytes:?}, {off}, {len})");
412
413 Self::with_monitor(jvm, &this, async {
414 if bytes.is_null() {
415 return Err(jvm.exception("java/lang/NullPointerException", "bytes is null").await);
416 }
417 let array_length = jvm.array_length(&bytes).await? as i32;
418 if off < 0 || len < 0 || off > array_length - len {
419 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid offset or length").await);
420 }
421
422 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
423 if out.is_null() {
424 let mut this = this.clone();
425 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
426 return Ok(());
427 }
428
429 let result = jvm
430 .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (bytes, off, len))
431 .await;
432 if Self::suppress_io_exception(jvm, &this, result).await? && jvm.get_field::<bool>(&this, "java/io/PrintStream", "autoFlush", "Z").await?
433 {
434 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
435 Self::suppress_io_exception(jvm, &this, result).await?;
436 }
437 Ok(())
438 })
439 .await
440 }
441
442 async fn print_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<()> {
443 tracing::debug!("java.io.PrintStream::print({this:?}, {value:?})");
444 let value: ClassInstanceRef<String> = jvm
445 .invoke_static("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;", (value,))
446 .await?;
447 Self::write_string(jvm, &this, value).await
448 }
449
450 async fn print_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
451 tracing::debug!("java.io.PrintStream::print({this:?}, {value:?})");
452 let value = if value.is_null() {
453 JavaLangString::from_rust_string(jvm, "null").await?.into()
454 } else {
455 value
456 };
457 Self::write_string(jvm, &this, value).await
458 }
459
460 async fn print_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
461 let value: ClassInstanceRef<String> = jvm
462 .invoke_static("java/lang/String", "valueOf", "(I)Ljava/lang/String;", (value,))
463 .await?;
464 Self::write_string(jvm, &this, value).await
465 }
466
467 async fn print_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
468 let value: ClassInstanceRef<String> = jvm
469 .invoke_static("java/lang/String", "valueOf", "(J)Ljava/lang/String;", (value,))
470 .await?;
471 Self::write_string(jvm, &this, value).await
472 }
473
474 async fn print_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
475 let mut chars = jvm.instantiate_array("C", 1).await?;
476 jvm.store_array(&mut chars, 0, [value]).await?;
477 Self::write_characters(jvm, &this, chars.into()).await
478 }
479
480 async fn print_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
481 Self::write_characters(jvm, &this, value).await
482 }
483
484 async fn print_bool(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
485 let value: ClassInstanceRef<String> = jvm
486 .invoke_static("java/lang/String", "valueOf", "(Z)Ljava/lang/String;", (value,))
487 .await?;
488 Self::write_string(jvm, &this, value).await
489 }
490
491 async fn print_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
492 let value: ClassInstanceRef<String> = jvm
493 .invoke_static("java/lang/String", "valueOf", "(F)Ljava/lang/String;", (value,))
494 .await?;
495 Self::write_string(jvm, &this, value).await
496 }
497
498 async fn print_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
499 let value: ClassInstanceRef<String> = jvm
500 .invoke_static("java/lang/String", "valueOf", "(D)Ljava/lang/String;", (value,))
501 .await?;
502 Self::write_string(jvm, &this, value).await
503 }
504
505 async fn println(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
506 Self::new_line(jvm, &this).await
507 }
508
509 async fn println_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<()> {
510 let value: ClassInstanceRef<String> = jvm
511 .invoke_static("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;", (value,))
512 .await?;
513 Self::with_monitor(jvm, &this, async {
514 let _: () = jvm
515 .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,))
516 .await?;
517 Self::new_line(jvm, &this).await
518 })
519 .await
520 }
521
522 async fn println_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
523 Self::with_monitor(jvm, &this, async {
524 let _: () = jvm
525 .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,))
526 .await?;
527 Self::new_line(jvm, &this).await
528 })
529 .await
530 }
531
532 async fn println_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
533 Self::with_monitor(jvm, &this, async {
534 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(I)V", (value,)).await?;
535 Self::new_line(jvm, &this).await
536 })
537 .await
538 }
539
540 async fn println_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
541 Self::with_monitor(jvm, &this, async {
542 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(J)V", (value,)).await?;
543 Self::new_line(jvm, &this).await
544 })
545 .await
546 }
547
548 async fn println_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
549 Self::with_monitor(jvm, &this, async {
550 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(C)V", (value,)).await?;
551 Self::new_line(jvm, &this).await
552 })
553 .await
554 }
555
556 async fn println_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
557 Self::with_monitor(jvm, &this, async {
558 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "([C)V", (value,)).await?;
559 Self::new_line(jvm, &this).await
560 })
561 .await
562 }
563
564 async fn println_bool(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
565 Self::with_monitor(jvm, &this, async {
566 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(Z)V", (value,)).await?;
567 Self::new_line(jvm, &this).await
568 })
569 .await
570 }
571
572 async fn println_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
573 Self::with_monitor(jvm, &this, async {
574 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(F)V", (value,)).await?;
575 Self::new_line(jvm, &this).await
576 })
577 .await
578 }
579
580 async fn println_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
581 Self::with_monitor(jvm, &this, async {
582 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(D)V", (value,)).await?;
583 Self::new_line(jvm, &this).await
584 })
585 .await
586 }
587
588 async fn printf(
589 jvm: &Jvm,
590 _: &mut RuntimeContext,
591 this: ClassInstanceRef<Self>,
592 format: ClassInstanceRef<String>,
593 arguments: ClassInstanceRef<Array<Object>>,
594 ) -> Result<ClassInstanceRef<Self>> {
595 jvm.invoke_virtual(
596 &this,
597 "java/io/PrintStream",
598 "format",
599 "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
600 (format, arguments),
601 )
602 .await
603 }
604
605 async fn printf_with_locale(
606 jvm: &Jvm,
607 _: &mut RuntimeContext,
608 this: ClassInstanceRef<Self>,
609 locale: ClassInstanceRef<Locale>,
610 format: ClassInstanceRef<String>,
611 arguments: ClassInstanceRef<Array<Object>>,
612 ) -> Result<ClassInstanceRef<Self>> {
613 jvm.invoke_virtual(
614 &this,
615 "java/io/PrintStream",
616 "format",
617 "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
618 (locale, format, arguments),
619 )
620 .await
621 }
622
623 async fn format(
624 jvm: &Jvm,
625 _: &mut RuntimeContext,
626 this: ClassInstanceRef<Self>,
627 format: ClassInstanceRef<String>,
628 arguments: ClassInstanceRef<Array<Object>>,
629 ) -> Result<ClassInstanceRef<Self>> {
630 let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
631 jvm.invoke_virtual(
632 &this,
633 "java/io/PrintStream",
634 "format",
635 "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
636 (locale, format, arguments),
637 )
638 .await
639 }
640
641 async fn format_with_locale(
642 jvm: &Jvm,
643 _: &mut RuntimeContext,
644 this: ClassInstanceRef<Self>,
645 locale: ClassInstanceRef<Locale>,
646 format: ClassInstanceRef<String>,
647 arguments: ClassInstanceRef<Array<Object>>,
648 ) -> Result<ClassInstanceRef<Self>> {
649 Self::with_monitor(jvm, &this, async {
650 let appendable: ClassInstanceRef<Appendable> = this.instance.clone().into();
651 let formatter: ClassInstanceRef<Formatter> = jvm
652 .new_class("java/util/Formatter", "(Ljava/lang/Appendable;Ljava/util/Locale;)V", (appendable, locale))
653 .await?
654 .into();
655 let _: ClassInstanceRef<Formatter> = jvm
656 .invoke_virtual(
657 &formatter,
658 "java/util/Formatter",
659 "format",
660 "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
661 (format, arguments),
662 )
663 .await?;
664 Ok(this.clone())
665 })
666 .await
667 }
668
669 async fn append_char_sequence(
670 jvm: &Jvm,
671 _: &mut RuntimeContext,
672 this: ClassInstanceRef<Self>,
673 sequence: ClassInstanceRef<CharSequence>,
674 ) -> Result<ClassInstanceRef<Self>> {
675 let string: ClassInstanceRef<String> = if sequence.is_null() {
676 JavaLangString::from_rust_string(jvm, "null").await?.into()
677 } else {
678 jvm.invoke_virtual(&sequence, &sequence.class_definition().name(), "toString", "()Ljava/lang/String;", ())
679 .await?
680 };
681 let _: () = jvm
682 .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (string,))
683 .await?;
684 Ok(this)
685 }
686
687 async fn append_char_sequence_range(
688 jvm: &Jvm,
689 _: &mut RuntimeContext,
690 this: ClassInstanceRef<Self>,
691 sequence: ClassInstanceRef<CharSequence>,
692 start: i32,
693 end: i32,
694 ) -> Result<ClassInstanceRef<Self>> {
695 let sequence: ClassInstanceRef<CharSequence> = if sequence.is_null() {
696 JavaLangString::from_rust_string(jvm, "null").await?.into()
697 } else {
698 sequence
699 };
700 let subsequence: ClassInstanceRef<CharSequence> = jvm
701 .invoke_virtual(
702 &sequence,
703 &sequence.class_definition().name(),
704 "subSequence",
705 "(II)Ljava/lang/CharSequence;",
706 (start, end),
707 )
708 .await?;
709 let string: ClassInstanceRef<String> = jvm
710 .invoke_virtual(
711 &subsequence,
712 &subsequence.class_definition().name(),
713 "toString",
714 "()Ljava/lang/String;",
715 (),
716 )
717 .await?;
718 let _: () = jvm
719 .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (string,))
720 .await?;
721 Ok(this)
722 }
723
724 async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, character: JavaChar) -> Result<ClassInstanceRef<Self>> {
725 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(C)V", (character,)).await?;
726 Ok(this)
727 }
728
729 async fn write_string(jvm: &Jvm, this: &ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
730 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&value, "java/lang/String", "toCharArray", "()[C", ()).await?;
731 Self::write_characters(jvm, this, chars).await
732 }
733
734 async fn write_characters(jvm: &Jvm, this: &ClassInstanceRef<Self>, chars: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
735 Self::with_monitor(jvm, this, async {
736 if chars.is_null() {
737 return Err(jvm.exception("java/lang/NullPointerException", "chars is null").await);
738 }
739
740 let out: ClassInstanceRef<OutputStream> = jvm.get_field(this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
741 if out.is_null() {
742 let mut this = this.clone();
743 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
744 return Ok(());
745 }
746
747 let length = jvm.array_length(&chars).await?;
748 let values: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
749 let char_out: ClassInstanceRef<OutputStreamWriter> = jvm
750 .get_field(this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;")
751 .await?;
752 let result = jvm
753 .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32))
754 .await;
755 if !Self::suppress_io_exception(jvm, this, result).await? {
756 return Ok(());
757 }
758
759 if jvm.get_field::<bool>(this, "java/io/PrintStream", "autoFlush", "Z").await? && values.contains(&('\n' as JavaChar)) {
760 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
761 Self::suppress_io_exception(jvm, this, result).await?;
762 }
763 Ok(())
764 })
765 .await
766 }
767
768 async fn new_line(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
769 Self::with_monitor(jvm, this, async {
770 let out: ClassInstanceRef<OutputStream> = jvm.get_field(this, "java/io/PrintStream", "out", "Ljava/io/OutputStream;").await?;
771 if out.is_null() {
772 let mut this = this.clone();
773 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
774 return Ok(());
775 }
776
777 let key = JavaLangString::from_rust_string(jvm, "line.separator").await?;
778 let separator: ClassInstanceRef<String> = jvm
779 .invoke_static("java/lang/System", "getProperty", "(Ljava/lang/String;)Ljava/lang/String;", (key,))
780 .await?;
781 let separator = if separator.is_null() {
782 JavaLangString::from_rust_string(jvm, "\n").await?.into()
783 } else {
784 separator
785 };
786 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&separator, "java/lang/String", "toCharArray", "()[C", ()).await?;
787 let length = jvm.array_length(&chars).await?;
788 let char_out: ClassInstanceRef<OutputStreamWriter> = jvm
789 .get_field(this, "java/io/PrintStream", "charOut", "Ljava/io/OutputStreamWriter;")
790 .await?;
791 let result = jvm
792 .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32))
793 .await;
794 if !Self::suppress_io_exception(jvm, this, result).await? {
795 return Ok(());
796 }
797
798 if jvm.get_field::<bool>(this, "java/io/PrintStream", "autoFlush", "Z").await? {
799 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
800 Self::suppress_io_exception(jvm, this, result).await?;
801 }
802 Ok(())
803 })
804 .await
805 }
806
807 async fn suppress_io_exception(jvm: &Jvm, this: &ClassInstanceRef<Self>, result: Result<()>) -> Result<bool> {
808 match result {
809 Ok(()) => Ok(true),
810 Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
811 let mut this = this.clone();
812 jvm.put_field(&mut this, "java/io/PrintStream", "trouble", "Z", true).await?;
813 Ok(false)
814 }
815 Err(error) => Err(error),
816 }
817 }
818}