Skip to main content

rustjava_runtime/classes/java/lang/
string.rs

1use alloc::{
2    format,
3    string::{String as RustString, ToString},
4    vec,
5    vec::Vec,
6};
7
8use bytemuck::{cast_slice, cast_vec};
9
10use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
11use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
12use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
13
14use crate::{
15    RuntimeClassProto, RuntimeContext,
16    classes::java::{
17        lang::{Object, System},
18        util::{
19            Formatter, Locale,
20            regex::{Matcher, Pattern},
21        },
22    },
23};
24
25use super::{CharSequence, StringBuffer};
26
27// class java.lang.String
28pub struct String;
29
30impl String {
31    pub fn as_proto() -> RuntimeClassProto {
32        RuntimeClassProto {
33            name: "java/lang/String",
34            parent_class: Some("java/lang/Object"),
35            interfaces: vec!["java/io/Serializable", "java/lang/Comparable", "java/lang/CharSequence"],
36            methods: vec![
37                JavaMethodProto::new("<init>", "()V", Self::init_empty, MethodAccessFlags::PUBLIC),
38                JavaMethodProto::new("<init>", "([B)V", Self::init_with_byte_array, MethodAccessFlags::PUBLIC),
39                JavaMethodProto::new("<init>", "([C)V", Self::init_with_char_array, MethodAccessFlags::PUBLIC),
40                JavaMethodProto::new("<init>", "([CII)V", Self::init_with_partial_char_array, MethodAccessFlags::PUBLIC),
41                JavaMethodProto::new("<init>", "(II[C)V", Self::init_with_shared_char_array, MethodAccessFlags::empty()),
42                JavaMethodProto::new("<init>", "([BII)V", Self::init_with_partial_byte_array, MethodAccessFlags::PUBLIC),
43                JavaMethodProto::new(
44                    "<init>",
45                    "([BLjava/lang/String;)V",
46                    Self::init_with_byte_array_charset,
47                    MethodAccessFlags::PUBLIC,
48                ),
49                JavaMethodProto::new(
50                    "<init>",
51                    "([BIILjava/lang/String;)V",
52                    Self::init_with_partial_byte_array_charset,
53                    MethodAccessFlags::PUBLIC,
54                ),
55                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_string, MethodAccessFlags::PUBLIC),
56                JavaMethodProto::new(
57                    "<init>",
58                    "(Ljava/lang/StringBuffer;)V",
59                    Self::init_with_string_buffer,
60                    MethodAccessFlags::PUBLIC,
61                ),
62                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
63                JavaMethodProto::new(
64                    "equalsIgnoreCase",
65                    "(Ljava/lang/String;)Z",
66                    Self::equals_ignore_case,
67                    MethodAccessFlags::PUBLIC,
68                ),
69                JavaMethodProto::new("compareTo", "(Ljava/lang/String;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
70                JavaMethodProto::new("compareTo", "(Ljava/lang/Object;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
71                JavaMethodProto::new(
72                    "compareToIgnoreCase",
73                    "(Ljava/lang/String;)I",
74                    Self::compare_to_ignore_case,
75                    MethodAccessFlags::PUBLIC,
76                ),
77                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
78                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
79                JavaMethodProto::new("charAt", "(I)C", Self::char_at, MethodAccessFlags::PUBLIC),
80                JavaMethodProto::new("getBytes", "()[B", Self::get_bytes, MethodAccessFlags::PUBLIC),
81                JavaMethodProto::new("getBytes", "(Ljava/lang/String;)[B", Self::get_bytes_charset, MethodAccessFlags::PUBLIC),
82                JavaMethodProto::new("getChars", "(II[CI)V", Self::get_chars, MethodAccessFlags::PUBLIC),
83                JavaMethodProto::new("toCharArray", "()[C", Self::to_char_array, MethodAccessFlags::PUBLIC),
84                JavaMethodProto::new("toUpperCase", "()Ljava/lang/String;", Self::to_upper_case, MethodAccessFlags::PUBLIC),
85                JavaMethodProto::new(
86                    "toUpperCase",
87                    "(Ljava/util/Locale;)Ljava/lang/String;",
88                    Self::to_upper_case_locale,
89                    MethodAccessFlags::PUBLIC,
90                ),
91                JavaMethodProto::new("toLowerCase", "()Ljava/lang/String;", Self::to_lower_case, MethodAccessFlags::PUBLIC),
92                JavaMethodProto::new(
93                    "toLowerCase",
94                    "(Ljava/util/Locale;)Ljava/lang/String;",
95                    Self::to_lower_case_locale,
96                    MethodAccessFlags::PUBLIC,
97                ),
98                JavaMethodProto::new("length", "()I", Self::length, MethodAccessFlags::PUBLIC),
99                JavaMethodProto::new(
100                    "concat",
101                    "(Ljava/lang/String;)Ljava/lang/String;",
102                    Self::concat,
103                    MethodAccessFlags::PUBLIC,
104                ),
105                JavaMethodProto::new("substring", "(I)Ljava/lang/String;", Self::substring, MethodAccessFlags::PUBLIC),
106                JavaMethodProto::new("substring", "(II)Ljava/lang/String;", Self::substring_with_end, MethodAccessFlags::PUBLIC),
107                JavaMethodProto::new(
108                    "subSequence",
109                    "(II)Ljava/lang/CharSequence;",
110                    Self::sub_sequence,
111                    MethodAccessFlags::PUBLIC,
112                ),
113                JavaMethodProto::new("replace", "(CC)Ljava/lang/String;", Self::replace, MethodAccessFlags::PUBLIC),
114                JavaMethodProto::new("matches", "(Ljava/lang/String;)Z", Self::matches, MethodAccessFlags::PUBLIC),
115                JavaMethodProto::new(
116                    "replaceFirst",
117                    "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
118                    Self::replace_first,
119                    MethodAccessFlags::PUBLIC,
120                ),
121                JavaMethodProto::new(
122                    "replaceAll",
123                    "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
124                    Self::replace_all,
125                    MethodAccessFlags::PUBLIC,
126                ),
127                JavaMethodProto::new("split", "(Ljava/lang/String;)[Ljava/lang/String;", Self::split, MethodAccessFlags::PUBLIC),
128                JavaMethodProto::new(
129                    "split",
130                    "(Ljava/lang/String;I)[Ljava/lang/String;",
131                    Self::split_with_limit,
132                    MethodAccessFlags::PUBLIC,
133                ),
134                JavaMethodProto::new(
135                    "format",
136                    "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
137                    Self::format,
138                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::VARARGS,
139                ),
140                JavaMethodProto::new(
141                    "format",
142                    "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
143                    Self::format_with_locale,
144                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::VARARGS,
145                ),
146                JavaMethodProto::new(
147                    "regionMatches",
148                    "(ILjava/lang/String;II)Z",
149                    Self::region_matches_case_sensitive,
150                    MethodAccessFlags::PUBLIC,
151                ),
152                JavaMethodProto::new(
153                    "regionMatches",
154                    "(ZILjava/lang/String;II)Z",
155                    Self::region_matches,
156                    MethodAccessFlags::PUBLIC,
157                ),
158                JavaMethodProto::new("valueOf", "(Z)Ljava/lang/String;", Self::value_of_boolean, MethodAccessFlags::STATIC),
159                JavaMethodProto::new("valueOf", "(C)Ljava/lang/String;", Self::value_of_char, MethodAccessFlags::STATIC),
160                JavaMethodProto::new("valueOf", "(I)Ljava/lang/String;", Self::value_of_integer, MethodAccessFlags::STATIC),
161                JavaMethodProto::new("valueOf", "(J)Ljava/lang/String;", Self::value_of_long, MethodAccessFlags::STATIC),
162                JavaMethodProto::new(
163                    "valueOf",
164                    "(F)Ljava/lang/String;",
165                    Self::value_of_float,
166                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
167                ),
168                JavaMethodProto::new(
169                    "valueOf",
170                    "(D)Ljava/lang/String;",
171                    Self::value_of_double,
172                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
173                ),
174                JavaMethodProto::new("valueOf", "([C)Ljava/lang/String;", Self::value_of_char_array, MethodAccessFlags::STATIC),
175                JavaMethodProto::new(
176                    "valueOf",
177                    "([CII)Ljava/lang/String;",
178                    Self::value_of_partial_char_array,
179                    MethodAccessFlags::STATIC,
180                ),
181                JavaMethodProto::new(
182                    "valueOf",
183                    "(Ljava/lang/Object;)Ljava/lang/String;",
184                    Self::value_of_object,
185                    MethodAccessFlags::STATIC,
186                ),
187                JavaMethodProto::new("indexOf", "(I)I", Self::index_of, MethodAccessFlags::PUBLIC),
188                JavaMethodProto::new("indexOf", "(II)I", Self::index_of_from, MethodAccessFlags::PUBLIC),
189                JavaMethodProto::new("indexOf", "(Ljava/lang/String;)I", Self::index_of_string, MethodAccessFlags::PUBLIC),
190                JavaMethodProto::new("indexOf", "(Ljava/lang/String;I)I", Self::index_of_string_from, MethodAccessFlags::PUBLIC),
191                JavaMethodProto::new("lastIndexOf", "(I)I", Self::last_index_of, MethodAccessFlags::PUBLIC),
192                JavaMethodProto::new("lastIndexOf", "(II)I", Self::last_index_of_from, MethodAccessFlags::PUBLIC),
193                JavaMethodProto::new(
194                    "lastIndexOf",
195                    "(Ljava/lang/String;)I",
196                    Self::last_index_of_string,
197                    MethodAccessFlags::PUBLIC,
198                ),
199                JavaMethodProto::new(
200                    "lastIndexOf",
201                    "(Ljava/lang/String;I)I",
202                    Self::last_index_of_string_from,
203                    MethodAccessFlags::PUBLIC,
204                ),
205                JavaMethodProto::new(
206                    "copyValueOf",
207                    "([C)Ljava/lang/String;",
208                    Self::copy_value_of,
209                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
210                ),
211                JavaMethodProto::new(
212                    "copyValueOf",
213                    "([CII)Ljava/lang/String;",
214                    Self::copy_value_of_range,
215                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
216                ),
217                JavaMethodProto::new("trim", "()Ljava/lang/String;", Self::trim, MethodAccessFlags::PUBLIC),
218                JavaMethodProto::new("startsWith", "(Ljava/lang/String;)Z", Self::starts_with, MethodAccessFlags::PUBLIC),
219                JavaMethodProto::new(
220                    "startsWith",
221                    "(Ljava/lang/String;I)Z",
222                    Self::starts_with_offset,
223                    MethodAccessFlags::PUBLIC,
224                ),
225                JavaMethodProto::new("endsWith", "(Ljava/lang/String;)Z", Self::ends_with, MethodAccessFlags::PUBLIC),
226                JavaMethodProto::new(
227                    "intern",
228                    "()Ljava/lang/String;",
229                    Self::intern,
230                    MethodAccessFlags::PUBLIC | MethodAccessFlags::NATIVE,
231                ),
232            ],
233            fields: vec![
234                JavaFieldProto::new("value", "[C", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
235                JavaFieldProto::new("offset", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
236                JavaFieldProto::new("count", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
237            ],
238            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
239        }
240    }
241
242    async fn value_range(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<(ClassInstanceRef<Array<JavaChar>>, usize, usize)> {
243        let value = jvm.get_field(this, "java/lang/String", "value", "[C").await?;
244        let offset: i32 = jvm.get_field(this, "java/lang/String", "offset", "I").await?;
245        let count: i32 = jvm.get_field(this, "java/lang/String", "count", "I").await?;
246
247        // access flags are not enforced, so bytecode can leave a negative here, which would widen into a huge usize
248        if offset < 0 || count < 0 {
249            return Err(jvm
250                .exception("java/lang/StringIndexOutOfBoundsException", &format!("offset {offset}, count {count}"))
251                .await);
252        }
253
254        Ok((value, offset as _, count as _))
255    }
256
257    async fn init_with_byte_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Array<i8>>) -> Result<()> {
258        tracing::debug!("java.lang.String::<init>({this:?}, {value:?})");
259
260        if value.is_null() {
261            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
262        }
263
264        let count = jvm.array_length(&value).await? as i32;
265
266        let _: () = jvm
267            .invoke_special(&this, "java/lang/String", "<init>", "([BII)V", (value, 0, count))
268            .await?;
269
270        Ok(())
271    }
272
273    async fn init_with_char_array(
274        jvm: &Jvm,
275        _: &mut RuntimeContext,
276        this: ClassInstanceRef<Self>,
277        value: ClassInstanceRef<Array<u16>>,
278    ) -> Result<()> {
279        tracing::debug!("java.lang.String::<init>({this:?}, {value:?})");
280
281        if value.is_null() {
282            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
283        }
284
285        let count = jvm.array_length(&value).await? as i32;
286
287        let _: () = jvm
288            .invoke_special(&this, "java/lang/String", "<init>", "([CII)V", (value, 0, count))
289            .await?;
290
291        Ok(())
292    }
293
294    async fn init_with_partial_char_array(
295        jvm: &Jvm,
296        _: &mut RuntimeContext,
297        mut this: ClassInstanceRef<Self>,
298        value: ClassInstanceRef<Array<u16>>,
299        offset: i32,
300        count: i32,
301    ) -> Result<()> {
302        tracing::debug!("java.lang.String::<init>({this:?}, {value:?}, {offset}, {count})");
303
304        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
305
306        if value.is_null() {
307            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
308        }
309        let length = jvm.array_length(&value).await? as i32;
310        if offset < 0 || count < 0 || offset > length - count {
311            return Err(jvm
312                .exception(
313                    "java/lang/StringIndexOutOfBoundsException",
314                    &format!("offset {offset}, count {count}, length {length}"),
315                )
316                .await);
317        }
318
319        let mut array = jvm.instantiate_array("C", count as _).await?;
320        let data: Vec<JavaChar> = jvm.load_array(&value, offset as _, count as _).await?;
321        jvm.store_array(&mut array, 0, data).await?;
322
323        jvm.put_field(&mut this, "java/lang/String", "value", "[C", array).await?;
324        jvm.put_field(&mut this, "java/lang/String", "offset", "I", 0).await?;
325        jvm.put_field(&mut this, "java/lang/String", "count", "I", count).await?;
326
327        Ok(())
328    }
329
330    // no validation; trusted internal callers pass a fresh array or an already-validated range
331    async fn init_with_shared_char_array(
332        jvm: &Jvm,
333        _: &mut RuntimeContext,
334        mut this: ClassInstanceRef<Self>,
335        offset: i32,
336        count: i32,
337        value: ClassInstanceRef<Array<JavaChar>>,
338    ) -> Result<()> {
339        tracing::debug!("java.lang.String::<init>({this:?}, {offset}, {count}, {value:?})");
340
341        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
342
343        if value.is_null() {
344            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
345        }
346        // this constructor is reachable from bytecode, since the runtime does not enforce access flags
347        let length = jvm.array_length(&value).await? as i64;
348        if offset < 0 || count < 0 || offset as i64 + count as i64 > length {
349            return Err(jvm
350                .exception(
351                    "java/lang/StringIndexOutOfBoundsException",
352                    &format!("offset {offset}, count {count}, length {length}"),
353                )
354                .await);
355        }
356
357        jvm.put_field(&mut this, "java/lang/String", "value", "[C", value).await?;
358        jvm.put_field(&mut this, "java/lang/String", "offset", "I", offset).await?;
359        jvm.put_field(&mut this, "java/lang/String", "count", "I", count).await?;
360
361        Ok(())
362    }
363
364    async fn init_with_partial_byte_array(
365        jvm: &Jvm,
366        _: &mut RuntimeContext,
367        this: ClassInstanceRef<Self>,
368        value: ClassInstanceRef<Array<i8>>,
369        offset: i32,
370        count: i32,
371    ) -> Result<()> {
372        tracing::debug!("java.lang.String::<init>({this:?}, {value:?}, {offset}, {count})");
373
374        if value.is_null() {
375            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
376        }
377
378        let bytes: Vec<i8> = jvm.load_array(&value, offset as _, count as _).await?;
379
380        let charset = System::get_charset(jvm).await?;
381        let string = Self::decode_str(&charset, cast_slice(&bytes)).unwrap_or_else(|| RustString::from_utf8_lossy(cast_slice(&bytes)).into_owned());
382
383        let utf16 = string.encode_utf16().collect::<Vec<_>>();
384
385        let length = utf16.len();
386        let mut array = jvm.instantiate_array("C", length).await?;
387        jvm.store_array(&mut array, 0, utf16).await?;
388
389        let _: () = jvm
390            .invoke_special(&this, "java/lang/String", "<init>", "(II[C)V", (0, length as i32, array))
391            .await?;
392
393        Ok(())
394    }
395
396    async fn init_with_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Self>) -> Result<()> {
397        tracing::debug!("java.lang.String::<init>({this:?}, {value:?})");
398
399        if value.is_null() {
400            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
401        }
402
403        let (original_value, offset, count) = Self::value_range(jvm, &value).await?;
404        let length = jvm.array_length(&original_value).await?;
405
406        // JDK 6 semantics: share a full-range original, but copy a substring so `new String(sub)` detaches from a large parent array
407        let value = if offset == 0 && count == length {
408            original_value
409        } else {
410            let chars: Vec<JavaChar> = jvm.load_array(&original_value, offset, count).await?;
411            let mut array = jvm.instantiate_array("C", count).await?;
412            jvm.store_array(&mut array, 0, chars).await?;
413
414            array.into()
415        };
416
417        let _: () = jvm
418            .invoke_special(&this, "java/lang/String", "<init>", "(II[C)V", (0, count as i32, value))
419            .await?;
420
421        Ok(())
422    }
423
424    async fn init_with_string_buffer(
425        jvm: &Jvm,
426        _: &mut RuntimeContext,
427        this: ClassInstanceRef<Self>,
428        value: ClassInstanceRef<StringBuffer>,
429    ) -> Result<()> {
430        tracing::debug!("java.lang.String::<init>({this:?}, {value:?})");
431
432        if value.is_null() {
433            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
434        }
435
436        let string: ClassInstanceRef<Self> = jvm
437            .invoke_virtual(&value, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
438            .await?;
439
440        let _: () = jvm
441            .invoke_special(&this, "java/lang/String", "<init>", "(Ljava/lang/String;)V", (string,))
442            .await?;
443
444        Ok(())
445    }
446
447    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
448        tracing::debug!("java.lang.String::equals({this:?}, {other:?})");
449
450        if other.is_null() || !jvm.is_instance(&**other, "java/lang/String") {
451            return Ok(false);
452        }
453        if this.identity() == other.identity() {
454            return Ok(true);
455        }
456
457        let this_count: i32 = jvm.get_field(&this, "java/lang/String", "count", "I").await?;
458        let other_count: i32 = jvm.get_field(&other, "java/lang/String", "count", "I").await?;
459        if this_count != other_count {
460            return Ok(false);
461        }
462
463        let this_chars = JavaLangString::to_utf16(jvm, &this).await?;
464        let other_chars = JavaLangString::to_utf16(jvm, &other).await?;
465
466        Ok(this_chars == other_chars)
467    }
468
469    async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
470        tracing::debug!("java.lang.String::compareTo({this:?}, {other:?})");
471
472        if other.is_null() {
473            return Err(jvm.exception("java/lang/NullPointerException", "anotherString is null").await);
474        }
475        if !jvm.is_instance(&**other, "java/lang/String") {
476            return Err(jvm.exception("java/lang/ClassCastException", &other.class_definition().name()).await);
477        }
478
479        let other: ClassInstanceRef<Self> = ClassInstanceRef::new(other.instance);
480        let this_chars = JavaLangString::to_utf16(jvm, &this).await?;
481        let other_chars = JavaLangString::to_utf16(jvm, &other).await?;
482
483        for (&this_char, &other_char) in this_chars.iter().zip(&other_chars) {
484            if this_char != other_char {
485                return Ok(this_char as i32 - other_char as i32);
486            }
487        }
488
489        Ok(this_chars.len() as i32 - other_chars.len() as i32)
490    }
491
492    async fn compare_to_ignore_case(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
493        tracing::debug!("java.lang.String::compareToIgnoreCase({this:?}, {other:?})");
494
495        if other.is_null() {
496            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
497        }
498
499        let this_chars = JavaLangString::to_utf16(jvm, &this).await?;
500        let other_chars = JavaLangString::to_utf16(jvm, &other).await?;
501
502        for (&this_char, &other_char) in this_chars.iter().zip(&other_chars) {
503            if this_char == other_char {
504                continue;
505            }
506
507            let this_folded = if this_char <= 0x7f {
508                (this_char as u8).to_ascii_lowercase() as JavaChar
509            } else {
510                char::from_u32(this_char as u32)
511                    .and_then(|value| value.to_uppercase().next())
512                    .and_then(|value| value.to_lowercase().next())
513                    .map(|value| value as JavaChar)
514                    .unwrap_or(this_char)
515            };
516            let other_folded = if other_char <= 0x7f {
517                (other_char as u8).to_ascii_lowercase() as JavaChar
518            } else {
519                char::from_u32(other_char as u32)
520                    .and_then(|value| value.to_uppercase().next())
521                    .and_then(|value| value.to_lowercase().next())
522                    .map(|value| value as JavaChar)
523                    .unwrap_or(other_char)
524            };
525            if this_folded != other_folded {
526                return Ok(this_folded as i32 - other_folded as i32);
527            }
528        }
529
530        Ok(this_chars.len() as i32 - other_chars.len() as i32)
531    }
532
533    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
534        tracing::debug!("java.lang.String::hashCode({this:?})");
535
536        let chars = JavaLangString::to_utf16(jvm, &this).await?;
537
538        let hash = chars.iter().fold(0i32, |acc, &c| acc.wrapping_mul(31).wrapping_add(c as i32));
539
540        Ok(hash)
541    }
542
543    async fn to_string(_jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
544        tracing::debug!("java.lang.String::toString({this:?})");
545
546        Ok(this)
547    }
548
549    async fn char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<u16> {
550        tracing::debug!("java.lang.String::charAt({this:?}, {index})");
551
552        let (value, offset, count) = Self::value_range(jvm, &this).await?;
553        if index < 0 || index as usize >= count {
554            return Err(jvm
555                .exception("java/lang/StringIndexOutOfBoundsException", &format!("index {index}, length {count}"))
556                .await);
557        }
558
559        Ok(jvm.load_array(&value, offset + index as usize, 1).await?[0])
560    }
561
562    async fn concat(
563        jvm: &Jvm,
564        _: &mut RuntimeContext,
565        this: ClassInstanceRef<Self>,
566        other: ClassInstanceRef<Self>,
567    ) -> Result<ClassInstanceRef<Self>> {
568        tracing::debug!("java.lang.String::concat({this:?}, {other:?})");
569
570        if other.is_null() {
571            return Err(jvm.exception("java/lang/NullPointerException", "other is null").await);
572        }
573
574        let this_string = JavaLangString::to_rust_string(jvm, &this.clone()).await?;
575        let other_string = JavaLangString::to_rust_string(jvm, &other.clone()).await?;
576
577        let concat = this_string + &other_string;
578
579        Ok(JavaLangString::from_rust_string(jvm, &concat).await?.into())
580    }
581
582    async fn get_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<i8>>> {
583        tracing::debug!("java.lang.String::getBytes({this:?})");
584
585        let string = JavaLangString::to_rust_string(jvm, &this.clone()).await?;
586
587        let charset = System::get_charset(jvm).await?;
588        let bytes = cast_vec(Self::encode_str(&charset, &string).unwrap_or_else(|| string.as_bytes().to_vec()));
589
590        let mut byte_array = jvm.instantiate_array("B", bytes.len()).await?;
591        jvm.array_raw_buffer_mut(&mut byte_array).await?.write(0, &bytes)?;
592
593        Ok(byte_array.into())
594    }
595
596    async fn get_chars(
597        jvm: &Jvm,
598        _: &mut RuntimeContext,
599        this: ClassInstanceRef<Self>,
600        src_begin: i32,
601        src_end: i32,
602        mut dst: ClassInstanceRef<Array<JavaChar>>,
603        dst_begin: i32,
604    ) -> Result<()> {
605        tracing::debug!("java.lang.String::getChars({this:?}, {src_begin}, {src_end}, {dst:?}, {dst_begin})");
606
607        let (value, offset, count) = Self::value_range(jvm, &this).await?;
608        if src_begin < 0 || src_begin > src_end || src_end as usize > count {
609            return Err(jvm
610                .exception(
611                    "java/lang/StringIndexOutOfBoundsException",
612                    &format!("begin {src_begin}, end {src_end}, length {count}"),
613                )
614                .await);
615        }
616
617        if dst.is_null() {
618            return Err(jvm.exception("java/lang/NullPointerException", "dst is null").await);
619        }
620        let chars: Vec<JavaChar> = jvm
621            .load_array(&value, offset + src_begin as usize, (src_end - src_begin) as usize)
622            .await?;
623        jvm.store_array(&mut dst, dst_begin as _, chars).await?;
624
625        Ok(())
626    }
627
628    async fn to_char_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<JavaChar>>> {
629        tracing::debug!("java.lang.String::toCharArray({this:?})");
630
631        let (value, offset, count) = Self::value_range(jvm, &this).await?;
632        let chars: Vec<JavaChar> = jvm.load_array(&value, offset, count).await?;
633
634        let mut array = jvm.instantiate_array("C", count).await?;
635        jvm.store_array(&mut array, 0, chars).await?;
636
637        Ok(array.into())
638    }
639
640    async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
641        tracing::debug!("java.lang.String::length({this:?})");
642
643        jvm.get_field(&this, "java/lang/String", "count", "I").await
644    }
645
646    async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, begin_index: i32) -> Result<ClassInstanceRef<Self>> {
647        tracing::debug!("java.lang.String::substring({this:?}, {begin_index})");
648
649        let (value, offset, count) = Self::value_range(jvm, &this).await?;
650        if begin_index < 0 || begin_index as usize > count {
651            return Err(jvm
652                .exception(
653                    "java/lang/StringIndexOutOfBoundsException",
654                    &format!("begin {begin_index}, length {count}"),
655                )
656                .await);
657        }
658        if begin_index == 0 {
659            return Ok(this);
660        }
661
662        let new_string = jvm
663            .new_class(
664                "java/lang/String",
665                "(II[C)V",
666                ((offset + begin_index as usize) as i32, (count - begin_index as usize) as i32, value),
667            )
668            .await?;
669
670        Ok(new_string.into())
671    }
672
673    async fn substring_with_end(
674        jvm: &Jvm,
675        _: &mut RuntimeContext,
676        this: ClassInstanceRef<Self>,
677        begin_index: i32,
678        end_index: i32,
679    ) -> Result<ClassInstanceRef<Self>> {
680        tracing::debug!("java.lang.String::substring({this:?}, {begin_index}, {end_index})");
681
682        let (value, offset, count) = Self::value_range(jvm, &this).await?;
683        if begin_index < 0 || end_index as usize > count || begin_index > end_index {
684            return Err(jvm
685                .exception(
686                    "java/lang/StringIndexOutOfBoundsException",
687                    &format!("begin {begin_index}, end {end_index}, length {count}"),
688                )
689                .await);
690        }
691        if begin_index == 0 && end_index as usize == count {
692            return Ok(this);
693        }
694
695        let new_string = jvm
696            .new_class(
697                "java/lang/String",
698                "(II[C)V",
699                ((offset + begin_index as usize) as i32, end_index - begin_index, value),
700            )
701            .await?;
702
703        Ok(new_string.into())
704    }
705
706    async fn sub_sequence(
707        jvm: &Jvm,
708        _: &mut RuntimeContext,
709        this: ClassInstanceRef<Self>,
710        begin_index: i32,
711        end_index: i32,
712    ) -> Result<ClassInstanceRef<CharSequence>> {
713        tracing::debug!("java.lang.String::subSequence({this:?}, {begin_index}, {end_index})");
714
715        jvm.invoke_virtual(&this, "java/lang/String", "substring", "(II)Ljava/lang/String;", (begin_index, end_index))
716            .await
717    }
718
719    async fn value_of_char(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<ClassInstanceRef<Self>> {
720        tracing::debug!("java.lang.String::valueOf({value})");
721
722        // build through [C so an unpaired surrogate is preserved
723        let mut chars = jvm.instantiate_array("C", 1).await?;
724        jvm.store_array(&mut chars, 0, [value]).await?;
725
726        Ok(jvm.new_class("java/lang/String", "(II[C)V", (0, 1, chars)).await?.into())
727    }
728
729    async fn value_of_integer(jvm: &Jvm, _: &mut RuntimeContext, value: i32) -> Result<ClassInstanceRef<Self>> {
730        tracing::debug!("java.lang.String::valueOf({value})");
731
732        let string = value.to_string();
733
734        Ok(JavaLangString::from_rust_string(jvm, &string).await?.into())
735    }
736
737    async fn value_of_object(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Self>> {
738        tracing::warn!("stub java.lang.String::valueOf({value:?})");
739
740        Ok(if value.is_null() {
741            JavaLangString::from_rust_string(jvm, "null").await?.into()
742        } else {
743            jvm.invoke_virtual(&value, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
744                .await?
745        })
746    }
747
748    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, ch: i32) -> Result<i32> {
749        tracing::debug!("java.lang.String::indexOf({this:?}, {ch:?})");
750
751        jvm.invoke_virtual(&this, "java/lang/String", "indexOf", "(II)I", (ch, 0)).await
752    }
753
754    async fn index_of_from(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, ch: i32, from_index: i32) -> Result<i32> {
755        tracing::debug!("java.lang.String::indexOf({this:?}, {ch:?}, {from_index:?})");
756
757        if !(0..=u16::MAX as i32).contains(&ch) {
758            return Ok(-1);
759        }
760
761        let chars = JavaLangString::to_utf16(jvm, &this).await?;
762        let from_index = from_index.max(0) as usize;
763        let index = chars
764            .get(from_index..)
765            .and_then(|chars| chars.iter().position(|&value| value == ch as u16))
766            .map(|index| index + from_index);
767
768        Ok(index.map(|index| index as i32).unwrap_or(-1))
769    }
770
771    async fn index_of_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, str: ClassInstanceRef<Self>) -> Result<i32> {
772        tracing::debug!("java.lang.String::indexOf({this:?}, {str:?})");
773
774        jvm.invoke_virtual(&this, "java/lang/String", "indexOf", "(Ljava/lang/String;I)I", (str, 0))
775            .await
776    }
777
778    async fn index_of_string_from(
779        jvm: &Jvm,
780        _: &mut RuntimeContext,
781        this: ClassInstanceRef<Self>,
782        str: ClassInstanceRef<Self>,
783        from_index: i32,
784    ) -> Result<i32> {
785        tracing::debug!("java.lang.String::indexOf({this:?}, {str:?}, {from_index})");
786
787        if str.is_null() {
788            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
789        }
790
791        let chars = JavaLangString::to_utf16(jvm, &this).await?;
792        let pattern = JavaLangString::to_utf16(jvm, &str).await?;
793        let from_index = (from_index.max(0) as usize).min(chars.len());
794
795        if pattern.is_empty() {
796            return Ok(from_index as i32);
797        }
798
799        let index = chars[from_index..]
800            .windows(pattern.len())
801            .position(|window| window == pattern)
802            .map(|index| index + from_index);
803
804        Ok(index.map(|index| index as i32).unwrap_or(-1))
805    }
806
807    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, ch: i32) -> Result<i32> {
808        tracing::debug!("java.lang.String::lastIndexOf({this:?}, {ch:?})");
809
810        if !(0..=u16::MAX as i32).contains(&ch) {
811            return Ok(-1);
812        }
813
814        let chars = JavaLangString::to_utf16(jvm, &this).await?;
815        let index = chars.iter().rposition(|&value| value == ch as u16).map(|index| index as i32);
816
817        Ok(index.unwrap_or(-1))
818    }
819
820    async fn trim(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
821        tracing::debug!("java.lang.String::trim({this:?})");
822
823        let (value, offset, count) = Self::value_range(jvm, &this).await?;
824        let chars: Vec<JavaChar> = jvm.load_array(&value, offset, count).await?;
825        let start = chars.iter().position(|&value| value > 0x20).unwrap_or(chars.len());
826        let end = chars.iter().rposition(|&value| value > 0x20).map(|index| index + 1).unwrap_or(start);
827        if start == 0 && end == chars.len() {
828            return Ok(this);
829        }
830
831        Ok(jvm
832            .new_class("java/lang/String", "(II[C)V", ((offset + start) as i32, (end - start) as i32, value))
833            .await?
834            .into())
835    }
836
837    async fn to_upper_case(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
838        tracing::debug!("java.lang.String::toUpperCase({this:?})");
839
840        let string = JavaLangString::to_rust_string(jvm, &this.clone()).await?;
841
842        let upper = string.to_uppercase().to_string();
843
844        Ok(JavaLangString::from_rust_string(jvm, &upper).await?.into())
845    }
846
847    async fn to_upper_case_locale(
848        jvm: &Jvm,
849        _: &mut RuntimeContext,
850        this: ClassInstanceRef<Self>,
851        locale: ClassInstanceRef<Object>,
852    ) -> Result<ClassInstanceRef<Self>> {
853        tracing::debug!("java.lang.String::toUpperCase({this:?}, {locale:?})");
854
855        if locale.is_null() {
856            return Err(jvm.exception("java/lang/NullPointerException", "locale is null").await);
857        }
858
859        jvm.invoke_virtual(&this, "java/lang/String", "toUpperCase", "()Ljava/lang/String;", ())
860            .await
861    }
862
863    async fn starts_with(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, prefix: ClassInstanceRef<Self>) -> Result<bool> {
864        tracing::debug!("java.lang.String::startsWith({this:?}, {prefix:?})");
865
866        jvm.invoke_virtual(&this, "java/lang/String", "startsWith", "(Ljava/lang/String;I)Z", (prefix, 0))
867            .await
868    }
869
870    async fn starts_with_offset(
871        jvm: &Jvm,
872        _: &mut RuntimeContext,
873        this: ClassInstanceRef<Self>,
874        prefix: ClassInstanceRef<Self>,
875        offset: i32,
876    ) -> Result<bool> {
877        tracing::debug!("java.lang.String::startsWith({this:?}, {prefix:?}, {offset})");
878
879        if prefix.is_null() {
880            return Err(jvm.exception("java/lang/NullPointerException", "prefix is null").await);
881        }
882        if offset < 0 {
883            return Ok(false);
884        }
885
886        let chars = JavaLangString::to_utf16(jvm, &this).await?;
887        let prefix = JavaLangString::to_utf16(jvm, &prefix).await?;
888
889        Ok(chars.get(offset as usize..).is_some_and(|chars| chars.starts_with(&prefix)))
890    }
891
892    async fn init_empty(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
893        tracing::debug!("java.lang.String::<init>({this:?})");
894
895        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
896
897        let array = jvm.instantiate_array("C", 0).await?;
898        jvm.put_field(&mut this, "java/lang/String", "value", "[C", array).await?;
899        jvm.put_field(&mut this, "java/lang/String", "offset", "I", 0).await?;
900        jvm.put_field(&mut this, "java/lang/String", "count", "I", 0).await?;
901
902        Ok(())
903    }
904
905    async fn init_with_byte_array_charset(
906        jvm: &Jvm,
907        _: &mut RuntimeContext,
908        this: ClassInstanceRef<Self>,
909        value: ClassInstanceRef<Array<i8>>,
910        charset_name: ClassInstanceRef<Self>,
911    ) -> Result<()> {
912        tracing::debug!("java.lang.String::<init>({this:?}, {value:?}, {charset_name:?})");
913
914        if value.is_null() {
915            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
916        }
917
918        let count = jvm.array_length(&value).await? as i32;
919
920        let _: () = jvm
921            .invoke_special(
922                &this,
923                "java/lang/String",
924                "<init>",
925                "([BIILjava/lang/String;)V",
926                (value, 0, count, charset_name),
927            )
928            .await?;
929
930        Ok(())
931    }
932
933    async fn init_with_partial_byte_array_charset(
934        jvm: &Jvm,
935        _: &mut RuntimeContext,
936        this: ClassInstanceRef<Self>,
937        value: ClassInstanceRef<Array<i8>>,
938        offset: i32,
939        count: i32,
940        charset_name: ClassInstanceRef<Self>,
941    ) -> Result<()> {
942        tracing::debug!("java.lang.String::<init>({this:?}, {value:?}, {offset}, {count}, {charset_name:?})");
943
944        if charset_name.is_null() {
945            return Err(jvm.exception("java/lang/NullPointerException", "charsetName is null").await);
946        }
947
948        if value.is_null() {
949            return Err(jvm.exception("java/lang/NullPointerException", "value is null").await);
950        }
951
952        let bytes: Vec<i8> = jvm.load_array(&value, offset as _, count as _).await?;
953
954        let charset = JavaLangString::to_rust_string(jvm, &charset_name).await?;
955        let Some(string) = Self::decode_str(&charset, cast_slice(&bytes)) else {
956            return Err(jvm.exception("java/io/UnsupportedEncodingException", &charset).await);
957        };
958
959        let utf16 = string.encode_utf16().collect::<Vec<_>>();
960
961        let length = utf16.len();
962        let mut array = jvm.instantiate_array("C", length).await?;
963        jvm.store_array(&mut array, 0, utf16).await?;
964
965        let _: () = jvm
966            .invoke_special(&this, "java/lang/String", "<init>", "(II[C)V", (0, length as i32, array))
967            .await?;
968
969        Ok(())
970    }
971
972    async fn equals_ignore_case(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<bool> {
973        tracing::debug!("java.lang.String::equalsIgnoreCase({this:?}, {other:?})");
974
975        if other.is_null() {
976            return Ok(false);
977        }
978
979        let this_string = JavaLangString::to_rust_string(jvm, &this).await?;
980        let other_string = JavaLangString::to_rust_string(jvm, &other).await?;
981
982        Ok(this_string.eq_ignore_ascii_case(&other_string) || this_string.to_lowercase() == other_string.to_lowercase())
983    }
984
985    async fn get_bytes_charset(
986        jvm: &Jvm,
987        _: &mut RuntimeContext,
988        this: ClassInstanceRef<Self>,
989        charset_name: ClassInstanceRef<Self>,
990    ) -> Result<ClassInstanceRef<Array<i8>>> {
991        tracing::debug!("java.lang.String::getBytes({this:?}, {charset_name:?})");
992
993        if charset_name.is_null() {
994            return Err(jvm.exception("java/lang/NullPointerException", "charsetName is null").await);
995        }
996
997        let string = JavaLangString::to_rust_string(jvm, &this).await?;
998        let charset = JavaLangString::to_rust_string(jvm, &charset_name).await?;
999
1000        let Some(bytes) = Self::encode_str(&charset, &string) else {
1001            return Err(jvm.exception("java/io/UnsupportedEncodingException", &charset).await);
1002        };
1003        let bytes = cast_vec(bytes);
1004
1005        let mut byte_array = jvm.instantiate_array("B", bytes.len()).await?;
1006        jvm.array_raw_buffer_mut(&mut byte_array).await?.write(0, &bytes)?;
1007
1008        Ok(byte_array.into())
1009    }
1010
1011    async fn to_lower_case(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
1012        tracing::debug!("java.lang.String::toLowerCase({this:?})");
1013
1014        let string = JavaLangString::to_rust_string(jvm, &this).await?;
1015        let lower = string.to_lowercase();
1016
1017        Ok(JavaLangString::from_rust_string(jvm, &lower).await?.into())
1018    }
1019
1020    async fn to_lower_case_locale(
1021        jvm: &Jvm,
1022        _: &mut RuntimeContext,
1023        this: ClassInstanceRef<Self>,
1024        locale: ClassInstanceRef<Object>,
1025    ) -> Result<ClassInstanceRef<Self>> {
1026        tracing::debug!("java.lang.String::toLowerCase({this:?}, {locale:?})");
1027
1028        if locale.is_null() {
1029            return Err(jvm.exception("java/lang/NullPointerException", "locale is null").await);
1030        }
1031
1032        jvm.invoke_virtual(&this, "java/lang/String", "toLowerCase", "()Ljava/lang/String;", ())
1033            .await
1034    }
1035
1036    async fn replace(
1037        jvm: &Jvm,
1038        _: &mut RuntimeContext,
1039        this: ClassInstanceRef<Self>,
1040        old_char: JavaChar,
1041        new_char: JavaChar,
1042    ) -> Result<ClassInstanceRef<Self>> {
1043        tracing::debug!("java.lang.String::replace({this:?}, {old_char}, {new_char})");
1044
1045        let chars = JavaLangString::to_utf16(jvm, &this).await?;
1046
1047        let replaced: Vec<JavaChar> = chars.into_iter().map(|c| if c == old_char { new_char } else { c }).collect();
1048
1049        let length = replaced.len();
1050        let mut array = jvm.instantiate_array("C", length).await?;
1051        jvm.store_array(&mut array, 0, replaced).await?;
1052
1053        let new_string = jvm.new_class("java/lang/String", "(II[C)V", (0, length as i32, array)).await?;
1054
1055        Ok(new_string.into())
1056    }
1057
1058    async fn matches(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, regex: ClassInstanceRef<Self>) -> Result<bool> {
1059        tracing::debug!("java.lang.String::matches({this:?}, {regex:?})");
1060
1061        let input: ClassInstanceRef<CharSequence> = ClassInstanceRef::new(this.instance);
1062        jvm.invoke_static(
1063            "java/util/regex/Pattern",
1064            "matches",
1065            "(Ljava/lang/String;Ljava/lang/CharSequence;)Z",
1066            (regex, input),
1067        )
1068        .await
1069    }
1070
1071    async fn replace_first(
1072        jvm: &Jvm,
1073        _: &mut RuntimeContext,
1074        this: ClassInstanceRef<Self>,
1075        regex: ClassInstanceRef<Self>,
1076        replacement: ClassInstanceRef<Self>,
1077    ) -> Result<ClassInstanceRef<Self>> {
1078        tracing::debug!("java.lang.String::replaceFirst({this:?}, {regex:?}, {replacement:?})");
1079
1080        let pattern: ClassInstanceRef<Pattern> = jvm
1081            .invoke_static(
1082                "java/util/regex/Pattern",
1083                "compile",
1084                "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
1085                (regex,),
1086            )
1087            .await?;
1088        let input: ClassInstanceRef<CharSequence> = ClassInstanceRef::new(this.instance);
1089        let matcher: ClassInstanceRef<Matcher> = jvm
1090            .invoke_virtual(
1091                &pattern,
1092                "java/util/regex/Pattern",
1093                "matcher",
1094                "(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;",
1095                (input,),
1096            )
1097            .await?;
1098        jvm.invoke_virtual(
1099            &matcher,
1100            "java/util/regex/Matcher",
1101            "replaceFirst",
1102            "(Ljava/lang/String;)Ljava/lang/String;",
1103            (replacement,),
1104        )
1105        .await
1106    }
1107
1108    async fn replace_all(
1109        jvm: &Jvm,
1110        _: &mut RuntimeContext,
1111        this: ClassInstanceRef<Self>,
1112        regex: ClassInstanceRef<Self>,
1113        replacement: ClassInstanceRef<Self>,
1114    ) -> Result<ClassInstanceRef<Self>> {
1115        tracing::debug!("java.lang.String::replaceAll({this:?}, {regex:?}, {replacement:?})");
1116
1117        let pattern: ClassInstanceRef<Pattern> = jvm
1118            .invoke_static(
1119                "java/util/regex/Pattern",
1120                "compile",
1121                "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
1122                (regex,),
1123            )
1124            .await?;
1125        let input: ClassInstanceRef<CharSequence> = ClassInstanceRef::new(this.instance);
1126        let matcher: ClassInstanceRef<Matcher> = jvm
1127            .invoke_virtual(
1128                &pattern,
1129                "java/util/regex/Pattern",
1130                "matcher",
1131                "(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;",
1132                (input,),
1133            )
1134            .await?;
1135        jvm.invoke_virtual(
1136            &matcher,
1137            "java/util/regex/Matcher",
1138            "replaceAll",
1139            "(Ljava/lang/String;)Ljava/lang/String;",
1140            (replacement,),
1141        )
1142        .await
1143    }
1144
1145    async fn split(
1146        jvm: &Jvm,
1147        _: &mut RuntimeContext,
1148        this: ClassInstanceRef<Self>,
1149        regex: ClassInstanceRef<Self>,
1150    ) -> Result<ClassInstanceRef<Array<Self>>> {
1151        tracing::debug!("java.lang.String::split({this:?}, {regex:?})");
1152
1153        let pattern: ClassInstanceRef<Pattern> = jvm
1154            .invoke_static(
1155                "java/util/regex/Pattern",
1156                "compile",
1157                "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
1158                (regex,),
1159            )
1160            .await?;
1161        let input: ClassInstanceRef<CharSequence> = ClassInstanceRef::new(this.instance);
1162        jvm.invoke_virtual(
1163            &pattern,
1164            "java/util/regex/Pattern",
1165            "split",
1166            "(Ljava/lang/CharSequence;)[Ljava/lang/String;",
1167            (input,),
1168        )
1169        .await
1170    }
1171
1172    async fn split_with_limit(
1173        jvm: &Jvm,
1174        _: &mut RuntimeContext,
1175        this: ClassInstanceRef<Self>,
1176        regex: ClassInstanceRef<Self>,
1177        limit: i32,
1178    ) -> Result<ClassInstanceRef<Array<Self>>> {
1179        tracing::debug!("java.lang.String::split({this:?}, {regex:?}, {limit})");
1180
1181        let pattern: ClassInstanceRef<Pattern> = jvm
1182            .invoke_static(
1183                "java/util/regex/Pattern",
1184                "compile",
1185                "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
1186                (regex,),
1187            )
1188            .await?;
1189        let input: ClassInstanceRef<CharSequence> = ClassInstanceRef::new(this.instance);
1190        jvm.invoke_virtual(
1191            &pattern,
1192            "java/util/regex/Pattern",
1193            "split",
1194            "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
1195            (input, limit),
1196        )
1197        .await
1198    }
1199
1200    async fn format(
1201        jvm: &Jvm,
1202        _: &mut RuntimeContext,
1203        format: ClassInstanceRef<Self>,
1204        arguments: ClassInstanceRef<Array<Object>>,
1205    ) -> Result<ClassInstanceRef<Self>> {
1206        let formatter: ClassInstanceRef<Formatter> = jvm.new_class("java/util/Formatter", "()V", ()).await?.into();
1207        let _: ClassInstanceRef<Formatter> = jvm
1208            .invoke_virtual(
1209                &formatter,
1210                "java/util/Formatter",
1211                "format",
1212                "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
1213                (format, arguments),
1214            )
1215            .await?;
1216        jvm.invoke_virtual(&formatter, "java/util/Formatter", "toString", "()Ljava/lang/String;", ())
1217            .await
1218    }
1219
1220    async fn format_with_locale(
1221        jvm: &Jvm,
1222        _: &mut RuntimeContext,
1223        locale: ClassInstanceRef<Locale>,
1224        format: ClassInstanceRef<Self>,
1225        arguments: ClassInstanceRef<Array<Object>>,
1226    ) -> Result<ClassInstanceRef<Self>> {
1227        let formatter: ClassInstanceRef<Formatter> = jvm.new_class("java/util/Formatter", "(Ljava/util/Locale;)V", (locale,)).await?.into();
1228        let _: ClassInstanceRef<Formatter> = jvm
1229            .invoke_virtual(
1230                &formatter,
1231                "java/util/Formatter",
1232                "format",
1233                "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/util/Formatter;",
1234                (format, arguments),
1235            )
1236            .await?;
1237        jvm.invoke_virtual(&formatter, "java/util/Formatter", "toString", "()Ljava/lang/String;", ())
1238            .await
1239    }
1240
1241    #[allow(clippy::too_many_arguments)]
1242    async fn region_matches(
1243        jvm: &Jvm,
1244        _: &mut RuntimeContext,
1245        this: ClassInstanceRef<Self>,
1246        ignore_case: bool,
1247        toffset: i32,
1248        other: ClassInstanceRef<Self>,
1249        ooffset: i32,
1250        len: i32,
1251    ) -> Result<bool> {
1252        tracing::debug!("java.lang.String::regionMatches({this:?}, {ignore_case}, {toffset}, {other:?}, {ooffset}, {len})");
1253
1254        if other.is_null() {
1255            return Err(jvm.exception("java/lang/NullPointerException", "other is null").await);
1256        }
1257
1258        if toffset < 0 || ooffset < 0 {
1259            return Ok(false);
1260        }
1261
1262        let (this_value, this_offset, this_count) = Self::value_range(jvm, &this).await?;
1263        let (other_value, other_offset, other_count) = Self::value_range(jvm, &other).await?;
1264        // widened like the jdk does, so a len near i32::MAX fails the bounds test instead of overflowing
1265        if toffset as i64 > this_count as i64 - len as i64 || ooffset as i64 > other_count as i64 - len as i64 {
1266            return Ok(false);
1267        }
1268        // the jdk's comparison loop never runs for a non-positive len, so an in-range region trivially matches
1269        if len <= 0 {
1270            return Ok(true);
1271        }
1272
1273        let this_chars: Vec<JavaChar> = jvm.load_array(&this_value, this_offset + toffset as usize, len as usize).await?;
1274        let other_chars: Vec<JavaChar> = jvm.load_array(&other_value, other_offset + ooffset as usize, len as usize).await?;
1275
1276        if ignore_case {
1277            let to_lower = |c: JavaChar| -> JavaChar {
1278                char::from_u32(c as u32)
1279                    .map(|ch| ch.to_lowercase().next().unwrap_or(ch) as u32 as u16)
1280                    .unwrap_or(c)
1281            };
1282            Ok(this_chars.iter().copied().map(to_lower).eq(other_chars.iter().copied().map(to_lower)))
1283        } else {
1284            Ok(this_chars == other_chars)
1285        }
1286    }
1287
1288    async fn region_matches_case_sensitive(
1289        jvm: &Jvm,
1290        _: &mut RuntimeContext,
1291        this: ClassInstanceRef<Self>,
1292        toffset: i32,
1293        other: ClassInstanceRef<Self>,
1294        ooffset: i32,
1295        len: i32,
1296    ) -> Result<bool> {
1297        tracing::debug!("java.lang.String::regionMatches({this:?}, {toffset}, {other:?}, {ooffset}, {len})");
1298
1299        jvm.invoke_virtual(
1300            &this,
1301            "java/lang/String",
1302            "regionMatches",
1303            "(ZILjava/lang/String;II)Z",
1304            (false, toffset, other, ooffset, len),
1305        )
1306        .await
1307    }
1308
1309    async fn last_index_of_from(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, ch: i32, from_index: i32) -> Result<i32> {
1310        tracing::debug!("java.lang.String::lastIndexOf({this:?}, {ch}, {from_index})");
1311
1312        if from_index < 0 {
1313            return Ok(-1);
1314        }
1315
1316        if !(0..=u16::MAX as i32).contains(&ch) {
1317            return Ok(-1);
1318        }
1319
1320        let chars = JavaLangString::to_utf16(jvm, &this).await?;
1321        let end = (from_index as usize + 1).min(chars.len());
1322
1323        let index = chars[..end].iter().rposition(|&value| value == ch as u16).map(|index| index as i32);
1324
1325        Ok(index.unwrap_or(-1))
1326    }
1327
1328    async fn last_index_of_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, str: ClassInstanceRef<Self>) -> Result<i32> {
1329        tracing::debug!("java.lang.String::lastIndexOf({this:?}, {str:?})");
1330
1331        let length: i32 = jvm.get_field(&this, "java/lang/String", "count", "I").await?;
1332        jvm.invoke_virtual(&this, "java/lang/String", "lastIndexOf", "(Ljava/lang/String;I)I", (str, length))
1333            .await
1334    }
1335
1336    async fn last_index_of_string_from(
1337        jvm: &Jvm,
1338        _: &mut RuntimeContext,
1339        this: ClassInstanceRef<Self>,
1340        str: ClassInstanceRef<Self>,
1341        from_index: i32,
1342    ) -> Result<i32> {
1343        tracing::debug!("java.lang.String::lastIndexOf({this:?}, {str:?}, {from_index})");
1344
1345        if str.is_null() {
1346            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1347        }
1348        if from_index < 0 {
1349            return Ok(-1);
1350        }
1351
1352        let chars = JavaLangString::to_utf16(jvm, &this).await?;
1353        let pattern = JavaLangString::to_utf16(jvm, &str).await?;
1354
1355        if pattern.is_empty() {
1356            return Ok((from_index as usize).min(chars.len()) as i32);
1357        }
1358        if pattern.len() > chars.len() {
1359            return Ok(-1);
1360        }
1361
1362        let last_start = (from_index as usize).min(chars.len() - pattern.len());
1363        for index in (0..=last_start).rev() {
1364            if chars[index..].starts_with(&pattern) {
1365                return Ok(index as i32);
1366            }
1367        }
1368
1369        Ok(-1)
1370    }
1371
1372    async fn ends_with(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, suffix: ClassInstanceRef<Self>) -> Result<bool> {
1373        tracing::debug!("java.lang.String::endsWith({this:?}, {suffix:?})");
1374
1375        if suffix.is_null() {
1376            return Err(jvm.exception("java/lang/NullPointerException", "suffix is null").await);
1377        }
1378
1379        let this_chars = JavaLangString::to_utf16(jvm, &this).await?;
1380        let suffix_chars = JavaLangString::to_utf16(jvm, &suffix).await?;
1381
1382        Ok(this_chars.ends_with(&suffix_chars))
1383    }
1384
1385    async fn intern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
1386        tracing::debug!("java.lang.String::intern({this:?})");
1387
1388        let utf16 = JavaLangString::to_utf16(jvm, &this).await?;
1389
1390        let receiver = this.instance.unwrap();
1391
1392        Ok(jvm.intern_string_instance(receiver, &utf16).into())
1393    }
1394
1395    async fn value_of_boolean(jvm: &Jvm, _: &mut RuntimeContext, value: bool) -> Result<ClassInstanceRef<Self>> {
1396        tracing::debug!("java.lang.String::valueOf({value})");
1397
1398        let string = if value { "true" } else { "false" };
1399        Ok(JavaLangString::from_rust_string(jvm, string).await?.into())
1400    }
1401
1402    async fn value_of_long(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<Self>> {
1403        tracing::debug!("java.lang.String::valueOf({value})");
1404
1405        Ok(JavaLangString::from_rust_string(jvm, &value.to_string()).await?.into())
1406    }
1407
1408    async fn value_of_float(jvm: &Jvm, _: &mut RuntimeContext, value: f32) -> Result<ClassInstanceRef<Self>> {
1409        tracing::debug!("java.lang.String::valueOf({value})");
1410
1411        jvm.invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,)).await
1412    }
1413
1414    async fn value_of_double(jvm: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<ClassInstanceRef<Self>> {
1415        tracing::debug!("java.lang.String::valueOf({value})");
1416
1417        jvm.invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,)).await
1418    }
1419
1420    async fn value_of_char_array(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<Array<JavaChar>>) -> Result<ClassInstanceRef<Self>> {
1421        tracing::debug!("java.lang.String::valueOf({value:?})");
1422
1423        let new_string = jvm.new_class("java/lang/String", "([C)V", (value,)).await?;
1424
1425        Ok(new_string.into())
1426    }
1427
1428    async fn value_of_partial_char_array(
1429        jvm: &Jvm,
1430        _: &mut RuntimeContext,
1431        value: ClassInstanceRef<Array<JavaChar>>,
1432        offset: i32,
1433        count: i32,
1434    ) -> Result<ClassInstanceRef<Self>> {
1435        tracing::debug!("java.lang.String::valueOf({value:?}, {offset}, {count})");
1436
1437        let new_string = jvm.new_class("java/lang/String", "([CII)V", (value, offset, count)).await?;
1438
1439        Ok(new_string.into())
1440    }
1441
1442    async fn copy_value_of(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<Array<JavaChar>>) -> Result<ClassInstanceRef<Self>> {
1443        tracing::debug!("java.lang.String::copyValueOf({value:?})");
1444
1445        if value.is_null() {
1446            return Err(jvm.exception("java/lang/NullPointerException", "data is null").await);
1447        }
1448
1449        let length = jvm.array_length(&value).await? as i32;
1450        Ok(jvm.new_class("java/lang/String", "([CII)V", (value, 0, length)).await?.into())
1451    }
1452
1453    async fn copy_value_of_range(
1454        jvm: &Jvm,
1455        _: &mut RuntimeContext,
1456        value: ClassInstanceRef<Array<JavaChar>>,
1457        offset: i32,
1458        count: i32,
1459    ) -> Result<ClassInstanceRef<Self>> {
1460        tracing::debug!("java.lang.String::copyValueOf({value:?}, {offset}, {count})");
1461
1462        if value.is_null() {
1463            return Err(jvm.exception("java/lang/NullPointerException", "data is null").await);
1464        }
1465        let length = jvm.array_length(&value).await? as i32;
1466        if offset < 0 || count < 0 || offset > length - count {
1467            return Err(jvm
1468                .exception(
1469                    "java/lang/StringIndexOutOfBoundsException",
1470                    &format!("offset {offset}, count {count}, length {length}"),
1471                )
1472                .await);
1473        }
1474
1475        Ok(jvm.new_class("java/lang/String", "([CII)V", (value, offset, count)).await?.into())
1476    }
1477
1478    fn decode_str(charset: &str, bytes: &[u8]) -> Option<RustString> {
1479        Some(match charset.to_ascii_uppercase().replace('_', "-").as_str() {
1480            "UTF-8" | "UTF8" => RustString::from_utf8_lossy(bytes).into_owned(),
1481            "EUC-KR" | "EUCKR" | "KS-C-5601-1987" | "MS949" | "CP949" => encoding_rs::EUC_KR.decode(bytes).0.to_string(),
1482            "ISO-8859-1" | "LATIN1" | "US-ASCII" | "ASCII" => bytes.iter().map(|&b| b as char).collect(),
1483            _ => return None,
1484        })
1485    }
1486
1487    fn encode_str(charset: &str, string: &str) -> Option<Vec<u8>> {
1488        Some(match charset.to_ascii_uppercase().replace('_', "-").as_str() {
1489            "UTF-8" | "UTF8" => string.as_bytes().to_vec(),
1490            "EUC-KR" | "EUCKR" | "KS-C-5601-1987" | "MS949" | "CP949" => encoding_rs::EUC_KR.encode(string).0.to_vec(),
1491            "ISO-8859-1" | "LATIN1" => string.chars().map(|c| if (c as u32) <= 0xff { c as u8 } else { b'?' }).collect(),
1492            "US-ASCII" | "ASCII" => string.chars().map(|c| if c.is_ascii() { c as u8 } else { b'?' }).collect(),
1493            _ => return None,
1494        })
1495    }
1496}