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