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 argument_class = jvm.resolve_class(&argument.class_definition().name()).await?.java_class();
873        Ok(JavaError::JavaException(
874            jvm.new_class(
875                "java/util/IllegalFormatConversionException",
876                "(CLjava/lang/Class;)V",
877                (specifier.conversion as JavaChar, argument_class),
878            )
879            .await?,
880        ))
881    }
882
883    async fn uppercase_utf16(jvm: &Jvm, text: Vec<JavaChar>) -> Result<Vec<JavaChar>> {
884        let Some(capacity) = text.len().checked_mul(6) else {
885            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
886        };
887        let mut output = Vec::new();
888        if output.try_reserve_exact(capacity).is_err() {
889            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
890        }
891        for character in char::decode_utf16(text) {
892            match character {
893                Ok(character) => {
894                    for uppercase in character.to_uppercase() {
895                        let mut encoded = [0; 2];
896                        output.extend_from_slice(uppercase.encode_utf16(&mut encoded));
897                    }
898                }
899                Err(error) => output.push(error.unpaired_surrogate()),
900            }
901        }
902        Ok(output)
903    }
904
905    async fn format_argument(
906        jvm: &Jvm,
907        formatter: &ClassInstanceRef<Self>,
908        locale: &ClassInstanceRef<Locale>,
909        specifier: &FormatSpecifier,
910        argument: ClassInstanceRef<Object>,
911    ) -> Result<Option<Vec<JavaChar>>> {
912        let conversion = specifier.conversion.to_ascii_lowercase();
913        let uppercase = specifier.conversion.is_ascii_uppercase();
914
915        match conversion {
916            's' => {
917                if !argument.is_null() && jvm.is_instance(&**argument, "java/util/Formattable") {
918                    let mut flags = 0;
919                    if specifier.flags.contains(&'-') {
920                        flags |= 1;
921                    }
922                    if uppercase {
923                        flags |= 2;
924                    }
925                    if specifier.flags.contains(&'#') {
926                        flags |= 4;
927                    }
928                    let formatter_locale: ClassInstanceRef<Locale> = jvm.get_field(formatter, "l", "Ljava/util/Locale;").await?;
929                    let callback_formatter = if (formatter_locale.is_null() && locale.is_null())
930                        || (!formatter_locale.is_null() && !locale.is_null() && formatter_locale.identity() == locale.identity())
931                    {
932                        formatter.clone()
933                    } else {
934                        let appendable: ClassInstanceRef<Appendable> = jvm
935                            .invoke_virtual(formatter, "java/util/Formatter", "out", "()Ljava/lang/Appendable;", ())
936                            .await?;
937                        jvm.new_class(
938                            "java/util/Formatter",
939                            "(Ljava/lang/Appendable;Ljava/util/Locale;)V",
940                            (appendable, locale.clone()),
941                        )
942                        .await?
943                        .into()
944                    };
945                    let _: () = jvm
946                        .invoke_virtual(
947                            &argument,
948                            &argument.class_definition().name(),
949                            "formatTo",
950                            "(Ljava/util/Formatter;III)V",
951                            (
952                                callback_formatter,
953                                flags,
954                                specifier.width.map_or(-1, |width| width as i32),
955                                specifier.precision.map_or(-1, |precision| precision as i32),
956                            ),
957                        )
958                        .await?;
959                    return Ok(None);
960                }
961                if specifier.flags.contains(&'#') {
962                    let flags = JavaLangString::from_rust_string(jvm, "#").await?;
963                    return Err(JavaError::JavaException(
964                        jvm.new_class(
965                            "java/util/FormatFlagsConversionMismatchException",
966                            "(Ljava/lang/String;C)V",
967                            (flags, specifier.conversion as JavaChar),
968                        )
969                        .await?,
970                    ));
971                }
972                let mut text = if argument.is_null() {
973                    "null".encode_utf16().collect()
974                } else {
975                    let value: ClassInstanceRef<String> = jvm
976                        .invoke_virtual(&argument, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
977                        .await?;
978                    JavaLangString::to_utf16(jvm, &value).await?
979                };
980                if let Some(precision) = specifier.precision {
981                    text.truncate(precision);
982                }
983                if uppercase {
984                    text = Self::uppercase_utf16(jvm, text).await?;
985                }
986                Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?))
987            }
988            'b' => {
989                let value = if argument.is_null() {
990                    false
991                } else if jvm.is_instance(&**argument, "java/lang/Boolean") {
992                    jvm.invoke_virtual(&argument, &argument.class_definition().name(), "booleanValue", "()Z", ())
993                        .await?
994                } else {
995                    true
996                };
997                let mut text: Vec<JavaChar> = if value { "true" } else { "false" }.encode_utf16().collect();
998                if let Some(precision) = specifier.precision {
999                    text.truncate(precision);
1000                }
1001                if uppercase {
1002                    text = Self::uppercase_utf16(jvm, text).await?;
1003                }
1004                Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?))
1005            }
1006            'h' => {
1007                let mut text: Vec<JavaChar> = if argument.is_null() {
1008                    "null".encode_utf16().collect()
1009                } else {
1010                    let hash: i32 = jvm.invoke_virtual(&argument, "java/lang/Object", "hashCode", "()I", ()).await?;
1011                    format!("{:x}", hash as u32).encode_utf16().collect()
1012                };
1013                if let Some(precision) = specifier.precision {
1014                    text.truncate(precision);
1015                }
1016                if uppercase {
1017                    text = Self::uppercase_utf16(jvm, text).await?;
1018                }
1019                Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?))
1020            }
1021            'c' => {
1022                if argument.is_null() {
1023                    let text = if uppercase { "NULL" } else { "null" }.encode_utf16().collect();
1024                    return Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?));
1025                }
1026                let code_point = if jvm.is_instance(&**argument, "java/lang/Character") {
1027                    jvm.invoke_virtual::<_, JavaChar>(&argument, &argument.class_definition().name(), "charValue", "()C", ())
1028                        .await? as i32
1029                } else if jvm.is_instance(&**argument, "java/lang/Byte")
1030                    || jvm.is_instance(&**argument, "java/lang/Short")
1031                    || jvm.is_instance(&**argument, "java/lang/Integer")
1032                {
1033                    jvm.invoke_virtual(&argument, &argument.class_definition().name(), "intValue", "()I", ())
1034                        .await?
1035                } else {
1036                    return Err(Self::illegal_conversion(jvm, specifier, &argument).await?);
1037                };
1038                if !(0..=0x10ffff).contains(&code_point) {
1039                    return Err(JavaError::JavaException(
1040                        jvm.new_class("java/util/IllegalFormatCodePointException", "(I)V", (code_point,)).await?,
1041                    ));
1042                }
1043                let mut text = if code_point < 0x10000 {
1044                    vec![code_point as JavaChar]
1045                } else {
1046                    let value = code_point - 0x10000;
1047                    vec![(0xd800 + (value >> 10)) as JavaChar, (0xdc00 + (value & 0x3ff)) as JavaChar]
1048                };
1049                if uppercase {
1050                    text = Self::uppercase_utf16(jvm, text).await?;
1051                }
1052                Ok(Some(Self::apply_width(jvm, text, specifier, ' ' as JavaChar).await?))
1053            }
1054            'd' | 'o' | 'x' => Self::format_integral(jvm, specifier, argument, uppercase).await.map(Some),
1055            'e' | 'f' | 'g' => Self::format_floating(jvm, specifier, argument, uppercase).await.map(Some),
1056            _ => Ok(Some(Vec::new())),
1057        }
1058    }
1059
1060    async fn apply_width(jvm: &Jvm, mut text: Vec<JavaChar>, specifier: &FormatSpecifier, padding: JavaChar) -> Result<Vec<JavaChar>> {
1061        let width = specifier.width.unwrap_or(0);
1062        if text.len() >= width {
1063            return Ok(text);
1064        }
1065        let padding_length = width - text.len();
1066        if specifier.flags.contains(&'-') {
1067            if text.try_reserve_exact(padding_length).is_err() {
1068                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1069            }
1070            text.resize(width, padding);
1071            Ok(text)
1072        } else {
1073            let mut output = Vec::new();
1074            if output.try_reserve_exact(width).is_err() {
1075                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1076            }
1077            output.resize(padding_length, padding);
1078            output.extend(text);
1079            Ok(output)
1080        }
1081    }
1082
1083    async fn validate_numeric_flags(jvm: &Jvm, specifier: &FormatSpecifier) -> Result<()> {
1084        let conflicting =
1085            (specifier.flags.contains(&'+') && specifier.flags.contains(&' ')) || (specifier.flags.contains(&'-') && specifier.flags.contains(&'0'));
1086        if !conflicting {
1087            return Ok(());
1088        }
1089        let flags = JavaLangString::from_rust_string(jvm, &specifier.flags.iter().collect::<RustString>()).await?;
1090        Err(JavaError::JavaException(
1091            jvm.new_class("java/util/IllegalFormatFlagsException", "(Ljava/lang/String;)V", (flags,))
1092                .await?,
1093        ))
1094    }
1095
1096    async fn format_integral(jvm: &Jvm, specifier: &FormatSpecifier, argument: ClassInstanceRef<Object>, uppercase: bool) -> Result<Vec<JavaChar>> {
1097        let conversion = specifier.conversion.to_ascii_lowercase();
1098        if argument.is_null() {
1099            return Self::apply_width(
1100                jvm,
1101                if uppercase { "NULL" } else { "null" }.encode_utf16().collect(),
1102                specifier,
1103                ' ' as JavaChar,
1104            )
1105            .await;
1106        }
1107
1108        let bits = match argument.class_definition().name().as_ref() {
1109            "java/lang/Byte" => 8,
1110            "java/lang/Short" => 16,
1111            "java/lang/Integer" => 32,
1112            "java/lang/Long" => 64,
1113            _ => return Err(Self::illegal_conversion(jvm, specifier, &argument).await?),
1114        };
1115        if conversion != 'd' {
1116            Self::validate_flags(jvm, specifier, "-#0").await?;
1117        }
1118        let value: i64 = jvm
1119            .invoke_virtual(&argument, &argument.class_definition().name(), "longValue", "()J", ())
1120            .await?;
1121        let (digits, negative, prefix) = if conversion == 'd' {
1122            (value.unsigned_abs().to_string(), value < 0, RustString::new())
1123        } else {
1124            let unsigned = match bits {
1125                8 => value as i8 as u8 as u64,
1126                16 => value as i16 as u16 as u64,
1127                32 => value as i32 as u32 as u64,
1128                _ => value as u64,
1129            };
1130            let digits = if conversion == 'o' {
1131                format!("{unsigned:o}")
1132            } else if uppercase {
1133                format!("{unsigned:X}")
1134            } else {
1135                format!("{unsigned:x}")
1136            };
1137            let prefix = if specifier.flags.contains(&'#') {
1138                if conversion == 'o' {
1139                    "0".into()
1140                } else if uppercase {
1141                    "0X".into()
1142                } else {
1143                    "0x".into()
1144                }
1145            } else {
1146                RustString::new()
1147            };
1148            (digits, false, prefix)
1149        };
1150        Self::finish_numeric(
1151            jvm,
1152            digits,
1153            negative,
1154            prefix,
1155            specifier,
1156            conversion == 'd' && specifier.flags.contains(&','),
1157            NumericKind::Finite,
1158        )
1159        .await
1160    }
1161
1162    async fn format_floating(jvm: &Jvm, specifier: &FormatSpecifier, argument: ClassInstanceRef<Object>, uppercase: bool) -> Result<Vec<JavaChar>> {
1163        let conversion = specifier.conversion.to_ascii_lowercase();
1164        if argument.is_null() {
1165            return Self::apply_width(
1166                jvm,
1167                if uppercase { "NULL" } else { "null" }.encode_utf16().collect(),
1168                specifier,
1169                ' ' as JavaChar,
1170            )
1171            .await;
1172        }
1173        if !jvm.is_instance(&**argument, "java/lang/Float") && !jvm.is_instance(&**argument, "java/lang/Double") {
1174            return Err(Self::illegal_conversion(jvm, specifier, &argument).await?);
1175        }
1176        let value: f64 = jvm
1177            .invoke_virtual(&argument, &argument.class_definition().name(), "doubleValue", "()D", ())
1178            .await?;
1179        let negative = value.is_sign_negative() && !value.is_nan();
1180        let magnitude = libm::fabs(value);
1181        let precision = specifier.precision.unwrap_or(6);
1182        let mut digits = if value.is_nan() {
1183            "NaN".into()
1184        } else if value.is_infinite() {
1185            "Infinity".into()
1186        } else {
1187            match conversion {
1188                'f' => Self::decimal(jvm, magnitude, precision).await?,
1189                'e' => Self::scientific(jvm, magnitude, precision).await?,
1190                'g' => {
1191                    let precision = precision.max(1);
1192                    let exponent = if magnitude == 0.0 {
1193                        0
1194                    } else {
1195                        libm::floor(libm::log10(magnitude)) as i32
1196                    };
1197                    if exponent < -4 || exponent >= precision as i32 {
1198                        Self::scientific(jvm, magnitude, precision - 1).await?
1199                    } else {
1200                        let fractional = (precision as i32 - exponent - 1).max(0) as usize;
1201                        let rounded = Self::round_fraction(magnitude, fractional);
1202                        let rounded_exponent = if rounded == 0.0 { 0 } else { libm::floor(libm::log10(rounded)) as i32 };
1203                        if rounded_exponent >= precision as i32 {
1204                            Self::scientific(jvm, magnitude, precision - 1).await?
1205                        } else {
1206                            let fractional = (precision as i32 - rounded_exponent - 1).max(0) as usize;
1207                            Self::decimal(jvm, magnitude, fractional).await?
1208                        }
1209                    }
1210                }
1211                _ => RustString::new(),
1212            }
1213        };
1214        if value.is_finite() && specifier.flags.contains(&'#') && !digits.contains('.') {
1215            if let Some(exponent) = digits.find('e') {
1216                digits.insert(exponent, '.');
1217            } else {
1218                digits.push('.');
1219            }
1220        }
1221        if uppercase {
1222            digits = digits.to_uppercase();
1223        }
1224        let kind = if value.is_nan() {
1225            NumericKind::Nan
1226        } else if value.is_infinite() {
1227            NumericKind::Infinite
1228        } else {
1229            NumericKind::Finite
1230        };
1231        Self::finish_numeric(
1232            jvm,
1233            digits,
1234            negative,
1235            RustString::new(),
1236            specifier,
1237            specifier.flags.contains(&',') && conversion != 'e',
1238            kind,
1239        )
1240        .await
1241    }
1242
1243    async fn decimal(jvm: &Jvm, value: f64, precision: usize) -> Result<RustString> {
1244        let Some(capacity) = precision.checked_add(400) else {
1245            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1246        };
1247        let mut output = RustString::new();
1248        if output.try_reserve_exact(capacity).is_err() {
1249            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1250        }
1251        let value = Self::round_fraction(value, precision);
1252        if write!(&mut output, "{value:.precision$}").is_err() {
1253            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1254        }
1255        Ok(output)
1256    }
1257
1258    fn round_fraction(value: f64, precision: usize) -> f64 {
1259        if precision > 308 {
1260            return value;
1261        }
1262        let factor = libm::pow(10.0, precision as f64);
1263        let scaled = value * factor;
1264        if !scaled.is_finite() {
1265            return value;
1266        }
1267        if value == 0.0 {
1268            return value;
1269        }
1270        let exponent = libm::floor(libm::log10(value)) as i32;
1271        let discarded_index = exponent + precision as i32 + 1;
1272        let canonical = format!("{value:e}");
1273        let round_up = discarded_index >= 0
1274            && canonical
1275                .bytes()
1276                .take_while(|byte| *byte != b'e')
1277                .filter(|byte| byte.is_ascii_digit())
1278                .nth(discarded_index as usize)
1279                .is_some_and(|digit| digit >= b'5');
1280        (libm::floor(scaled) + if round_up { 1.0 } else { 0.0 }) / factor
1281    }
1282
1283    async fn scientific(jvm: &Jvm, value: f64, precision: usize) -> Result<RustString> {
1284        let mut exponent = if value == 0.0 { 0 } else { libm::floor(libm::log10(value)) as i32 };
1285        let scale = libm::pow(10.0, exponent as f64);
1286        let mut mantissa = if value == 0.0 {
1287            0.0
1288        } else if value.to_bits() == 1 {
1289            // Java's canonical decimal representation of Double.MIN_VALUE is 4.9E-324.
1290            4.9
1291        } else if scale == 0.0 {
1292            value * 1.0e308 / libm::pow(10.0, (exponent + 308) as f64)
1293        } else {
1294            value / scale
1295        };
1296        mantissa = Self::round_fraction(mantissa, precision);
1297        if mantissa >= 10.0 {
1298            mantissa /= 10.0;
1299            exponent += 1;
1300        }
1301        let mantissa = Self::decimal(jvm, mantissa, precision).await?;
1302        let exponent_magnitude = exponent.unsigned_abs().to_string();
1303        let Some(capacity) = mantissa
1304            .len()
1305            .checked_add(exponent_magnitude.len())
1306            .and_then(|length| length.checked_add(3))
1307        else {
1308            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1309        };
1310        let mut output = RustString::new();
1311        if output.try_reserve_exact(capacity).is_err() {
1312            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1313        }
1314        output.push_str(&mantissa);
1315        output.push('e');
1316        output.push(if exponent < 0 { '-' } else { '+' });
1317        if exponent_magnitude.len() < 2 {
1318            output.push('0');
1319        }
1320        output.push_str(&exponent_magnitude);
1321        Ok(output)
1322    }
1323
1324    async fn finish_numeric(
1325        jvm: &Jvm,
1326        mut digits: RustString,
1327        negative: bool,
1328        prefix: RustString,
1329        specifier: &FormatSpecifier,
1330        grouping: bool,
1331        kind: NumericKind,
1332    ) -> Result<Vec<JavaChar>> {
1333        if grouping && matches!(kind, NumericKind::Finite) {
1334            let separator = digits.find(['.', 'e', 'E']).unwrap_or(digits.len());
1335            let integer = &digits[..separator];
1336            let suffix = &digits[separator..];
1337            let Some(capacity) = digits.len().checked_add(integer.len().saturating_sub(1) / 3) else {
1338                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1339            };
1340            let mut grouped = RustString::new();
1341            if grouped.try_reserve_exact(capacity).is_err() {
1342                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1343            }
1344            for (index, character) in integer.chars().enumerate() {
1345                if index > 0 && (integer.len() - index).is_multiple_of(3) {
1346                    grouped.push(',');
1347                }
1348                grouped.push(character);
1349            }
1350            grouped.push_str(suffix);
1351            digits = grouped;
1352        }
1353
1354        let parentheses = negative && specifier.flags.contains(&'(');
1355        let sign = if parentheses {
1356            ""
1357        } else if negative {
1358            "-"
1359        } else if !matches!(kind, NumericKind::Nan) && specifier.flags.contains(&'+') {
1360            "+"
1361        } else if !matches!(kind, NumericKind::Nan) && specifier.flags.contains(&' ') {
1362            " "
1363        } else {
1364            ""
1365        };
1366        let Some(fixed) = sign
1367            .len()
1368            .checked_add(prefix.len())
1369            .and_then(|length| length.checked_add(usize::from(parentheses) * 2))
1370        else {
1371            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1372        };
1373        if specifier.flags.contains(&'0') && !specifier.flags.contains(&'-') && matches!(kind, NumericKind::Finite) {
1374            let width = specifier.width.unwrap_or(0);
1375            let Some(current) = fixed.checked_add(digits.len()) else {
1376                return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1377            };
1378            if current < width {
1379                let padding_length = width - current;
1380                let Some(capacity) = padding_length.checked_add(digits.len()) else {
1381                    return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1382                };
1383                let mut padded = RustString::new();
1384                if padded.try_reserve_exact(capacity).is_err() {
1385                    return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1386                }
1387                for _ in 0..padding_length {
1388                    padded.push('0');
1389                }
1390                padded.push_str(&digits);
1391                digits = padded;
1392            }
1393        }
1394
1395        let Some(capacity) = fixed.checked_add(digits.len()) else {
1396            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1397        };
1398        let mut result = RustString::new();
1399        if result.try_reserve_exact(capacity).is_err() {
1400            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1401        }
1402        if parentheses {
1403            result.push('(');
1404        } else {
1405            result.push_str(sign);
1406        }
1407        result.push_str(&prefix);
1408        result.push_str(&digits);
1409        if parentheses {
1410            result.push(')');
1411        }
1412        let mut characters = Vec::new();
1413        if characters.try_reserve_exact(result.len()).is_err() {
1414            return Err(jvm.exception("java/lang/OutOfMemoryError", "formatted output is too large").await);
1415        }
1416        characters.extend(result.encode_utf16());
1417        Self::apply_width(jvm, characters, specifier, ' ' as JavaChar).await
1418    }
1419}