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