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, "autoFlush", "Z", auto_flush).await?;
211 jvm.put_field(&mut this, "trouble", "Z", false).await?;
212 jvm.put_field(&mut this, "charOut", "Ljava/io/OutputStreamWriter;", char_out).await?;
213 jvm.put_field(&mut this, "closing", "Z", false).await
214 }
215
216 async fn init_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, path: ClassInstanceRef<String>) -> Result<()> {
217 if path.is_null() {
218 return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
219 }
220 let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
221 jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/File;)V", (file,))
222 .await
223 }
224
225 async fn init_path_encoding(
226 jvm: &Jvm,
227 _: &mut RuntimeContext,
228 this: ClassInstanceRef<Self>,
229 path: ClassInstanceRef<String>,
230 encoding: ClassInstanceRef<String>,
231 ) -> Result<()> {
232 if path.is_null() {
233 return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
234 }
235 OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
236 let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
237 jvm.invoke_special(
238 &this,
239 "java/io/PrintStream",
240 "<init>",
241 "(Ljava/io/File;Ljava/lang/String;)V",
242 (file, encoding),
243 )
244 .await
245 }
246
247 async fn init_file(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
248 if file.is_null() {
249 return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
250 }
251 let output: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
252 jvm.invoke_special(&this, "java/io/PrintStream", "<init>", "(Ljava/io/OutputStream;)V", (output,))
253 .await
254 }
255
256 async fn init_file_encoding(
257 jvm: &Jvm,
258 _: &mut RuntimeContext,
259 this: ClassInstanceRef<Self>,
260 file: ClassInstanceRef<File>,
261 encoding: ClassInstanceRef<String>,
262 ) -> Result<()> {
263 if file.is_null() {
264 return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
265 }
266 OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
267 let output: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
268 jvm.invoke_special(
269 &this,
270 "java/io/PrintStream",
271 "<init>",
272 "(Ljava/io/OutputStream;ZLjava/lang/String;)V",
273 (output, false, encoding),
274 )
275 .await
276 }
277
278 async fn with_monitor<T, F>(jvm: &Jvm, this: &ClassInstanceRef<Self>, operation: F) -> Result<T>
279 where
280 F: Future<Output = Result<T>>,
281 {
282 jvm.monitor_enter(this).await?;
283 match operation.await {
284 Ok(value) => {
285 jvm.monitor_exit(this).await?;
286 Ok(value)
287 }
288 Err(error) => {
289 if let Err(exit_error) = jvm.monitor_exit(this).await {
290 tracing::error!(?exit_error, "failed to release PrintStream monitor");
291 }
292 Err(error)
293 }
294 }
295 }
296
297 async fn check_error(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
298 tracing::debug!("java.io.PrintStream::checkError({this:?})");
299
300 Self::with_monitor(jvm, &this, async {
301 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
302 if !out.is_null() {
303 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "flush", "()V", ()).await?;
304 if jvm.is_instance(&**out, "java/io/PrintStream") {
305 return jvm.invoke_virtual(&out, "java/io/PrintStream", "checkError", "()Z", ()).await;
306 }
307 }
308 jvm.get_field(&this, "trouble", "Z").await
309 })
310 .await
311 }
312
313 async fn set_error(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
314 jvm.put_field(&mut this, "trouble", "Z", true).await
315 }
316
317 async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
318 tracing::debug!("java.io.PrintStream::close({this:?})");
319
320 Self::with_monitor(jvm, &this, async {
321 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
322 if out.is_null() || jvm.get_field::<bool>(&this, "closing", "Z").await? {
323 return Ok(());
324 }
325
326 let mut this = this.clone();
327 jvm.put_field(&mut this, "closing", "Z", true).await?;
328 let char_out: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "charOut", "Ljava/io/OutputStreamWriter;").await?;
329 let char_out_result = jvm.invoke_virtual(&char_out, "java/io/OutputStreamWriter", "close", "()V", ()).await;
330 let close_out = match char_out_result {
331 Ok(()) => true,
332 Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
333 jvm.put_field(&mut this, "trouble", "Z", true).await?;
334 false
335 }
336 Err(error) => return Err(error),
337 };
338
339 if close_out {
340 match jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await {
341 Ok(()) => {}
342 Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
343 jvm.put_field(&mut this, "trouble", "Z", true).await?;
344 }
345 Err(error) => return Err(error),
346 }
347 }
348
349 let closed_output: ClassInstanceRef<OutputStream> = None.into();
350 let closed_writer: ClassInstanceRef<OutputStreamWriter> = None.into();
351 jvm.put_field(&mut this, "charOut", "Ljava/io/OutputStreamWriter;", closed_writer).await?;
352 jvm.put_field(&mut this, "out", "Ljava/io/OutputStream;", closed_output).await
353 })
354 .await
355 }
356
357 async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
358 tracing::debug!("java.io.PrintStream::flush({this:?})");
359
360 Self::with_monitor(jvm, &this, async {
361 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
362 if out.is_null() {
363 let mut this = this.clone();
364 jvm.put_field(&mut this, "trouble", "Z", true).await?;
365 return Ok(());
366 }
367
368 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
369 Self::suppress_io_exception(jvm, &this, result).await.map(|_| ())
370 })
371 .await
372 }
373
374 async fn write_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
375 tracing::debug!("java.io.PrintStream::write({this:?}, {value})");
376
377 Self::with_monitor(jvm, &this, async {
378 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
379 if out.is_null() {
380 let mut this = this.clone();
381 jvm.put_field(&mut this, "trouble", "Z", true).await?;
382 return Ok(());
383 }
384
385 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (value,)).await;
386 if Self::suppress_io_exception(jvm, &this, result).await?
387 && value == b'\n' as i32
388 && jvm.get_field::<bool>(&this, "autoFlush", "Z").await?
389 {
390 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
391 Self::suppress_io_exception(jvm, &this, result).await?;
392 }
393 Ok(())
394 })
395 .await
396 }
397
398 async fn write_bytes(
399 jvm: &Jvm,
400 _: &mut RuntimeContext,
401 this: ClassInstanceRef<Self>,
402 bytes: ClassInstanceRef<Array<i8>>,
403 off: i32,
404 len: i32,
405 ) -> Result<()> {
406 tracing::debug!("java.io.PrintStream::write({this:?}, {bytes:?}, {off}, {len})");
407
408 Self::with_monitor(jvm, &this, async {
409 if bytes.is_null() {
410 return Err(jvm.exception("java/lang/NullPointerException", "bytes is null").await);
411 }
412 let array_length = jvm.array_length(&bytes).await? as i32;
413 if off < 0 || len < 0 || off > array_length - len {
414 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid offset or length").await);
415 }
416
417 let out: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "out", "Ljava/io/OutputStream;").await?;
418 if out.is_null() {
419 let mut this = this.clone();
420 jvm.put_field(&mut this, "trouble", "Z", true).await?;
421 return Ok(());
422 }
423
424 let result = jvm
425 .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (bytes, off, len))
426 .await;
427 if Self::suppress_io_exception(jvm, &this, result).await? && jvm.get_field::<bool>(&this, "autoFlush", "Z").await? {
428 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
429 Self::suppress_io_exception(jvm, &this, result).await?;
430 }
431 Ok(())
432 })
433 .await
434 }
435
436 async fn print_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<()> {
437 tracing::debug!("java.io.PrintStream::print({this:?}, {value:?})");
438 let value: ClassInstanceRef<String> = jvm
439 .invoke_static("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;", (value,))
440 .await?;
441 Self::write_string(jvm, &this, value).await
442 }
443
444 async fn print_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
445 tracing::debug!("java.io.PrintStream::print({this:?}, {value:?})");
446 let value = if value.is_null() {
447 JavaLangString::from_rust_string(jvm, "null").await?.into()
448 } else {
449 value
450 };
451 Self::write_string(jvm, &this, value).await
452 }
453
454 async fn print_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
455 let value: ClassInstanceRef<String> = jvm
456 .invoke_static("java/lang/String", "valueOf", "(I)Ljava/lang/String;", (value,))
457 .await?;
458 Self::write_string(jvm, &this, value).await
459 }
460
461 async fn print_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
462 let value: ClassInstanceRef<String> = jvm
463 .invoke_static("java/lang/String", "valueOf", "(J)Ljava/lang/String;", (value,))
464 .await?;
465 Self::write_string(jvm, &this, value).await
466 }
467
468 async fn print_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
469 let mut chars = jvm.instantiate_array("C", 1).await?;
470 jvm.store_array(&mut chars, 0, [value]).await?;
471 Self::write_characters(jvm, &this, chars.into()).await
472 }
473
474 async fn print_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
475 Self::write_characters(jvm, &this, value).await
476 }
477
478 async fn print_bool(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
479 let value: ClassInstanceRef<String> = jvm
480 .invoke_static("java/lang/String", "valueOf", "(Z)Ljava/lang/String;", (value,))
481 .await?;
482 Self::write_string(jvm, &this, value).await
483 }
484
485 async fn print_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
486 let value: ClassInstanceRef<String> = jvm
487 .invoke_static("java/lang/String", "valueOf", "(F)Ljava/lang/String;", (value,))
488 .await?;
489 Self::write_string(jvm, &this, value).await
490 }
491
492 async fn print_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
493 let value: ClassInstanceRef<String> = jvm
494 .invoke_static("java/lang/String", "valueOf", "(D)Ljava/lang/String;", (value,))
495 .await?;
496 Self::write_string(jvm, &this, value).await
497 }
498
499 async fn println(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
500 Self::new_line(jvm, &this).await
501 }
502
503 async fn println_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<()> {
504 let value: ClassInstanceRef<String> = jvm
505 .invoke_static("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;", (value,))
506 .await?;
507 Self::with_monitor(jvm, &this, async {
508 let _: () = jvm
509 .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,))
510 .await?;
511 Self::new_line(jvm, &this).await
512 })
513 .await
514 }
515
516 async fn println_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
517 Self::with_monitor(jvm, &this, async {
518 let _: () = jvm
519 .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (value,))
520 .await?;
521 Self::new_line(jvm, &this).await
522 })
523 .await
524 }
525
526 async fn println_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
527 Self::with_monitor(jvm, &this, async {
528 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(I)V", (value,)).await?;
529 Self::new_line(jvm, &this).await
530 })
531 .await
532 }
533
534 async fn println_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
535 Self::with_monitor(jvm, &this, async {
536 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(J)V", (value,)).await?;
537 Self::new_line(jvm, &this).await
538 })
539 .await
540 }
541
542 async fn println_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
543 Self::with_monitor(jvm, &this, async {
544 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(C)V", (value,)).await?;
545 Self::new_line(jvm, &this).await
546 })
547 .await
548 }
549
550 async fn println_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
551 Self::with_monitor(jvm, &this, async {
552 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "([C)V", (value,)).await?;
553 Self::new_line(jvm, &this).await
554 })
555 .await
556 }
557
558 async fn println_bool(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<()> {
559 Self::with_monitor(jvm, &this, async {
560 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(Z)V", (value,)).await?;
561 Self::new_line(jvm, &this).await
562 })
563 .await
564 }
565
566 async fn println_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
567 Self::with_monitor(jvm, &this, async {
568 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(F)V", (value,)).await?;
569 Self::new_line(jvm, &this).await
570 })
571 .await
572 }
573
574 async fn println_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
575 Self::with_monitor(jvm, &this, async {
576 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(D)V", (value,)).await?;
577 Self::new_line(jvm, &this).await
578 })
579 .await
580 }
581
582 async fn printf(
583 jvm: &Jvm,
584 _: &mut RuntimeContext,
585 this: ClassInstanceRef<Self>,
586 format: ClassInstanceRef<String>,
587 arguments: ClassInstanceRef<Array<Object>>,
588 ) -> Result<ClassInstanceRef<Self>> {
589 jvm.invoke_virtual(
590 &this,
591 "java/io/PrintStream",
592 "format",
593 "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
594 (format, arguments),
595 )
596 .await
597 }
598
599 async fn printf_with_locale(
600 jvm: &Jvm,
601 _: &mut RuntimeContext,
602 this: ClassInstanceRef<Self>,
603 locale: ClassInstanceRef<Locale>,
604 format: ClassInstanceRef<String>,
605 arguments: ClassInstanceRef<Array<Object>>,
606 ) -> Result<ClassInstanceRef<Self>> {
607 jvm.invoke_virtual(
608 &this,
609 "java/io/PrintStream",
610 "format",
611 "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
612 (locale, format, arguments),
613 )
614 .await
615 }
616
617 async fn format(
618 jvm: &Jvm,
619 _: &mut RuntimeContext,
620 this: ClassInstanceRef<Self>,
621 format: ClassInstanceRef<String>,
622 arguments: ClassInstanceRef<Array<Object>>,
623 ) -> Result<ClassInstanceRef<Self>> {
624 let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
625 jvm.invoke_virtual(
626 &this,
627 "java/io/PrintStream",
628 "format",
629 "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/io/PrintStream;",
630 (locale, format, arguments),
631 )
632 .await
633 }
634
635 async fn format_with_locale(
636 jvm: &Jvm,
637 _: &mut RuntimeContext,
638 this: ClassInstanceRef<Self>,
639 locale: ClassInstanceRef<Locale>,
640 format: ClassInstanceRef<String>,
641 arguments: ClassInstanceRef<Array<Object>>,
642 ) -> Result<ClassInstanceRef<Self>> {
643 Self::with_monitor(jvm, &this, async {
644 let appendable: ClassInstanceRef<Appendable> = this.instance.clone().into();
645 let formatter: ClassInstanceRef<Formatter> = jvm
646 .new_class("java/util/Formatter", "(Ljava/lang/Appendable;Ljava/util/Locale;)V", (appendable, locale))
647 .await?
648 .into();
649 let _: ClassInstanceRef<Formatter> = jvm
650 .invoke_virtual(
651 &formatter,
652 "java/util/Formatter",
653 "format",
654 "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
655 (format, arguments),
656 )
657 .await?;
658 Ok(this.clone())
659 })
660 .await
661 }
662
663 async fn append_char_sequence(
664 jvm: &Jvm,
665 _: &mut RuntimeContext,
666 this: ClassInstanceRef<Self>,
667 sequence: ClassInstanceRef<CharSequence>,
668 ) -> Result<ClassInstanceRef<Self>> {
669 let string: ClassInstanceRef<String> = if sequence.is_null() {
670 JavaLangString::from_rust_string(jvm, "null").await?.into()
671 } else {
672 jvm.invoke_virtual(&sequence, &sequence.class_definition().name(), "toString", "()Ljava/lang/String;", ())
673 .await?
674 };
675 let _: () = jvm
676 .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (string,))
677 .await?;
678 Ok(this)
679 }
680
681 async fn append_char_sequence_range(
682 jvm: &Jvm,
683 _: &mut RuntimeContext,
684 this: ClassInstanceRef<Self>,
685 sequence: ClassInstanceRef<CharSequence>,
686 start: i32,
687 end: i32,
688 ) -> Result<ClassInstanceRef<Self>> {
689 let sequence: ClassInstanceRef<CharSequence> = if sequence.is_null() {
690 JavaLangString::from_rust_string(jvm, "null").await?.into()
691 } else {
692 sequence
693 };
694 let subsequence: ClassInstanceRef<CharSequence> = jvm
695 .invoke_virtual(
696 &sequence,
697 &sequence.class_definition().name(),
698 "subSequence",
699 "(II)Ljava/lang/CharSequence;",
700 (start, end),
701 )
702 .await?;
703 let string: ClassInstanceRef<String> = jvm
704 .invoke_virtual(
705 &subsequence,
706 &subsequence.class_definition().name(),
707 "toString",
708 "()Ljava/lang/String;",
709 (),
710 )
711 .await?;
712 let _: () = jvm
713 .invoke_virtual(&this, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", (string,))
714 .await?;
715 Ok(this)
716 }
717
718 async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, character: JavaChar) -> Result<ClassInstanceRef<Self>> {
719 let _: () = jvm.invoke_virtual(&this, "java/io/PrintStream", "print", "(C)V", (character,)).await?;
720 Ok(this)
721 }
722
723 async fn write_string(jvm: &Jvm, this: &ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
724 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&value, "java/lang/String", "toCharArray", "()[C", ()).await?;
725 Self::write_characters(jvm, this, chars).await
726 }
727
728 async fn write_characters(jvm: &Jvm, this: &ClassInstanceRef<Self>, chars: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
729 Self::with_monitor(jvm, this, async {
730 if chars.is_null() {
731 return Err(jvm.exception("java/lang/NullPointerException", "chars is null").await);
732 }
733
734 let out: ClassInstanceRef<OutputStream> = jvm.get_field(this, "out", "Ljava/io/OutputStream;").await?;
735 if out.is_null() {
736 let mut this = this.clone();
737 jvm.put_field(&mut this, "trouble", "Z", true).await?;
738 return Ok(());
739 }
740
741 let length = jvm.array_length(&chars).await?;
742 let values: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
743 let char_out: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(this, "charOut", "Ljava/io/OutputStreamWriter;").await?;
744 let result = jvm
745 .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32))
746 .await;
747 if !Self::suppress_io_exception(jvm, this, result).await? {
748 return Ok(());
749 }
750
751 if jvm.get_field::<bool>(this, "autoFlush", "Z").await? && values.contains(&('\n' as JavaChar)) {
752 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
753 Self::suppress_io_exception(jvm, this, result).await?;
754 }
755 Ok(())
756 })
757 .await
758 }
759
760 async fn new_line(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
761 Self::with_monitor(jvm, this, async {
762 let out: ClassInstanceRef<OutputStream> = jvm.get_field(this, "out", "Ljava/io/OutputStream;").await?;
763 if out.is_null() {
764 let mut this = this.clone();
765 jvm.put_field(&mut this, "trouble", "Z", true).await?;
766 return Ok(());
767 }
768
769 let key = JavaLangString::from_rust_string(jvm, "line.separator").await?;
770 let separator: ClassInstanceRef<String> = jvm
771 .invoke_static("java/lang/System", "getProperty", "(Ljava/lang/String;)Ljava/lang/String;", (key,))
772 .await?;
773 let separator = if separator.is_null() {
774 JavaLangString::from_rust_string(jvm, "\n").await?.into()
775 } else {
776 separator
777 };
778 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&separator, "java/lang/String", "toCharArray", "()[C", ()).await?;
779 let length = jvm.array_length(&chars).await?;
780 let char_out: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(this, "charOut", "Ljava/io/OutputStreamWriter;").await?;
781 let result = jvm
782 .invoke_virtual(&char_out, "java/io/OutputStreamWriter", "write", "([CII)V", (chars, 0, length as i32))
783 .await;
784 if !Self::suppress_io_exception(jvm, this, result).await? {
785 return Ok(());
786 }
787
788 if jvm.get_field::<bool>(this, "autoFlush", "Z").await? {
789 let result = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await;
790 Self::suppress_io_exception(jvm, this, result).await?;
791 }
792 Ok(())
793 })
794 .await
795 }
796
797 async fn suppress_io_exception(jvm: &Jvm, this: &ClassInstanceRef<Self>, result: Result<()>) -> Result<bool> {
798 match result {
799 Ok(()) => Ok(true),
800 Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
801 let mut this = this.clone();
802 jvm.put_field(&mut this, "trouble", "Z", true).await?;
803 Ok(false)
804 }
805 Err(error) => Err(error),
806 }
807 }
808}