Skip to main content

rustjava_runtime/classes/java/io/
print_writer.rs

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