Skip to main content

rustjava_runtime/classes/java/text/
decimal_format.rs

1use alloc::{
2    format,
3    string::{String as RustString, ToString},
4    vec,
5    vec::Vec,
6};
7
8use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
9use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
10use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
11
12use crate::{
13    RuntimeClassProto, RuntimeContext,
14    classes::java::{
15        lang::{Double, Long, Number, String, StringBuffer},
16        text::{FieldPosition, ParsePosition},
17    },
18};
19
20struct DecimalPattern {
21    positive_prefix: RustString,
22    positive_suffix: RustString,
23    negative_prefix: RustString,
24    negative_suffix: RustString,
25    minimum_integer_digits: i32,
26    maximum_fraction_digits: i32,
27    minimum_fraction_digits: i32,
28    grouping_used: bool,
29    grouping_size: i32,
30    multiplier: i32,
31}
32
33// public class java.text.DecimalFormat
34pub struct DecimalFormat;
35
36impl DecimalFormat {
37    pub fn as_proto() -> RuntimeClassProto {
38        RuntimeClassProto {
39            name: "java/text/DecimalFormat",
40            parent_class: Some("java/text/NumberFormat"),
41            interfaces: vec![],
42            methods: vec![
43                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_pattern, MethodAccessFlags::PUBLIC),
45                JavaMethodProto::new(
46                    "format",
47                    "(DLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
48                    Self::format_double,
49                    MethodAccessFlags::PUBLIC,
50                ),
51                JavaMethodProto::new(
52                    "format",
53                    "(JLjava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
54                    Self::format_long,
55                    MethodAccessFlags::PUBLIC,
56                ),
57                JavaMethodProto::new(
58                    "parse",
59                    "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Number;",
60                    Self::parse,
61                    MethodAccessFlags::PUBLIC,
62                ),
63                JavaMethodProto::new("applyPattern", "(Ljava/lang/String;)V", Self::apply_pattern, MethodAccessFlags::PUBLIC),
64                JavaMethodProto::new("toPattern", "()Ljava/lang/String;", Self::to_pattern, MethodAccessFlags::PUBLIC),
65                JavaMethodProto::new("getMultiplier", "()I", Self::get_multiplier, MethodAccessFlags::PUBLIC),
66                JavaMethodProto::new("setMultiplier", "(I)V", Self::set_multiplier, MethodAccessFlags::PUBLIC),
67            ],
68            fields: vec![
69                JavaFieldProto::new("pattern", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
70                JavaFieldProto::new("positivePrefix", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
71                JavaFieldProto::new("positiveSuffix", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
72                JavaFieldProto::new("negativePrefix", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
73                JavaFieldProto::new("negativeSuffix", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
74                JavaFieldProto::new("multiplier", "I", FieldAccessFlags::PRIVATE),
75                JavaFieldProto::new("groupingSize", "I", FieldAccessFlags::PRIVATE),
76            ],
77            access_flags: ClassAccessFlags::PUBLIC,
78        }
79    }
80
81    fn parse_affix(value: &[char]) -> Option<(RustString, bool)> {
82        let mut result = RustString::new();
83        let mut percent = false;
84        let mut quoted = false;
85        let mut index = 0;
86        while index < value.len() {
87            if value[index] == '\'' {
88                if index + 1 < value.len() && value[index + 1] == '\'' {
89                    result.push('\'');
90                    index += 2;
91                    continue;
92                }
93                quoted = !quoted;
94                index += 1;
95                continue;
96            }
97            if !quoted && value[index] == '\u{00a4}' {
98                result.push('$');
99            } else {
100                if !quoted && value[index] == '%' {
101                    percent = true;
102                }
103                result.push(value[index]);
104            }
105            index += 1;
106        }
107        if quoted { None } else { Some((result, percent)) }
108    }
109
110    fn parse_subpattern(value: &[char]) -> Option<(RustString, Vec<char>, RustString, bool)> {
111        let mut quoted = false;
112        let mut numeric_start = None;
113        let mut index = 0;
114        while index < value.len() {
115            if value[index] == '\'' {
116                if index + 1 < value.len() && value[index + 1] == '\'' {
117                    index += 2;
118                    continue;
119                }
120                quoted = !quoted;
121            } else if !quoted && matches!(value[index], '#' | '0') {
122                numeric_start = Some(index);
123                break;
124            }
125            index += 1;
126        }
127        let numeric_start = numeric_start?;
128        let mut numeric_end = numeric_start;
129        while numeric_end < value.len() && matches!(value[numeric_end], '#' | '0' | ',' | '.') {
130            numeric_end += 1;
131        }
132        quoted = false;
133        index = numeric_end;
134        while index < value.len() {
135            if value[index] == '\'' {
136                if index + 1 < value.len() && value[index + 1] == '\'' {
137                    index += 2;
138                    continue;
139                }
140                quoted = !quoted;
141            } else if !quoted && matches!(value[index], '#' | '0' | ',' | '.') {
142                return None;
143            }
144            index += 1;
145        }
146        let (prefix, prefix_percent) = Self::parse_affix(&value[..numeric_start])?;
147        let (suffix, suffix_percent) = Self::parse_affix(&value[numeric_end..])?;
148        Some((
149            prefix,
150            value[numeric_start..numeric_end].to_vec(),
151            suffix,
152            prefix_percent || suffix_percent,
153        ))
154    }
155
156    fn parse_pattern_value(pattern: &str) -> Option<DecimalPattern> {
157        let characters: Vec<char> = pattern.chars().collect();
158        let mut quoted = false;
159        let mut separator = None;
160        let mut index = 0;
161        while index < characters.len() {
162            if characters[index] == '\'' {
163                if index + 1 < characters.len() && characters[index + 1] == '\'' {
164                    index += 2;
165                    continue;
166                }
167                quoted = !quoted;
168            } else if !quoted && characters[index] == ';' {
169                if separator.is_some() {
170                    return None;
171                }
172                separator = Some(index);
173            }
174            index += 1;
175        }
176        if quoted || characters.is_empty() {
177            return None;
178        }
179
180        let positive = &characters[..separator.unwrap_or(characters.len())];
181        let (positive_prefix, number, positive_suffix, positive_percent) = Self::parse_subpattern(positive)?;
182        if number.iter().filter(|character| **character == '.').count() > 1 {
183            return None;
184        }
185        let decimal_index = number.iter().position(|character| *character == '.').unwrap_or(number.len());
186        let integer_pattern = &number[..decimal_index];
187        let fraction_pattern = if decimal_index < number.len() {
188            &number[decimal_index + 1..]
189        } else {
190            &[]
191        };
192        if integer_pattern.is_empty()
193            || integer_pattern.iter().any(|character| !matches!(character, '#' | '0' | ','))
194            || fraction_pattern.iter().any(|character| !matches!(character, '#' | '0'))
195        {
196            return None;
197        }
198        let minimum_integer_digits = integer_pattern.iter().filter(|character| **character == '0').count() as i32;
199        let maximum_fraction_digits = fraction_pattern.len() as i32;
200        let minimum_fraction_digits = fraction_pattern.iter().filter(|character| **character == '0').count() as i32;
201        let grouping_position = integer_pattern.iter().rposition(|character| *character == ',');
202        let grouping_size = grouping_position
203            .map(|position| {
204                integer_pattern[position + 1..]
205                    .iter()
206                    .filter(|character| matches!(character, '#' | '0'))
207                    .count() as i32
208            })
209            .unwrap_or(0);
210        if grouping_position.is_some() && grouping_size == 0 {
211            return None;
212        }
213
214        let (negative_prefix, negative_suffix, negative_percent) = if let Some(separator) = separator {
215            let (prefix, negative_number, suffix, percent) = Self::parse_subpattern(&characters[separator + 1..])?;
216            if negative_number != number {
217                return None;
218            }
219            (prefix, suffix, percent)
220        } else {
221            (format!("-{positive_prefix}"), positive_suffix.clone(), positive_percent)
222        };
223
224        Some(DecimalPattern {
225            positive_prefix,
226            positive_suffix,
227            negative_prefix,
228            negative_suffix,
229            minimum_integer_digits,
230            maximum_fraction_digits,
231            minimum_fraction_digits,
232            grouping_used: grouping_position.is_some(),
233            grouping_size,
234            multiplier: if positive_percent || negative_percent { 100 } else { 1 },
235        })
236    }
237
238    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
239        let pattern = JavaLangString::from_rust_string(jvm, "#,##0.###").await?;
240        jvm.invoke_special(&this, "java/text/DecimalFormat", "<init>", "(Ljava/lang/String;)V", (pattern,))
241            .await
242    }
243
244    async fn init_with_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
245        if pattern.is_null() {
246            return Err(jvm.exception("java/lang/NullPointerException", "pattern").await);
247        }
248        let _: () = jvm.invoke_special(&this, "java/text/NumberFormat", "<init>", "()V", ()).await?;
249        jvm.invoke_virtual(&this, "java/text/DecimalFormat", "applyPattern", "(Ljava/lang/String;)V", (pattern,))
250            .await
251    }
252
253    async fn apply_pattern(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
254        if pattern.is_null() {
255            return Err(jvm.exception("java/lang/NullPointerException", "pattern").await);
256        }
257        let value = JavaLangString::to_rust_string(jvm, &pattern).await?;
258        let Some(parsed) = Self::parse_pattern_value(&value) else {
259            return Err(jvm.exception("java/lang/IllegalArgumentException", "Malformed pattern").await);
260        };
261
262        let positive_prefix = JavaLangString::from_rust_string(jvm, &parsed.positive_prefix).await?;
263        let positive_suffix = JavaLangString::from_rust_string(jvm, &parsed.positive_suffix).await?;
264        let negative_prefix = JavaLangString::from_rust_string(jvm, &parsed.negative_prefix).await?;
265        let negative_suffix = JavaLangString::from_rust_string(jvm, &parsed.negative_suffix).await?;
266        jvm.put_field(&mut this, "java/text/DecimalFormat", "pattern", "Ljava/lang/String;", pattern)
267            .await?;
268        jvm.put_field(
269            &mut this,
270            "java/text/DecimalFormat",
271            "positivePrefix",
272            "Ljava/lang/String;",
273            positive_prefix,
274        )
275        .await?;
276        jvm.put_field(
277            &mut this,
278            "java/text/DecimalFormat",
279            "positiveSuffix",
280            "Ljava/lang/String;",
281            positive_suffix,
282        )
283        .await?;
284        jvm.put_field(
285            &mut this,
286            "java/text/DecimalFormat",
287            "negativePrefix",
288            "Ljava/lang/String;",
289            negative_prefix,
290        )
291        .await?;
292        jvm.put_field(
293            &mut this,
294            "java/text/DecimalFormat",
295            "negativeSuffix",
296            "Ljava/lang/String;",
297            negative_suffix,
298        )
299        .await?;
300        jvm.put_field(&mut this, "java/text/DecimalFormat", "multiplier", "I", parsed.multiplier)
301            .await?;
302        jvm.put_field(&mut this, "java/text/DecimalFormat", "groupingSize", "I", parsed.grouping_size)
303            .await?;
304        jvm.put_field(&mut this, "java/text/DecimalFormat", "groupingUsed", "Z", parsed.grouping_used)
305            .await?;
306        jvm.put_field(&mut this, "java/text/DecimalFormat", "maximumIntegerDigits", "I", 309)
307            .await?;
308        jvm.put_field(
309            &mut this,
310            "java/text/DecimalFormat",
311            "minimumIntegerDigits",
312            "I",
313            parsed.minimum_integer_digits,
314        )
315        .await?;
316        jvm.put_field(
317            &mut this,
318            "java/text/DecimalFormat",
319            "maximumFractionDigits",
320            "I",
321            parsed.maximum_fraction_digits,
322        )
323        .await?;
324        jvm.put_field(
325            &mut this,
326            "java/text/DecimalFormat",
327            "minimumFractionDigits",
328            "I",
329            parsed.minimum_fraction_digits,
330        )
331        .await
332    }
333
334    async fn append_formatted(
335        jvm: &Jvm,
336        this: &ClassInstanceRef<Self>,
337        negative: bool,
338        mut integer: RustString,
339        mut fraction: RustString,
340        buffer: ClassInstanceRef<StringBuffer>,
341        position: ClassInstanceRef<FieldPosition>,
342    ) -> Result<ClassInstanceRef<StringBuffer>> {
343        if buffer.is_null() || position.is_null() {
344            return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await);
345        }
346        let minimum_integer_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "minimumIntegerDigits", "I").await?;
347        let maximum_integer_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "maximumIntegerDigits", "I").await?;
348        let minimum_fraction_digits: i32 = jvm.get_field(this, "java/text/DecimalFormat", "minimumFractionDigits", "I").await?;
349        let grouping_used: bool = jvm.get_field(this, "java/text/DecimalFormat", "groupingUsed", "Z").await?;
350        let grouping_size: i32 = jvm.get_field(this, "java/text/DecimalFormat", "groupingSize", "I").await?;
351
352        if integer.len() > maximum_integer_digits.max(0) as usize {
353            integer = integer[integer.len() - maximum_integer_digits.max(0) as usize..].to_string();
354        }
355        while integer.len() < minimum_integer_digits.max(0) as usize {
356            integer.insert(0, '0');
357        }
358        if integer.is_empty() {
359            integer.push('0');
360        }
361        if grouping_used && grouping_size > 0 {
362            let mut grouped = RustString::new();
363            for (index, character) in integer.chars().rev().enumerate() {
364                if index > 0 && index % grouping_size as usize == 0 {
365                    grouped.push(',');
366                }
367                grouped.push(character);
368            }
369            integer = grouped.chars().rev().collect();
370        }
371        while fraction.ends_with('0') && fraction.len() > minimum_fraction_digits.max(0) as usize {
372            fraction.pop();
373        }
374        while fraction.len() < minimum_fraction_digits.max(0) as usize {
375            fraction.push('0');
376        }
377
378        let prefix: ClassInstanceRef<String> = jvm
379            .get_field(
380                this,
381                "java/text/DecimalFormat",
382                if negative { "negativePrefix" } else { "positivePrefix" },
383                "Ljava/lang/String;",
384            )
385            .await?;
386        let suffix: ClassInstanceRef<String> = jvm
387            .get_field(
388                this,
389                "java/text/DecimalFormat",
390                if negative { "negativeSuffix" } else { "positiveSuffix" },
391                "Ljava/lang/String;",
392            )
393            .await?;
394        let prefix = JavaLangString::to_rust_string(jvm, &prefix).await?;
395        let suffix = JavaLangString::to_rust_string(jvm, &suffix).await?;
396        let mut formatted = format!("{prefix}{integer}");
397        if !fraction.is_empty() {
398            formatted.push('.');
399            formatted.push_str(&fraction);
400        }
401        formatted.push_str(&suffix);
402
403        let base: i32 = jvm.invoke_virtual(&buffer, "java/lang/StringBuffer", "length", "()I", ()).await?;
404        let field: i32 = jvm.invoke_virtual(&position, "java/text/FieldPosition", "getField", "()I", ()).await?;
405        if field == 0 {
406            let begin = base + prefix.encode_utf16().count() as i32;
407            let _: () = jvm
408                .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (begin,))
409                .await?;
410            let _: () = jvm
411                .invoke_virtual(
412                    &position,
413                    "java/text/FieldPosition",
414                    "setEndIndex",
415                    "(I)V",
416                    (begin + integer.encode_utf16().count() as i32,),
417                )
418                .await?;
419        } else if field == 1 && !fraction.is_empty() {
420            let begin = base + prefix.encode_utf16().count() as i32 + integer.encode_utf16().count() as i32 + 1;
421            let _: () = jvm
422                .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (begin,))
423                .await?;
424            let _: () = jvm
425                .invoke_virtual(
426                    &position,
427                    "java/text/FieldPosition",
428                    "setEndIndex",
429                    "(I)V",
430                    (begin + fraction.encode_utf16().count() as i32,),
431                )
432                .await?;
433        }
434
435        let text = JavaLangString::from_rust_string(jvm, &formatted).await?;
436        jvm.invoke_virtual(
437            &buffer,
438            "java/lang/StringBuffer",
439            "append",
440            "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
441            (text,),
442        )
443        .await
444    }
445
446    async fn format_double(
447        jvm: &Jvm,
448        _: &mut RuntimeContext,
449        this: ClassInstanceRef<Self>,
450        value: f64,
451        buffer: ClassInstanceRef<StringBuffer>,
452        position: ClassInstanceRef<FieldPosition>,
453    ) -> Result<ClassInstanceRef<StringBuffer>> {
454        if buffer.is_null() || position.is_null() {
455            return Err(jvm.exception("java/lang/NullPointerException", "buffer or position").await);
456        }
457        if value.is_nan() {
458            let text = JavaLangString::from_rust_string(jvm, "NaN").await?;
459            return jvm
460                .invoke_virtual(
461                    &buffer,
462                    "java/lang/StringBuffer",
463                    "append",
464                    "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
465                    (text,),
466                )
467                .await;
468        }
469
470        let negative = value.is_sign_negative();
471        let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?;
472        let scaled = value.abs() * f64::from(multiplier);
473        if scaled.is_infinite() {
474            return Self::append_formatted(jvm, &this, negative, "\u{221e}".to_string(), RustString::new(), buffer, position).await;
475        }
476        let maximum_fraction_digits: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "maximumFractionDigits", "I").await?;
477        let precision = maximum_fraction_digits.clamp(0, 340) as usize;
478        let numeric = format!("{scaled:.precision$}");
479        let (integer, fraction) = numeric
480            .split_once('.')
481            .map(|(integer, fraction)| (integer.to_string(), fraction.to_string()))
482            .unwrap_or((numeric, RustString::new()));
483        Self::append_formatted(jvm, &this, negative, integer, fraction, buffer, position).await
484    }
485
486    async fn format_long(
487        jvm: &Jvm,
488        _: &mut RuntimeContext,
489        this: ClassInstanceRef<Self>,
490        value: i64,
491        buffer: ClassInstanceRef<StringBuffer>,
492        position: ClassInstanceRef<FieldPosition>,
493    ) -> Result<ClassInstanceRef<StringBuffer>> {
494        let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?;
495        let scaled = i128::from(value) * i128::from(multiplier);
496        let negative = scaled < 0;
497        Self::append_formatted(
498            jvm,
499            &this,
500            negative,
501            scaled.unsigned_abs().to_string(),
502            RustString::new(),
503            buffer,
504            position,
505        )
506        .await
507    }
508
509    async fn parse(
510        jvm: &Jvm,
511        _: &mut RuntimeContext,
512        this: ClassInstanceRef<Self>,
513        source: ClassInstanceRef<String>,
514        position: ClassInstanceRef<ParsePosition>,
515    ) -> Result<ClassInstanceRef<Number>> {
516        if source.is_null() || position.is_null() {
517            return Err(jvm.exception("java/lang/NullPointerException", "source or position").await);
518        }
519        let source = JavaLangString::to_rust_string(jvm, &source).await?;
520        let characters: Vec<char> = source.chars().collect();
521        let mut utf16_indices = Vec::with_capacity(characters.len() + 1);
522        let mut utf16_index = 0;
523        for character in &characters {
524            utf16_indices.push(utf16_index);
525            utf16_index += character.len_utf16();
526        }
527        utf16_indices.push(utf16_index);
528        let start: i32 = jvm.invoke_virtual(&position, "java/text/ParsePosition", "getIndex", "()I", ()).await?;
529        if start < 0 {
530            let _: () = jvm
531                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
532                .await?;
533            return Ok(ClassInstanceRef::new(None));
534        }
535        let Some(start_index) = utf16_indices.iter().position(|index| *index == start as usize) else {
536            let _: () = jvm
537                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
538                .await?;
539            return Ok(ClassInstanceRef::new(None));
540        };
541
542        let positive_prefix: ClassInstanceRef<String> = jvm
543            .get_field(&this, "java/text/DecimalFormat", "positivePrefix", "Ljava/lang/String;")
544            .await?;
545        let positive_suffix: ClassInstanceRef<String> = jvm
546            .get_field(&this, "java/text/DecimalFormat", "positiveSuffix", "Ljava/lang/String;")
547            .await?;
548        let negative_prefix: ClassInstanceRef<String> = jvm
549            .get_field(&this, "java/text/DecimalFormat", "negativePrefix", "Ljava/lang/String;")
550            .await?;
551        let negative_suffix: ClassInstanceRef<String> = jvm
552            .get_field(&this, "java/text/DecimalFormat", "negativeSuffix", "Ljava/lang/String;")
553            .await?;
554        let positive_prefix: Vec<char> = JavaLangString::to_rust_string(jvm, &positive_prefix).await?.chars().collect();
555        let positive_suffix: Vec<char> = JavaLangString::to_rust_string(jvm, &positive_suffix).await?.chars().collect();
556        let negative_prefix: Vec<char> = JavaLangString::to_rust_string(jvm, &negative_prefix).await?.chars().collect();
557        let negative_suffix: Vec<char> = JavaLangString::to_rust_string(jvm, &negative_suffix).await?.chars().collect();
558
559        let mut index = start_index;
560        let prefix_negative = if characters[index..].starts_with(&negative_prefix) && negative_prefix != positive_prefix {
561            index += negative_prefix.len();
562            true
563        } else if characters[index..].starts_with(&positive_prefix) {
564            index += positive_prefix.len();
565            false
566        } else {
567            let _: () = jvm
568                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
569                .await?;
570            return Ok(ClassInstanceRef::new(None));
571        };
572
573        let parse_integer_only: bool = jvm.get_field(&this, "java/text/DecimalFormat", "parseIntegerOnly", "Z").await?;
574        let mut normalized = RustString::new();
575        let mut digits = 0;
576        let mut decimal = false;
577        while index < characters.len() {
578            match characters[index] {
579                '0'..='9' => {
580                    normalized.push(characters[index]);
581                    digits += 1;
582                    index += 1;
583                }
584                ',' if !decimal => index += 1,
585                '.' if !decimal && !parse_integer_only => {
586                    normalized.push('.');
587                    decimal = true;
588                    index += 1;
589                }
590                _ => break,
591            }
592        }
593        if digits == 0 {
594            let _: () = jvm
595                .invoke_virtual(
596                    &position,
597                    "java/text/ParsePosition",
598                    "setErrorIndex",
599                    "(I)V",
600                    (utf16_indices[index] as i32,),
601                )
602                .await?;
603            return Ok(ClassInstanceRef::new(None));
604        }
605        let negative = if negative_prefix == positive_prefix {
606            let positive_matches = characters[index..].starts_with(&positive_suffix);
607            let negative_matches = characters[index..].starts_with(&negative_suffix);
608            if negative_matches && (!positive_matches || negative_suffix.len() > positive_suffix.len()) {
609                index += negative_suffix.len();
610                true
611            } else if positive_matches {
612                index += positive_suffix.len();
613                false
614            } else {
615                let _: () = jvm
616                    .invoke_virtual(
617                        &position,
618                        "java/text/ParsePosition",
619                        "setErrorIndex",
620                        "(I)V",
621                        (utf16_indices[index] as i32,),
622                    )
623                    .await?;
624                return Ok(ClassInstanceRef::new(None));
625            }
626        } else {
627            let suffix = if prefix_negative { &negative_suffix } else { &positive_suffix };
628            if !characters[index..].starts_with(suffix) {
629                let _: () = jvm
630                    .invoke_virtual(
631                        &position,
632                        "java/text/ParsePosition",
633                        "setErrorIndex",
634                        "(I)V",
635                        (utf16_indices[index] as i32,),
636                    )
637                    .await?;
638                return Ok(ClassInstanceRef::new(None));
639            }
640            index += suffix.len();
641            prefix_negative
642        };
643        if negative {
644            normalized.insert(0, '-');
645        }
646
647        let Ok(mut value) = normalized.parse::<f64>() else {
648            let _: () = jvm
649                .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
650                .await?;
651            return Ok(ClassInstanceRef::new(None));
652        };
653        let multiplier: i32 = jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await?;
654        if multiplier != 0 {
655            value /= f64::from(multiplier);
656        }
657        let _: () = jvm
658            .invoke_virtual(&position, "java/text/ParsePosition", "setIndex", "(I)V", (utf16_indices[index] as i32,))
659            .await?;
660        let _: () = jvm
661            .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (-1,))
662            .await?;
663
664        if multiplier == 1
665            && !decimal
666            && let Ok(value) = normalized.parse::<i64>()
667        {
668            let result: ClassInstanceRef<Long> = jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into();
669            return Ok(ClassInstanceRef::new(result.instance));
670        }
671        if value.is_finite() && value.fract() == 0.0 && (-9_223_372_036_854_775_808.0..9_223_372_036_854_775_808.0).contains(&value) {
672            let result: ClassInstanceRef<Long> = jvm.new_class("java/lang/Long", "(J)V", (value as i64,)).await?.into();
673            return Ok(ClassInstanceRef::new(result.instance));
674        }
675        let result: ClassInstanceRef<Double> = jvm.new_class("java/lang/Double", "(D)V", (value,)).await?.into();
676        Ok(ClassInstanceRef::new(result.instance))
677    }
678
679    async fn to_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
680        jvm.get_field(&this, "java/text/DecimalFormat", "pattern", "Ljava/lang/String;").await
681    }
682
683    async fn get_multiplier(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
684        jvm.get_field(&this, "java/text/DecimalFormat", "multiplier", "I").await
685    }
686
687    async fn set_multiplier(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, multiplier: i32) -> Result<()> {
688        jvm.put_field(&mut this, "java/text/DecimalFormat", "multiplier", "I", multiplier).await
689    }
690}