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