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