Skip to main content

rustjava_runtime/classes/java/util/
formatter.rs

1use alloc::{format, string::String as RustString, string::ToString, vec, vec::Vec};
2use core::fmt::Write;
3
4use jvm::{Array, ClassInstanceRef, JavaChar, JavaError, Jvm, Result, runtime::JavaLangString};
5use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
6use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
7
8use crate::{
9    RuntimeClassProto, RuntimeContext,
10    classes::java::{
11        io::{File, IOException, OutputStream, OutputStreamWriter, PrintStream, Writer},
12        lang::{Appendable, CharSequence, Object, String},
13        util::Locale,
14    },
15};
16
17struct FormatSpecifier {
18    text: RustString,
19    argument_index: Option<usize>,
20    reuse_previous: bool,
21    flags: Vec<char>,
22    width: Option<usize>,
23    precision: Option<usize>,
24    conversion: char,
25}
26
27enum NumericKind {
28    Finite,
29    Nan,
30    Infinite,
31}
32
33// public final class java.util.Formatter
34pub struct Formatter;
35
36impl Formatter {
37    pub fn as_proto() -> RuntimeClassProto {
38        RuntimeClassProto {
39            name: "java/util/Formatter",
40            parent_class: Some("java/lang/Object"),
41            interfaces: vec!["java/io/Closeable", "java/io/Flushable"],
42            methods: vec![
43                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new(
45                    "<init>",
46                    "(Ljava/lang/Appendable;)V",
47                    Self::init_with_appendable,
48                    MethodAccessFlags::PUBLIC,
49                ),
50                JavaMethodProto::new("<init>", "(Ljava/util/Locale;)V", Self::init_with_locale, MethodAccessFlags::PUBLIC),
51                JavaMethodProto::new(
52                    "<init>",
53                    "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
54                    Self::init_with_appendable_locale,
55                    MethodAccessFlags::PUBLIC,
56                ),
57                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_path, MethodAccessFlags::PUBLIC),
58                JavaMethodProto::new(
59                    "<init>",
60                    "(Ljava/lang/String;Ljava/lang/String;)V",
61                    Self::init_with_path_encoding,
62                    MethodAccessFlags::PUBLIC,
63                ),
64                JavaMethodProto::new(
65                    "<init>",
66                    "(Ljava/lang/String;Ljava/lang/String;Ljava/util/Locale;)V",
67                    Self::init_with_path_encoding_locale,
68                    MethodAccessFlags::PUBLIC,
69                ),
70                JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init_with_file, MethodAccessFlags::PUBLIC),
71                JavaMethodProto::new(
72                    "<init>",
73                    "(Ljava/io/File;Ljava/lang/String;)V",
74                    Self::init_with_file_encoding,
75                    MethodAccessFlags::PUBLIC,
76                ),
77                JavaMethodProto::new(
78                    "<init>",
79                    "(Ljava/io/File;Ljava/lang/String;Ljava/util/Locale;)V",
80                    Self::init_with_file_encoding_locale,
81                    MethodAccessFlags::PUBLIC,
82                ),
83                JavaMethodProto::new(
84                    "<init>",
85                    "(Ljava/io/PrintStream;)V",
86                    Self::init_with_print_stream,
87                    MethodAccessFlags::PUBLIC,
88                ),
89                JavaMethodProto::new(
90                    "<init>",
91                    "(Ljava/io/OutputStream;)V",
92                    Self::init_with_output_stream,
93                    MethodAccessFlags::PUBLIC,
94                ),
95                JavaMethodProto::new(
96                    "<init>",
97                    "(Ljava/io/OutputStream;Ljava/lang/String;)V",
98                    Self::init_with_output_stream_encoding,
99                    MethodAccessFlags::PUBLIC,
100                ),
101                JavaMethodProto::new(
102                    "<init>",
103                    "(Ljava/io/OutputStream;Ljava/lang/String;Ljava/util/Locale;)V",
104                    Self::init_with_output_stream_encoding_locale,
105                    MethodAccessFlags::PUBLIC,
106                ),
107                JavaMethodProto::new("locale", "()Ljava/util/Locale;", Self::locale, MethodAccessFlags::PUBLIC),
108                JavaMethodProto::new("out", "()Ljava/lang/Appendable;", Self::out, MethodAccessFlags::PUBLIC),
109                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
110                JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
111                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
112                JavaMethodProto::new("ioException", "()Ljava/io/IOException;", Self::io_exception, MethodAccessFlags::PUBLIC),
113                JavaMethodProto::new(
114                    "format",
115                    "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
116                    Self::format,
117                    MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
118                ),
119                JavaMethodProto::new(
120                    "format",
121                    "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
122                    Self::format_with_locale,
123                    MethodAccessFlags::PUBLIC | MethodAccessFlags::VARARGS,
124                ),
125            ],
126            fields: vec![
127                JavaFieldProto::new("a", "Ljava/lang/Appendable;", FieldAccessFlags::PRIVATE),
128                JavaFieldProto::new("l", "Ljava/util/Locale;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
129                JavaFieldProto::new("lastException", "Ljava/io/IOException;", FieldAccessFlags::PRIVATE),
130            ],
131            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
132        }
133    }
134
135    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
136        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
137        jvm.invoke_special(
138            &this,
139            "java/util/Formatter",
140            "<init>",
141            "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
142            (ClassInstanceRef::<Appendable>::new(None), locale),
143        )
144        .await
145    }
146
147    async fn init_with_appendable(
148        jvm: &Jvm,
149        _: &mut RuntimeContext,
150        this: ClassInstanceRef<Self>,
151        appendable: ClassInstanceRef<Appendable>,
152    ) -> Result<()> {
153        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
154        jvm.invoke_special(
155            &this,
156            "java/util/Formatter",
157            "<init>",
158            "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
159            (appendable, locale),
160        )
161        .await
162    }
163
164    async fn init_with_locale(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, locale: ClassInstanceRef<Locale>) -> Result<()> {
165        jvm.invoke_special(
166            &this,
167            "java/util/Formatter",
168            "<init>",
169            "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
170            (ClassInstanceRef::<Appendable>::new(None), locale),
171        )
172        .await
173    }
174
175    async fn init_with_appendable_locale(
176        jvm: &Jvm,
177        _: &mut RuntimeContext,
178        mut this: ClassInstanceRef<Self>,
179        appendable: ClassInstanceRef<Appendable>,
180        locale: ClassInstanceRef<Locale>,
181    ) -> Result<()> {
182        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
183        let appendable: ClassInstanceRef<Appendable> = if appendable.is_null() {
184            jvm.new_class("java/lang/StringBuilder", "()V", ()).await?.into()
185        } else {
186            appendable
187        };
188        jvm.put_field(&mut this, "java/util/Formatter", "a", "Ljava/lang/Appendable;", appendable)
189            .await?;
190        jvm.put_field(&mut this, "java/util/Formatter", "l", "Ljava/util/Locale;", locale).await?;
191        jvm.put_field(
192            &mut this,
193            "java/util/Formatter",
194            "lastException",
195            "Ljava/io/IOException;",
196            ClassInstanceRef::<IOException>::new(None),
197        )
198        .await
199    }
200
201    async fn init_with_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, path: ClassInstanceRef<String>) -> Result<()> {
202        if path.is_null() {
203            return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
204        }
205        let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
206        jvm.invoke_special(&this, "java/util/Formatter", "<init>", "(Ljava/io/File;)V", (file,))
207            .await
208    }
209
210    async fn init_with_path_encoding(
211        jvm: &Jvm,
212        _: &mut RuntimeContext,
213        this: ClassInstanceRef<Self>,
214        path: ClassInstanceRef<String>,
215        encoding: ClassInstanceRef<String>,
216    ) -> Result<()> {
217        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
218        jvm.invoke_special(
219            &this,
220            "java/util/Formatter",
221            "<init>",
222            "(Ljava/lang/String;Ljava/lang/String;Ljava/util/Locale;)V",
223            (path, encoding, locale),
224        )
225        .await
226    }
227
228    async fn init_with_path_encoding_locale(
229        jvm: &Jvm,
230        _: &mut RuntimeContext,
231        this: ClassInstanceRef<Self>,
232        path: ClassInstanceRef<String>,
233        encoding: ClassInstanceRef<String>,
234        locale: ClassInstanceRef<Locale>,
235    ) -> Result<()> {
236        if path.is_null() {
237            return Err(jvm.exception("java/lang/NullPointerException", "file name is null").await);
238        }
239        OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
240        let file: ClassInstanceRef<File> = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (path,)).await?.into();
241        jvm.invoke_special(
242            &this,
243            "java/util/Formatter",
244            "<init>",
245            "(Ljava/io/File;Ljava/lang/String;Ljava/util/Locale;)V",
246            (file, encoding, locale),
247        )
248        .await
249    }
250
251    async fn init_with_file(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
252        if file.is_null() {
253            return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
254        }
255        let stream: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
256        let writer: ClassInstanceRef<Writer> = jvm
257            .new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (stream,))
258            .await?
259            .into();
260        let appendable: ClassInstanceRef<Appendable> = jvm.new_class("java/io/BufferedWriter", "(Ljava/io/Writer;)V", (writer,)).await?.into();
261        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
262        jvm.invoke_special(
263            &this,
264            "java/util/Formatter",
265            "<init>",
266            "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
267            (appendable, locale),
268        )
269        .await
270    }
271
272    async fn init_with_file_encoding(
273        jvm: &Jvm,
274        _: &mut RuntimeContext,
275        this: ClassInstanceRef<Self>,
276        file: ClassInstanceRef<File>,
277        encoding: ClassInstanceRef<String>,
278    ) -> Result<()> {
279        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
280        jvm.invoke_special(
281            &this,
282            "java/util/Formatter",
283            "<init>",
284            "(Ljava/io/File;Ljava/lang/String;Ljava/util/Locale;)V",
285            (file, encoding, locale),
286        )
287        .await
288    }
289
290    async fn init_with_file_encoding_locale(
291        jvm: &Jvm,
292        _: &mut RuntimeContext,
293        this: ClassInstanceRef<Self>,
294        file: ClassInstanceRef<File>,
295        encoding: ClassInstanceRef<String>,
296        locale: ClassInstanceRef<Locale>,
297    ) -> Result<()> {
298        if file.is_null() {
299            return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
300        }
301        OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
302        let stream: ClassInstanceRef<OutputStream> = jvm.new_class("java/io/FileOutputStream", "(Ljava/io/File;)V", (file,)).await?.into();
303        let writer: ClassInstanceRef<Writer> = jvm
304            .new_class(
305                "java/io/OutputStreamWriter",
306                "(Ljava/io/OutputStream;Ljava/lang/String;)V",
307                (stream, encoding),
308            )
309            .await?
310            .into();
311        let appendable: ClassInstanceRef<Appendable> = jvm.new_class("java/io/BufferedWriter", "(Ljava/io/Writer;)V", (writer,)).await?.into();
312        jvm.invoke_special(
313            &this,
314            "java/util/Formatter",
315            "<init>",
316            "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
317            (appendable, locale),
318        )
319        .await
320    }
321
322    async fn init_with_print_stream(
323        jvm: &Jvm,
324        _: &mut RuntimeContext,
325        this: ClassInstanceRef<Self>,
326        stream: ClassInstanceRef<PrintStream>,
327    ) -> Result<()> {
328        if stream.is_null() {
329            return Err(jvm.exception("java/lang/NullPointerException", "print stream is null").await);
330        }
331        let appendable: ClassInstanceRef<Appendable> = stream.instance.into();
332        jvm.invoke_special(&this, "java/util/Formatter", "<init>", "(Ljava/lang/Appendable;)V", (appendable,))
333            .await
334    }
335
336    async fn init_with_output_stream(
337        jvm: &Jvm,
338        _: &mut RuntimeContext,
339        this: ClassInstanceRef<Self>,
340        stream: ClassInstanceRef<OutputStream>,
341    ) -> Result<()> {
342        if stream.is_null() {
343            return Err(jvm.exception("java/lang/NullPointerException", "output stream is null").await);
344        }
345        let writer: ClassInstanceRef<Writer> = jvm
346            .new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (stream,))
347            .await?
348            .into();
349        let appendable: ClassInstanceRef<Appendable> = jvm.new_class("java/io/BufferedWriter", "(Ljava/io/Writer;)V", (writer,)).await?.into();
350        jvm.invoke_special(&this, "java/util/Formatter", "<init>", "(Ljava/lang/Appendable;)V", (appendable,))
351            .await
352    }
353
354    async fn init_with_output_stream_encoding(
355        jvm: &Jvm,
356        _: &mut RuntimeContext,
357        this: ClassInstanceRef<Self>,
358        stream: ClassInstanceRef<OutputStream>,
359        encoding: ClassInstanceRef<String>,
360    ) -> Result<()> {
361        let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
362        jvm.invoke_special(
363            &this,
364            "java/util/Formatter",
365            "<init>",
366            "(Ljava/io/OutputStream;Ljava/lang/String;Ljava/util/Locale;)V",
367            (stream, encoding, locale),
368        )
369        .await
370    }
371
372    async fn init_with_output_stream_encoding_locale(
373        jvm: &Jvm,
374        _: &mut RuntimeContext,
375        this: ClassInstanceRef<Self>,
376        stream: ClassInstanceRef<OutputStream>,
377        encoding: ClassInstanceRef<String>,
378        locale: ClassInstanceRef<Locale>,
379    ) -> Result<()> {
380        if stream.is_null() || encoding.is_null() {
381            return Err(jvm.exception("java/lang/NullPointerException", "output stream or encoding is null").await);
382        }
383        let writer: ClassInstanceRef<Writer> = jvm
384            .new_class(
385                "java/io/OutputStreamWriter",
386                "(Ljava/io/OutputStream;Ljava/lang/String;)V",
387                (stream, encoding),
388            )
389            .await?
390            .into();
391        let appendable: ClassInstanceRef<Appendable> = jvm.new_class("java/io/BufferedWriter", "(Ljava/io/Writer;)V", (writer,)).await?.into();
392        jvm.invoke_special(
393            &this,
394            "java/util/Formatter",
395            "<init>",
396            "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
397            (appendable, locale),
398        )
399        .await
400    }
401
402    async fn locale(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Locale>> {
403        let _: ClassInstanceRef<Appendable> = jvm
404            .invoke_virtual(&this, "java/util/Formatter", "out", "()Ljava/lang/Appendable;", ())
405            .await?;
406        jvm.get_field(&this, "java/util/Formatter", "l", "Ljava/util/Locale;").await
407    }
408
409    async fn out(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Appendable>> {
410        let appendable: ClassInstanceRef<Appendable> = jvm.get_field(&this, "java/util/Formatter", "a", "Ljava/lang/Appendable;").await?;
411        if appendable.is_null() {
412            return Err(JavaError::JavaException(
413                jvm.new_class("java/util/FormatterClosedException", "()V", ()).await?,
414            ));
415        }
416        Ok(appendable)
417    }
418
419    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
420        let appendable: ClassInstanceRef<Appendable> = jvm
421            .invoke_virtual(&this, "java/util/Formatter", "out", "()Ljava/lang/Appendable;", ())
422            .await?;
423        jvm.invoke_virtual(&appendable, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
424            .await
425    }
426
427    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
428        let appendable: ClassInstanceRef<Appendable> = jvm
429            .invoke_virtual(&this, "java/util/Formatter", "out", "()Ljava/lang/Appendable;", ())
430            .await?;
431        if !jvm.is_instance(&**appendable, "java/io/Flushable") {
432            return Ok(());
433        }
434        match jvm
435            .invoke_virtual(&appendable, &appendable.class_definition().name(), "flush", "()V", ())
436            .await
437        {
438            Ok(()) => Ok(()),
439            Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
440                jvm.put_field(
441                    &mut this,
442                    "java/util/Formatter",
443                    "lastException",
444                    "Ljava/io/IOException;",
445                    ClassInstanceRef::<IOException>::from(exception),
446                )
447                .await
448            }
449            Err(error) => Err(error),
450        }
451    }
452
453    async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
454        let appendable: ClassInstanceRef<Appendable> = jvm.get_field(&this, "java/util/Formatter", "a", "Ljava/lang/Appendable;").await?;
455        if appendable.is_null() {
456            return Ok(());
457        }
458        let result = if jvm.is_instance(&**appendable, "java/io/Closeable") {
459            jvm.invoke_virtual(&appendable, &appendable.class_definition().name(), "close", "()V", ())
460                .await
461        } else {
462            Ok(())
463        };
464        jvm.put_field(
465            &mut this,
466            "java/util/Formatter",
467            "a",
468            "Ljava/lang/Appendable;",
469            ClassInstanceRef::<Appendable>::new(None),
470        )
471        .await?;
472        match result {
473            Ok(()) => Ok(()),
474            Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
475                jvm.put_field(
476                    &mut this,
477                    "java/util/Formatter",
478                    "lastException",
479                    "Ljava/io/IOException;",
480                    ClassInstanceRef::<IOException>::from(exception),
481                )
482                .await
483            }
484            Err(error) => Err(error),
485        }
486    }
487
488    async fn io_exception(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<IOException>> {
489        jvm.get_field(&this, "java/util/Formatter", "lastException", "Ljava/io/IOException;")
490            .await
491    }
492
493    async fn append_output(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, characters: Vec<JavaChar>) -> Result<()> {
494        if characters.is_empty() {
495            return Ok(());
496        }
497        let appendable: ClassInstanceRef<Appendable> = jvm
498            .invoke_virtual(this, "java/util/Formatter", "out", "()Ljava/lang/Appendable;", ())
499            .await?;
500        let text: ClassInstanceRef<CharSequence> = JavaLangString::from_utf16(jvm, characters).await?.into();
501        match jvm
502            .invoke_virtual::<_, ClassInstanceRef<Appendable>>(
503                &appendable,
504                &appendable.class_definition().name(),
505                "append",
506                "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
507                (text,),
508            )
509            .await
510        {
511            Ok(_) => Ok(()),
512            Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/io/IOException") => {
513                jvm.put_field(
514                    this,
515                    "java/util/Formatter",
516                    "lastException",
517                    "Ljava/io/IOException;",
518                    ClassInstanceRef::<IOException>::from(exception),
519                )
520                .await
521            }
522            Err(error) => Err(error),
523        }
524    }
525
526    async fn format(
527        jvm: &Jvm,
528        _: &mut RuntimeContext,
529        this: ClassInstanceRef<Self>,
530        format: ClassInstanceRef<String>,
531        arguments: ClassInstanceRef<Array<Object>>,
532    ) -> Result<ClassInstanceRef<Self>> {
533        let locale: ClassInstanceRef<Locale> = jvm.get_field(&this, "java/util/Formatter", "l", "Ljava/util/Locale;").await?;
534        jvm.invoke_virtual(
535            &this,
536            "java/util/Formatter",
537            "format",
538            "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
539            (locale, format, arguments),
540        )
541        .await
542    }
543
544    async fn format_with_locale(
545        jvm: &Jvm,
546        _: &mut RuntimeContext,
547        mut this: ClassInstanceRef<Self>,
548        locale: ClassInstanceRef<Locale>,
549        format: ClassInstanceRef<String>,
550        arguments: ClassInstanceRef<Array<Object>>,
551    ) -> Result<ClassInstanceRef<Self>> {
552        let _: ClassInstanceRef<Appendable> = jvm
553            .invoke_virtual(&this, "java/util/Formatter", "out", "()Ljava/lang/Appendable;", ())
554            .await?;
555        if format.is_null() {
556            return Err(jvm.exception("java/lang/NullPointerException", "format is null").await);
557        }
558
559        let characters = JavaLangString::to_utf16(jvm, &format).await?;
560        let argument_values: Option<Vec<ClassInstanceRef<Object>>> = if arguments.is_null() {
561            None
562        } else {
563            Some(jvm.load_array(&arguments, 0, jvm.array_length(&arguments).await?).await?)
564        };
565        for validation_only in [true, false] {
566            let mut cursor = 0;
567            let mut literal_start = 0;
568            let mut ordinary_index = 0;
569            let mut previous_index = None;
570
571            while cursor < characters.len() {
572                if characters[cursor] != '%' as JavaChar {
573                    cursor += 1;
574                    continue;
575                }
576                if !validation_only {
577                    Self::append_output(jvm, &mut this, characters[literal_start..cursor].to_vec()).await?;
578                }
579                let specifier_start = cursor;
580                cursor += 1;
581                if cursor == characters.len() {
582                    let conversion = JavaLangString::from_rust_string(jvm, "%").await?;
583                    return Err(JavaError::JavaException(
584                        jvm.new_class("java/util/UnknownFormatConversionException", "(Ljava/lang/String;)V", (conversion,))
585                            .await?,
586                    ));
587                }
588
589                let mut argument_index = None;
590                let number_start = cursor;
591                while cursor < characters.len() && char::from_u32(characters[cursor] as u32).is_some_and(|value| value.is_ascii_digit()) {
592                    cursor += 1;
593                }
594                if cursor > number_start && cursor < characters.len() && characters[cursor] == '$' as JavaChar {
595                    let value = RustString::from_utf16_lossy(&characters[number_start..cursor])
596                        .parse::<usize>()
597                        .unwrap_or(0);
598                    argument_index = value.checked_sub(1);
599                    cursor += 1;
600                } else {
601                    cursor = number_start;
602                }
603
604                let mut flags = Vec::new();
605                while cursor < characters.len() {
606                    let flag = char::from_u32(characters[cursor] as u32).unwrap_or('\u{fffd}');
607                    if !matches!(flag, '-' | '#' | '+' | ' ' | '0' | ',' | '(' | '<') {
608                        break;
609                    }
610                    if flags.contains(&flag) {
611                        let duplicate = JavaLangString::from_rust_string(jvm, &flag.to_string()).await?;
612                        return Err(JavaError::JavaException(
613                            jvm.new_class("java/util/DuplicateFormatFlagsException", "(Ljava/lang/String;)V", (duplicate,))
614                                .await?,
615                        ));
616                    }
617                    flags.push(flag);
618                    cursor += 1;
619                }
620
621                let width_start = cursor;
622                while cursor < characters.len() && char::from_u32(characters[cursor] as u32).is_some_and(|value| value.is_ascii_digit()) {
623                    cursor += 1;
624                }
625                let width = if cursor > width_start {
626                    match RustString::from_utf16_lossy(&characters[width_start..cursor]).parse::<i32>() {
627                        Ok(width) => Some(width as usize),
628                        Err(_) => {
629                            return Err(JavaError::JavaException(
630                                jvm.new_class("java/util/IllegalFormatWidthException", "(I)V", (-1,)).await?,
631                            ));
632                        }
633                    }
634                } else {
635                    None
636                };
637
638                let precision = if cursor < characters.len() && characters[cursor] == '.' as JavaChar {
639                    cursor += 1;
640                    let precision_start = cursor;
641                    while cursor < characters.len() && char::from_u32(characters[cursor] as u32).is_some_and(|value| value.is_ascii_digit()) {
642                        cursor += 1;
643                    }
644                    if precision_start == cursor {
645                        let conversion = JavaLangString::from_rust_string(jvm, ".").await?;
646                        return Err(JavaError::JavaException(
647                            jvm.new_class("java/util/UnknownFormatConversionException", "(Ljava/lang/String;)V", (conversion,))
648                                .await?,
649                        ));
650                    }
651                    match RustString::from_utf16_lossy(&characters[precision_start..cursor]).parse::<i32>() {
652                        Ok(precision) => Some(precision as usize),
653                        Err(_) => {
654                            return Err(JavaError::JavaException(
655                                jvm.new_class("java/util/IllegalFormatPrecisionException", "(I)V", (-1,)).await?,
656                            ));
657                        }
658                    }
659                } else {
660                    None
661                };
662
663                if cursor == characters.len() {
664                    let conversion = JavaLangString::from_rust_string(jvm, "%").await?;
665                    return Err(JavaError::JavaException(
666                        jvm.new_class("java/util/UnknownFormatConversionException", "(Ljava/lang/String;)V", (conversion,))
667                            .await?,
668                    ));
669                }
670                let conversion = char::from_u32(characters[cursor] as u32).unwrap_or('\u{fffd}');
671                cursor += 1;
672                let text = RustString::from_utf16_lossy(&characters[specifier_start..cursor]);
673                let specifier = FormatSpecifier {
674                    text,
675                    argument_index,
676                    reuse_previous: flags.contains(&'<'),
677                    flags,
678                    width,
679                    precision,
680                    conversion,
681                };
682
683                if !matches!(
684                    specifier.conversion,
685                    's' | 'S' | 'b' | 'B' | 'h' | 'H' | 'c' | 'C' | 'd' | 'o' | 'x' | 'X' | 'e' | 'E' | 'f' | 'g' | 'G' | '%' | 'n'
686                ) {
687                    let conversion = JavaLangString::from_rust_string(jvm, &specifier.conversion.to_string()).await?;
688                    return Err(JavaError::JavaException(
689                        jvm.new_class("java/util/UnknownFormatConversionException", "(Ljava/lang/String;)V", (conversion,))
690                            .await?,
691                    ));
692                }
693
694                if specifier.conversion == '%' {
695                    if let Some(precision) = specifier.precision {
696                        return Err(JavaError::JavaException(
697                            jvm.new_class("java/util/IllegalFormatPrecisionException", "(I)V", (precision as i32,))
698                                .await?,
699                        ));
700                    }
701                    let illegal_flags: RustString = specifier.flags.iter().filter(|flag| **flag != '-').collect();
702                    if !illegal_flags.is_empty() {
703                        let flags = JavaLangString::from_rust_string(jvm, &specifier.flags.iter().collect::<RustString>()).await?;
704                        return Err(JavaError::JavaException(
705                            jvm.new_class("java/util/IllegalFormatFlagsException", "(Ljava/lang/String;)V", (flags,))
706                                .await?,
707                        ));
708                    }
709                    if specifier.flags.contains(&'-') && specifier.width.is_none() {
710                        let text = JavaLangString::from_rust_string(jvm, &specifier.text).await?;
711                        return Err(JavaError::JavaException(
712                            jvm.new_class("java/util/MissingFormatWidthException", "(Ljava/lang/String;)V", (text,))
713                                .await?,
714                        ));
715                    }
716                    if !validation_only {
717                        let output = Self::apply_width(jvm, vec!['%' as JavaChar], &specifier, ' ' as JavaChar).await?;
718                        Self::append_output(jvm, &mut this, output).await?;
719                    }
720                    literal_start = cursor;
721                    continue;
722                }
723                if specifier.conversion == 'n' {
724                    if let Some(precision) = specifier.precision {
725                        return Err(JavaError::JavaException(
726                            jvm.new_class("java/util/IllegalFormatPrecisionException", "(I)V", (precision as i32,))
727                                .await?,
728                        ));
729                    }
730                    if let Some(width) = specifier.width {
731                        return Err(JavaError::JavaException(
732                            jvm.new_class("java/util/IllegalFormatWidthException", "(I)V", (width as i32,)).await?,
733                        ));
734                    }
735                    if !specifier.flags.is_empty() {
736                        let flags = JavaLangString::from_rust_string(jvm, &specifier.flags.iter().collect::<RustString>()).await?;
737                        return Err(JavaError::JavaException(
738                            jvm.new_class("java/util/IllegalFormatFlagsException", "(Ljava/lang/String;)V", (flags,))
739                                .await?,
740                        ));
741                    }
742                    if !validation_only {
743                        let key = JavaLangString::from_rust_string(jvm, "line.separator").await?;
744                        let separator: ClassInstanceRef<String> = jvm
745                            .invoke_static("java/lang/System", "getProperty", "(Ljava/lang/String;)Ljava/lang/String;", (key,))
746                            .await?;
747                        let line = if separator.is_null() {
748                            vec!['\n' as JavaChar]
749                        } else {
750                            JavaLangString::to_utf16(jvm, &separator).await?
751                        };
752                        Self::append_output(jvm, &mut this, line).await?;
753                    }
754                    literal_start = cursor;
755                    continue;
756                }
757
758                if specifier.flags.contains(&'-') && specifier.width.is_none() {
759                    let text = JavaLangString::from_rust_string(jvm, &specifier.text).await?;
760                    return Err(JavaError::JavaException(
761                        jvm.new_class("java/util/MissingFormatWidthException", "(Ljava/lang/String;)V", (text,))
762                            .await?,
763                    ));
764                }
765                Self::validate_specifier(jvm, &specifier).await?;
766                if validation_only {
767                    literal_start = cursor;
768                    continue;
769                }
770
771                let selected_index = if specifier.reuse_previous {
772                    previous_index
773                } else if let Some(index) = specifier.argument_index {
774                    Some(index)
775                } else {
776                    let index = ordinary_index;
777                    ordinary_index += 1;
778                    Some(index)
779                };
780                let Some(selected_index) = selected_index else {
781                    let text = JavaLangString::from_rust_string(jvm, &specifier.text).await?;
782                    return Err(JavaError::JavaException(
783                        jvm.new_class("java/util/MissingFormatArgumentException", "(Ljava/lang/String;)V", (text,))
784                            .await?,
785                    ));
786                };
787                previous_index = Some(selected_index);
788                let argument = match &argument_values {
789                    None => ClassInstanceRef::<Object>::new(None),
790                    Some(values) if selected_index < values.len() => values[selected_index].clone(),
791                    Some(_) => {
792                        let text = JavaLangString::from_rust_string(jvm, &specifier.text).await?;
793                        return Err(JavaError::JavaException(
794                            jvm.new_class("java/util/MissingFormatArgumentException", "(Ljava/lang/String;)V", (text,))
795                                .await?,
796                        ));
797                    }
798                };
799                if let Some(output) = Self::format_argument(jvm, &this, &locale, &specifier, argument).await? {
800                    Self::append_output(jvm, &mut this, output).await?;
801                }
802                literal_start = cursor;
803            }
804            if !validation_only {
805                Self::append_output(jvm, &mut this, characters[literal_start..].to_vec()).await?;
806            }
807        }
808        Ok(this)
809    }
810
811    async fn validate_flags(jvm: &Jvm, specifier: &FormatSpecifier, allowed: &str) -> Result<()> {
812        let invalid: RustString = specifier.flags.iter().filter(|flag| **flag != '<' && !allowed.contains(**flag)).collect();
813        if invalid.is_empty() {
814            return Ok(());
815        }
816        let flags = JavaLangString::from_rust_string(jvm, &invalid).await?;
817        Err(JavaError::JavaException(
818            jvm.new_class(
819                "java/util/FormatFlagsConversionMismatchException",
820                "(Ljava/lang/String;C)V",
821                (flags, specifier.conversion as JavaChar),
822            )
823            .await?,
824        ))
825    }
826
827    async fn validate_specifier(jvm: &Jvm, specifier: &FormatSpecifier) -> Result<()> {
828        let conversion = specifier.conversion.to_ascii_lowercase();
829        match conversion {
830            's' => Self::validate_flags(jvm, specifier, "-#").await,
831            'b' | 'h' => Self::validate_flags(jvm, specifier, "-").await,
832            'c' => {
833                if let Some(precision) = specifier.precision {
834                    return Err(JavaError::JavaException(
835                        jvm.new_class("java/util/IllegalFormatPrecisionException", "(I)V", (precision as i32,))
836                            .await?,
837                    ));
838                }
839                Self::validate_flags(jvm, specifier, "-").await
840            }
841            'd' | 'o' | 'x' => {
842                if specifier.flags.contains(&'0') && specifier.width.is_none() {
843                    let text = JavaLangString::from_rust_string(jvm, &specifier.text).await?;
844                    return Err(JavaError::JavaException(
845                        jvm.new_class("java/util/MissingFormatWidthException", "(Ljava/lang/String;)V", (text,))
846                            .await?,
847                    ));
848                }
849                Self::validate_numeric_flags(jvm, specifier).await?;
850                if let Some(precision) = specifier.precision {
851                    return Err(JavaError::JavaException(
852                        jvm.new_class("java/util/IllegalFormatPrecisionException", "(I)V", (precision as i32,))
853                            .await?,
854                    ));
855                }
856                Self::validate_flags(jvm, specifier, if conversion == 'd' { "-+ 0,(" } else { "-#+ 0(" }).await
857            }
858            'e'..='g' => {
859                if specifier.flags.contains(&'0') && specifier.width.is_none() {
860                    let text = JavaLangString::from_rust_string(jvm, &specifier.text).await?;
861                    return Err(JavaError::JavaException(
862                        jvm.new_class("java/util/MissingFormatWidthException", "(Ljava/lang/String;)V", (text,))
863                            .await?,
864                    ));
865                }
866                Self::validate_numeric_flags(jvm, specifier).await?;
867                Self::validate_flags(
868                    jvm,
869                    specifier,
870                    match conversion {
871                        'e' => "-+ 0(#",
872                        'f' => "-+ 0,(#",
873                        'g' => "-+ 0,(",
874                        _ => "",
875                    },
876                )
877                .await
878            }
879            _ => Ok(()),
880        }
881    }
882
883    async fn illegal_conversion(jvm: &Jvm, specifier: &FormatSpecifier, argument: &ClassInstanceRef<Object>) -> Result<JavaError> {
884        let argument_class = jvm.resolve_class(&argument.class_definition().name()).await?.java_class();
885        Ok(JavaError::JavaException(
886            jvm.new_class(
887                "java/util/IllegalFormatConversionException",
888                "(CLjava/lang/Class;)V",
889                (specifier.conversion as JavaChar, argument_class),
890            )
891            .await?,
892        ))
893    }
894
895    async fn uppercase_utf16(jvm: &Jvm, text: Vec<JavaChar>) -> Result<Vec<JavaChar>> {
896        let Some(capacity) = text.len().checked_mul(6) else {
897            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
898        };
899        let mut output = Vec::new();
900        if output.try_reserve_exact(capacity).is_err() {
901            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
902        }
903        for character in char::decode_utf16(text) {
904            match character {
905                Ok(character) => {
906                    for uppercase in character.to_uppercase() {
907                        let mut encoded = [0; 2];
908                        output.extend_from_slice(uppercase.encode_utf16(&mut encoded));
909                    }
910                }
911                Err(error) => output.push(error.unpaired_surrogate()),
912            }
913        }
914        Ok(output)
915    }
916
917    async fn format_argument(
918        jvm: &Jvm,
919        formatter: &ClassInstanceRef<Self>,
920        locale: &ClassInstanceRef<Locale>,
921        specifier: &FormatSpecifier,
922        argument: ClassInstanceRef<Object>,
923    ) -> Result<Option<Vec<JavaChar>>> {
924        let conversion = specifier.conversion.to_ascii_lowercase();
925        let uppercase = specifier.conversion.is_ascii_uppercase();
926
927        match conversion {
928            's' => {
929                if !argument.is_null() && jvm.is_instance(&**argument, "java/util/Formattable") {
930                    let mut flags = 0;
931                    if specifier.flags.contains(&'-') {
932                        flags |= 1;
933                    }
934                    if uppercase {
935                        flags |= 2;
936                    }
937                    if specifier.flags.contains(&'#') {
938                        flags |= 4;
939                    }
940                    let formatter_locale: ClassInstanceRef<Locale> =
941                        jvm.get_field(formatter, "java/util/Formatter", "l", "Ljava/util/Locale;").await?;
942                    let callback_formatter = if (formatter_locale.is_null() && locale.is_null())
943                        || (!formatter_locale.is_null() && !locale.is_null() && formatter_locale.identity() == locale.identity())
944                    {
945                        formatter.clone()
946                    } else {
947                        let appendable: ClassInstanceRef<Appendable> = jvm
948                            .invoke_virtual(formatter, "java/util/Formatter", "out", "()Ljava/lang/Appendable;", ())
949                            .await?;
950                        jvm.new_class(
951                            "java/util/Formatter",
952                            "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
953                            (appendable, locale.clone()),
954                        )
955                        .await?
956                        .into()
957                    };
958                    let _: () = jvm
959                        .invoke_virtual(
960                            &argument,
961                            &argument.class_definition().name(),
962                            "formatTo",
963                            "(Ljava/util/Formatter;III)V",
964                            (
965                                callback_formatter,
966                                flags,
967                                specifier.width.map_or(-1, |width| width as i32),
968                                specifier.precision.map_or(-1, |precision| precision as i32),
969                            ),
970                        )
971                        .await?;
972                    return Ok(None);
973                }
974                if specifier.flags.contains(&'#') {
975                    let flags = JavaLangString::from_rust_string(jvm, "#").await?;
976                    return Err(JavaError::JavaException(
977                        jvm.new_class(
978                            "java/util/FormatFlagsConversionMismatchException",
979                            "(Ljava/lang/String;C)V",
980                            (flags, specifier.conversion as JavaChar),
981                        )
982                        .await?,
983                    ));
984                }
985                let mut text = if argument.is_null() {
986                    "null".encode_utf16().collect()
987                } else {
988                    let value: ClassInstanceRef<String> = jvm
989                        .invoke_virtual(&argument, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
990                        .await?;
991                    JavaLangString::to_utf16(jvm, &value).await?
992                };
993                if let Some(precision) = specifier.precision {
994                    text.truncate(precision);
995                }
996                if uppercase {
997                    text = Self::uppercase_utf16(jvm, text).await?;
998                }
999                Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?))
1000            }
1001            'b' => {
1002                let value = if argument.is_null() {
1003                    false
1004                } else if jvm.is_instance(&**argument, "java/lang/Boolean") {
1005                    jvm.invoke_virtual(&argument, &argument.class_definition().name(), "booleanValue", "()Z", ())
1006                        .await?
1007                } else {
1008                    true
1009                };
1010                let mut text: Vec<JavaChar> = if value { "true" } else { "false" }.encode_utf16().collect();
1011                if let Some(precision) = specifier.precision {
1012                    text.truncate(precision);
1013                }
1014                if uppercase {
1015                    text = Self::uppercase_utf16(jvm, text).await?;
1016                }
1017                Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?))
1018            }
1019            'h' => {
1020                let mut text: Vec<JavaChar> = if argument.is_null() {
1021                    "null".encode_utf16().collect()
1022                } else {
1023                    let hash: i32 = jvm.invoke_virtual(&argument, "java/lang/Object", "hashCode", "()I", ()).await?;
1024                    format!("{:x}", hash as u32).encode_utf16().collect()
1025                };
1026                if let Some(precision) = specifier.precision {
1027                    text.truncate(precision);
1028                }
1029                if uppercase {
1030                    text = Self::uppercase_utf16(jvm, text).await?;
1031                }
1032                Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?))
1033            }
1034            'c' => {
1035                if argument.is_null() {
1036                    let text = if uppercase { "NULL" } else { "null" }.encode_utf16().collect();
1037                    return Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?));
1038                }
1039                let code_point = if jvm.is_instance(&**argument, "java/lang/Character") {
1040                    jvm.invoke_virtual::<_, JavaChar>(&argument, &argument.class_definition().name(), "charValue", "()C", ())
1041                        .await? as i32
1042                } else if jvm.is_instance(&**argument, "java/lang/Byte")
1043                    || jvm.is_instance(&**argument, "java/lang/Short")
1044                    || jvm.is_instance(&**argument, "java/lang/Integer")
1045                {
1046                    jvm.invoke_virtual(&argument, &argument.class_definition().name(), "intValue", "()I", ())
1047                        .await?
1048                } else {
1049                    return Err(Self::illegal_conversion(jvm, specifier, &argument).await?);
1050                };
1051                if !(0..=0x10ffff).contains(&code_point) {
1052                    return Err(JavaError::JavaException(
1053                        jvm.new_class("java/util/IllegalFormatCodePointException", "(I)V", (code_point,)).await?,
1054                    ));
1055                }
1056                let mut text = if code_point < 0x10000 {
1057                    vec![code_point as JavaChar]
1058                } else {
1059                    let value = code_point - 0x10000;
1060                    vec![(0xd800 + (value >> 10)) as JavaChar, (0xdc00 + (value & 0x3ff)) as JavaChar]
1061                };
1062                if uppercase {
1063                    text = Self::uppercase_utf16(jvm, text).await?;
1064                }
1065                Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?))
1066            }
1067            'd' | 'o' | 'x' => Self::format_integral(jvm, specifier, argument, uppercase).await.map(Some),
1068            'e'..='g' => Self::format_floating(jvm, specifier, argument, uppercase).await.map(Some),
1069            _ => Ok(Some(Vec::new())),
1070        }
1071    }
1072
1073    async fn apply_width(jvm: &Jvm, mut text: Vec<JavaChar>, specifier: &FormatSpecifier, padding: JavaChar) -> Result<Vec<JavaChar>> {
1074        let width = specifier.width.unwrap_or(0);
1075        if text.len() >= width {
1076            return Ok(text);
1077        }
1078        let padding_length = width - text.len();
1079        if specifier.flags.contains(&'-') {
1080            if text.try_reserve_exact(padding_length).is_err() {
1081                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1082            }
1083            text.resize(width, padding);
1084            Ok(text)
1085        } else {
1086            let mut output = Vec::new();
1087            if output.try_reserve_exact(width).is_err() {
1088                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1089            }
1090            output.resize(padding_length, padding);
1091            output.extend(text);
1092            Ok(output)
1093        }
1094    }
1095
1096    async fn validate_numeric_flags(jvm: &Jvm, specifier: &FormatSpecifier) -> Result<()> {
1097        let conflicting =
1098            (specifier.flags.contains(&'+') && specifier.flags.contains(&' ')) || (specifier.flags.contains(&'-') && specifier.flags.contains(&'0'));
1099        if !conflicting {
1100            return Ok(());
1101        }
1102        let flags = JavaLangString::from_rust_string(jvm, &specifier.flags.iter().collect::<RustString>()).await?;
1103        Err(JavaError::JavaException(
1104            jvm.new_class("java/util/IllegalFormatFlagsException", "(Ljava/lang/String;)V", (flags,))
1105                .await?,
1106        ))
1107    }
1108
1109    async fn format_integral(jvm: &Jvm, specifier: &FormatSpecifier, argument: ClassInstanceRef<Object>, uppercase: bool) -> Result<Vec<JavaChar>> {
1110        let conversion = specifier.conversion.to_ascii_lowercase();
1111        if argument.is_null() {
1112            return Self::apply_width(
1113                jvm,
1114                if uppercase { "NULL" } else { "null" }.encode_utf16().collect(),
1115                specifier,
1116                ' ' as JavaChar,
1117            )
1118            .await;
1119        }
1120
1121        let bits = match argument.class_definition().name().as_ref() {
1122            "java/lang/Byte" => 8,
1123            "java/lang/Short" => 16,
1124            "java/lang/Integer" => 32,
1125            "java/lang/Long" => 64,
1126            _ => return Err(Self::illegal_conversion(jvm, specifier, &argument).await?),
1127        };
1128        if conversion != 'd' {
1129            Self::validate_flags(jvm, specifier, "-#0").await?;
1130        }
1131        let value: i64 = jvm
1132            .invoke_virtual(&argument, &argument.class_definition().name(), "longValue", "()J", ())
1133            .await?;
1134        let (digits, negative, prefix) = if conversion == 'd' {
1135            (value.unsigned_abs().to_string(), value < 0, RustString::new())
1136        } else {
1137            let unsigned = match bits {
1138                8 => value as i8 as u8 as u64,
1139                16 => value as i16 as u16 as u64,
1140                32 => value as i32 as u32 as u64,
1141                _ => value as u64,
1142            };
1143            let digits = if conversion == 'o' {
1144                format!("{unsigned:o}")
1145            } else if uppercase {
1146                format!("{unsigned:X}")
1147            } else {
1148                format!("{unsigned:x}")
1149            };
1150            let prefix = if specifier.flags.contains(&'#') {
1151                if conversion == 'o' {
1152                    "0".into()
1153                } else if uppercase {
1154                    "0X".into()
1155                } else {
1156                    "0x".into()
1157                }
1158            } else {
1159                RustString::new()
1160            };
1161            (digits, false, prefix)
1162        };
1163        Self::finish_numeric(
1164            jvm,
1165            digits,
1166            negative,
1167            prefix,
1168            specifier,
1169            conversion == 'd' && specifier.flags.contains(&','),
1170            NumericKind::Finite,
1171        )
1172        .await
1173    }
1174
1175    async fn format_floating(jvm: &Jvm, specifier: &FormatSpecifier, argument: ClassInstanceRef<Object>, uppercase: bool) -> Result<Vec<JavaChar>> {
1176        let conversion = specifier.conversion.to_ascii_lowercase();
1177        if argument.is_null() {
1178            return Self::apply_width(
1179                jvm,
1180                if uppercase { "NULL" } else { "null" }.encode_utf16().collect(),
1181                specifier,
1182                ' ' as JavaChar,
1183            )
1184            .await;
1185        }
1186        if !jvm.is_instance(&**argument, "java/lang/Float") && !jvm.is_instance(&**argument, "java/lang/Double") {
1187            return Err(Self::illegal_conversion(jvm, specifier, &argument).await?);
1188        }
1189        let value: f64 = jvm
1190            .invoke_virtual(&argument, &argument.class_definition().name(), "doubleValue", "()D", ())
1191            .await?;
1192        let negative = value.is_sign_negative() && !value.is_nan();
1193        let magnitude = libm::fabs(value);
1194        let precision = specifier.precision.unwrap_or(6);
1195        let mut digits = if value.is_nan() {
1196            "NaN".into()
1197        } else if value.is_infinite() {
1198            "Infinity".into()
1199        } else {
1200            match conversion {
1201                'f' => Self::decimal(jvm, magnitude, precision).await?,
1202                'e' => Self::scientific(jvm, magnitude, precision).await?,
1203                'g' => {
1204                    let precision = precision.max(1);
1205                    let exponent = if magnitude == 0.0 {
1206                        0
1207                    } else {
1208                        libm::floor(libm::log10(magnitude)) as i32
1209                    };
1210                    if exponent < -4 || exponent >= precision as i32 {
1211                        Self::scientific(jvm, magnitude, precision - 1).await?
1212                    } else {
1213                        let fractional = (precision as i32 - exponent - 1).max(0) as usize;
1214                        let rounded = Self::round_fraction(magnitude, fractional);
1215                        let rounded_exponent = if rounded == 0.0 { 0 } else { libm::floor(libm::log10(rounded)) as i32 };
1216                        if rounded_exponent >= precision as i32 {
1217                            Self::scientific(jvm, magnitude, precision - 1).await?
1218                        } else {
1219                            let fractional = (precision as i32 - rounded_exponent - 1).max(0) as usize;
1220                            Self::decimal(jvm, magnitude, fractional).await?
1221                        }
1222                    }
1223                }
1224                _ => RustString::new(),
1225            }
1226        };
1227        if value.is_finite() && specifier.flags.contains(&'#') && !digits.contains('.') {
1228            if let Some(exponent) = digits.find('e') {
1229                digits.insert(exponent, '.');
1230            } else {
1231                digits.push('.');
1232            }
1233        }
1234        if uppercase {
1235            digits = digits.to_uppercase();
1236        }
1237        let kind = if value.is_nan() {
1238            NumericKind::Nan
1239        } else if value.is_infinite() {
1240            NumericKind::Infinite
1241        } else {
1242            NumericKind::Finite
1243        };
1244        Self::finish_numeric(
1245            jvm,
1246            digits,
1247            negative,
1248            RustString::new(),
1249            specifier,
1250            specifier.flags.contains(&',') && conversion != 'e',
1251            kind,
1252        )
1253        .await
1254    }
1255
1256    async fn decimal(jvm: &Jvm, value: f64, precision: usize) -> Result<RustString> {
1257        let Some(capacity) = precision.checked_add(400) else {
1258            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1259        };
1260        let mut output = RustString::new();
1261        if output.try_reserve_exact(capacity).is_err() {
1262            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1263        }
1264        let value = Self::round_fraction(value, precision);
1265        if write!(&mut output, "{value:.precision$}").is_err() {
1266            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1267        }
1268        Ok(output)
1269    }
1270
1271    fn round_fraction(value: f64, precision: usize) -> f64 {
1272        if precision > 308 {
1273            return value;
1274        }
1275        let factor = libm::pow(10.0, precision as f64);
1276        let scaled = value * factor;
1277        if !scaled.is_finite() {
1278            return value;
1279        }
1280        if value == 0.0 {
1281            return value;
1282        }
1283        let exponent = libm::floor(libm::log10(value)) as i32;
1284        let discarded_index = exponent + precision as i32 + 1;
1285        let canonical = format!("{value:e}");
1286        let round_up = discarded_index >= 0
1287            && canonical
1288                .bytes()
1289                .take_while(|byte| *byte != b'e')
1290                .filter(|byte| byte.is_ascii_digit())
1291                .nth(discarded_index as usize)
1292                .is_some_and(|digit| digit >= b'5');
1293        (libm::floor(scaled) + if round_up { 1.0 } else { 0.0 }) / factor
1294    }
1295
1296    async fn scientific(jvm: &Jvm, value: f64, precision: usize) -> Result<RustString> {
1297        let mut exponent = if value == 0.0 { 0 } else { libm::floor(libm::log10(value)) as i32 };
1298        let scale = libm::pow(10.0, exponent as f64);
1299        let mut mantissa = if value == 0.0 {
1300            0.0
1301        } else if value.to_bits() == 1 {
1302            // Java's canonical decimal representation of Double.MIN_VALUE is 4.9E-324.
1303            4.9
1304        } else if scale == 0.0 {
1305            value * 1.0e308 / libm::pow(10.0, (exponent + 308) as f64)
1306        } else {
1307            value / scale
1308        };
1309        mantissa = Self::round_fraction(mantissa, precision);
1310        if mantissa >= 10.0 {
1311            mantissa /= 10.0;
1312            exponent += 1;
1313        }
1314        let mantissa = Self::decimal(jvm, mantissa, precision).await?;
1315        let exponent_magnitude = exponent.unsigned_abs().to_string();
1316        let Some(capacity) = mantissa
1317            .len()
1318            .checked_add(exponent_magnitude.len())
1319            .and_then(|length| length.checked_add(3))
1320        else {
1321            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1322        };
1323        let mut output = RustString::new();
1324        if output.try_reserve_exact(capacity).is_err() {
1325            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1326        }
1327        output.push_str(&mantissa);
1328        output.push('e');
1329        output.push(if exponent < 0 { '-' } else { '+' });
1330        if exponent_magnitude.len() < 2 {
1331            output.push('0');
1332        }
1333        output.push_str(&exponent_magnitude);
1334        Ok(output)
1335    }
1336
1337    async fn finish_numeric(
1338        jvm: &Jvm,
1339        mut digits: RustString,
1340        negative: bool,
1341        prefix: RustString,
1342        specifier: &FormatSpecifier,
1343        grouping: bool,
1344        kind: NumericKind,
1345    ) -> Result<Vec<JavaChar>> {
1346        if grouping && matches!(kind, NumericKind::Finite) {
1347            let separator = digits.find(['.', 'e', 'E']).unwrap_or(digits.len());
1348            let integer = &digits[..separator];
1349            let suffix = &digits[separator..];
1350            let Some(capacity) = digits.len().checked_add(integer.len().saturating_sub(1) / 3) else {
1351                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1352            };
1353            let mut grouped = RustString::new();
1354            if grouped.try_reserve_exact(capacity).is_err() {
1355                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1356            }
1357            for (index, character) in integer.chars().enumerate() {
1358                if index > 0 && (integer.len() - index).is_multiple_of(3) {
1359                    grouped.push(',');
1360                }
1361                grouped.push(character);
1362            }
1363            grouped.push_str(suffix);
1364            digits = grouped;
1365        }
1366
1367        let parentheses = negative && specifier.flags.contains(&'(');
1368        let sign = if parentheses {
1369            ""
1370        } else if negative {
1371            "-"
1372        } else if !matches!(kind, NumericKind::Nan) && specifier.flags.contains(&'+') {
1373            "+"
1374        } else if !matches!(kind, NumericKind::Nan) && specifier.flags.contains(&' ') {
1375            " "
1376        } else {
1377            ""
1378        };
1379        let Some(fixed) = sign
1380            .len()
1381            .checked_add(prefix.len())
1382            .and_then(|length| length.checked_add(usize::from(parentheses) * 2))
1383        else {
1384            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1385        };
1386        if specifier.flags.contains(&'0') && !specifier.flags.contains(&'-') && matches!(kind, NumericKind::Finite) {
1387            let width = specifier.width.unwrap_or(0);
1388            let Some(current) = fixed.checked_add(digits.len()) else {
1389                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1390            };
1391            if current < width {
1392                let padding_length = width - current;
1393                let Some(capacity) = padding_length.checked_add(digits.len()) else {
1394                    return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1395                };
1396                let mut padded = RustString::new();
1397                if padded.try_reserve_exact(capacity).is_err() {
1398                    return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1399                }
1400                for _ in 0..padding_length {
1401                    padded.push('0');
1402                }
1403                padded.push_str(&digits);
1404                digits = padded;
1405            }
1406        }
1407
1408        let Some(capacity) = fixed.checked_add(digits.len()) else {
1409            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1410        };
1411        let mut result = RustString::new();
1412        if result.try_reserve_exact(capacity).is_err() {
1413            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1414        }
1415        if parentheses {
1416            result.push('(');
1417        } else {
1418            result.push_str(sign);
1419        }
1420        result.push_str(&prefix);
1421        result.push_str(&digits);
1422        if parentheses {
1423            result.push(')');
1424        }
1425        let mut characters = Vec::new();
1426        if characters.try_reserve_exact(result.len()).is_err() {
1427            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1428        }
1429        characters.extend(result.encode_utf16());
1430        Self::apply_width(jvm, characters, specifier, ' ' as JavaChar).await
1431    }
1432}