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
27pub 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 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, "java/lang/String", "value", "[C", array).await?;
316 jvm.put_field(&mut this, "java/lang/String", "offset", "I", 0).await?;
317 jvm.put_field(&mut this, "java/lang/String", "count", "I", count).await?;
318
319 Ok(())
320 }
321
322 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 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, "java/lang/String", "value", "[C", value).await?;
350 jvm.put_field(&mut this, "java/lang/String", "offset", "I", offset).await?;
351 jvm.put_field(&mut this, "java/lang/String", "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 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, "java/lang/String", "count", "I").await?;
438 let other_count: i32 = jvm.get_field(&other, "java/lang/String", "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, "java/lang/String", "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 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, "java/lang/String", "value", "[C", array).await?;
872 jvm.put_field(&mut this, "java/lang/String", "offset", "I", 0).await?;
873 jvm.put_field(&mut this, "java/lang/String", "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 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 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, "java/lang/String", "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}