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, "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 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}