1use alloc::{string::String as RustString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::lang::{CharSequence, String, StringBuffer},
10};
11
12use super::Pattern;
13
14#[derive(Clone, Copy)]
15enum MatchMode {
16 Full,
17 Prefix,
18 Find { start: i32, reset: bool },
19}
20
21pub struct Matcher;
23
24impl Matcher {
25 pub fn as_proto() -> RuntimeClassProto {
26 RuntimeClassProto {
27 name: "java/util/regex/Matcher",
28 parent_class: Some("java/lang/Object"),
29 interfaces: vec![],
30 methods: vec![
31 JavaMethodProto::new(
32 "<init>",
33 "(Ljava/util/regex/Pattern;Ljava/lang/CharSequence;)V",
34 Self::init,
35 MethodAccessFlags::empty(),
36 ),
37 JavaMethodProto::new("pattern", "()Ljava/util/regex/Pattern;", Self::pattern, MethodAccessFlags::PUBLIC),
38 JavaMethodProto::new("reset", "()Ljava/util/regex/Matcher;", Self::reset, MethodAccessFlags::PUBLIC),
39 JavaMethodProto::new(
40 "reset",
41 "(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;",
42 Self::reset_with_input,
43 MethodAccessFlags::PUBLIC,
44 ),
45 JavaMethodProto::new("matches", "()Z", Self::matches, MethodAccessFlags::PUBLIC),
46 JavaMethodProto::new("lookingAt", "()Z", Self::looking_at, MethodAccessFlags::PUBLIC),
47 JavaMethodProto::new("find", "()Z", Self::find, MethodAccessFlags::PUBLIC),
48 JavaMethodProto::new("find", "(I)Z", Self::find_from, MethodAccessFlags::PUBLIC),
49 JavaMethodProto::new("start", "()I", Self::start, MethodAccessFlags::PUBLIC),
50 JavaMethodProto::new("start", "(I)I", Self::start_group, MethodAccessFlags::PUBLIC),
51 JavaMethodProto::new("end", "()I", Self::end, MethodAccessFlags::PUBLIC),
52 JavaMethodProto::new("end", "(I)I", Self::end_group, MethodAccessFlags::PUBLIC),
53 JavaMethodProto::new("group", "()Ljava/lang/String;", Self::group, MethodAccessFlags::PUBLIC),
54 JavaMethodProto::new("group", "(I)Ljava/lang/String;", Self::group_index, MethodAccessFlags::PUBLIC),
55 JavaMethodProto::new("groupCount", "()I", Self::group_count, MethodAccessFlags::PUBLIC),
56 JavaMethodProto::new(
57 "appendReplacement",
58 "(Ljava/lang/StringBuffer;Ljava/lang/String;)Ljava/util/regex/Matcher;",
59 Self::append_replacement,
60 MethodAccessFlags::PUBLIC,
61 ),
62 JavaMethodProto::new(
63 "appendTail",
64 "(Ljava/lang/StringBuffer;)Ljava/lang/StringBuffer;",
65 Self::append_tail,
66 MethodAccessFlags::PUBLIC,
67 ),
68 JavaMethodProto::new(
69 "replaceAll",
70 "(Ljava/lang/String;)Ljava/lang/String;",
71 Self::replace_all,
72 MethodAccessFlags::PUBLIC,
73 ),
74 JavaMethodProto::new(
75 "replaceFirst",
76 "(Ljava/lang/String;)Ljava/lang/String;",
77 Self::replace_first,
78 MethodAccessFlags::PUBLIC,
79 ),
80 ],
81 fields: vec![
82 JavaFieldProto::new(
83 "parentPattern",
84 "Ljava/util/regex/Pattern;",
85 FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL,
86 ),
87 JavaFieldProto::new("text", "Ljava/lang/CharSequence;", FieldAccessFlags::PRIVATE),
88 JavaFieldProto::new("groups", "[I", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
89 JavaFieldProto::new("searchPosition", "I", FieldAccessFlags::PRIVATE),
90 JavaFieldProto::new("appendPosition", "I", FieldAccessFlags::PRIVATE),
91 JavaFieldProto::new("hasMatch", "Z", FieldAccessFlags::PRIVATE),
92 ],
93 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
94 }
95 }
96
97 async fn init(
98 jvm: &Jvm,
99 _: &mut RuntimeContext,
100 mut this: ClassInstanceRef<Self>,
101 pattern: ClassInstanceRef<Pattern>,
102 input: ClassInstanceRef<CharSequence>,
103 ) -> Result<()> {
104 tracing::debug!("java.util.regex.Matcher::<init>({this:?}, {pattern:?}, {input:?})");
105
106 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
107 if input.is_null() {
108 return Err(jvm.exception("java/lang/NullPointerException", "input is null").await);
109 }
110
111 let source: ClassInstanceRef<String> = jvm.get_field(&pattern, "pattern", "Ljava/lang/String;").await?;
112 let flags: i32 = jvm.get_field(&pattern, "flags", "I").await?;
113 let source_text = JavaLangString::to_rust_string(jvm, &source).await?;
114 let regex = Pattern::build_regex(jvm, &source_text, &source, flags, false).await?;
115 let mut groups = jvm.instantiate_array("I", regex.captures_len() * 2).await?;
116 jvm.store_array(&mut groups, 0, vec![-1i32; regex.captures_len() * 2]).await?;
117
118 jvm.put_field(&mut this, "parentPattern", "Ljava/util/regex/Pattern;", pattern).await?;
119 jvm.put_field(&mut this, "text", "Ljava/lang/CharSequence;", input).await?;
120 jvm.put_field(&mut this, "groups", "[I", groups).await?;
121 jvm.put_field(&mut this, "searchPosition", "I", 0).await?;
122 jvm.put_field(&mut this, "appendPosition", "I", 0).await?;
123 jvm.put_field(&mut this, "hasMatch", "Z", false).await
124 }
125
126 async fn pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Pattern>> {
127 tracing::debug!("java.util.regex.Matcher::pattern({this:?})");
128
129 jvm.get_field(&this, "parentPattern", "Ljava/util/regex/Pattern;").await
130 }
131
132 async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
133 tracing::debug!("java.util.regex.Matcher::reset({this:?})");
134
135 let mut groups: ClassInstanceRef<Array<i32>> = jvm.get_field(&this, "groups", "[I").await?;
136 let length = jvm.array_length(&groups).await?;
137 jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?;
138 jvm.put_field(&mut this, "searchPosition", "I", 0).await?;
139 jvm.put_field(&mut this, "appendPosition", "I", 0).await?;
140 jvm.put_field(&mut this, "hasMatch", "Z", false).await?;
141 Ok(this)
142 }
143
144 async fn reset_with_input(
145 jvm: &Jvm,
146 _: &mut RuntimeContext,
147 mut this: ClassInstanceRef<Self>,
148 input: ClassInstanceRef<CharSequence>,
149 ) -> Result<ClassInstanceRef<Self>> {
150 tracing::debug!("java.util.regex.Matcher::reset({this:?}, {input:?})");
151
152 if input.is_null() {
153 return Err(jvm.exception("java/lang/NullPointerException", "input is null").await);
154 }
155
156 jvm.put_field(&mut this, "text", "Ljava/lang/CharSequence;", input).await?;
157 let mut groups: ClassInstanceRef<Array<i32>> = jvm.get_field(&this, "groups", "[I").await?;
158 let length = jvm.array_length(&groups).await?;
159 jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?;
160 jvm.put_field(&mut this, "searchPosition", "I", 0).await?;
161 jvm.put_field(&mut this, "appendPosition", "I", 0).await?;
162 jvm.put_field(&mut this, "hasMatch", "Z", false).await?;
163 Ok(this)
164 }
165
166 async fn matches(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<bool> {
167 tracing::debug!("java.util.regex.Matcher::matches({this:?})");
168
169 Self::execute_match(jvm, &mut this, MatchMode::Full).await
170 }
171
172 async fn looking_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<bool> {
173 tracing::debug!("java.util.regex.Matcher::lookingAt({this:?})");
174
175 Self::execute_match(jvm, &mut this, MatchMode::Prefix).await
176 }
177
178 async fn find(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<bool> {
179 tracing::debug!("java.util.regex.Matcher::find({this:?})");
180
181 let search_position: i32 = jvm.get_field(&this, "searchPosition", "I").await?;
182 if search_position == -1 {
183 return Ok(false);
184 }
185
186 let has_match: bool = jvm.get_field(&this, "hasMatch", "Z").await?;
187 if has_match {
188 let groups: ClassInstanceRef<Array<i32>> = jvm.get_field(&this, "groups", "[I").await?;
189 let range: Vec<i32> = jvm.load_array(&groups, 0, 2).await?;
190 if range[0] == range[1] && range[1] == search_position {
191 let length = jvm.array_length(&groups).await?;
192 let mut groups = groups;
193 jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?;
194 jvm.put_field(&mut this, "searchPosition", "I", -1).await?;
195 jvm.put_field(&mut this, "hasMatch", "Z", false).await?;
196 return Ok(false);
197 }
198 }
199
200 Self::execute_match(
201 jvm,
202 &mut this,
203 MatchMode::Find {
204 start: search_position,
205 reset: false,
206 },
207 )
208 .await
209 }
210
211 async fn find_from(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, start: i32) -> Result<bool> {
212 tracing::debug!("java.util.regex.Matcher::find({this:?}, {start})");
213
214 if start < 0 {
215 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Illegal start index").await);
216 }
217 let text: ClassInstanceRef<CharSequence> = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?;
218 let length: i32 = jvm.invoke_virtual(&text, &text.class_definition().name(), "length", "()I", ()).await?;
219 if start > length {
220 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Illegal start index").await);
221 }
222
223 Self::execute_match(jvm, &mut this, MatchMode::Find { start, reset: true }).await
224 }
225
226 async fn start(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
227 tracing::debug!("java.util.regex.Matcher::start({this:?})");
228
229 let (start, _) = Self::group_range(jvm, &this, 0).await?;
230 Ok(start)
231 }
232
233 async fn start_group(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, group: i32) -> Result<i32> {
234 tracing::debug!("java.util.regex.Matcher::start({this:?}, {group})");
235
236 let (start, _) = Self::group_range(jvm, &this, group).await?;
237 Ok(start)
238 }
239
240 async fn end(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
241 tracing::debug!("java.util.regex.Matcher::end({this:?})");
242
243 let (_, end) = Self::group_range(jvm, &this, 0).await?;
244 Ok(end)
245 }
246
247 async fn end_group(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, group: i32) -> Result<i32> {
248 tracing::debug!("java.util.regex.Matcher::end({this:?}, {group})");
249
250 let (_, end) = Self::group_range(jvm, &this, group).await?;
251 Ok(end)
252 }
253
254 async fn group(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
255 tracing::debug!("java.util.regex.Matcher::group({this:?})");
256
257 let (start, end) = Self::group_range(jvm, &this, 0).await?;
258 let text: ClassInstanceRef<CharSequence> = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?;
259 let group: ClassInstanceRef<CharSequence> = jvm
260 .invoke_virtual(
261 &text,
262 &text.class_definition().name(),
263 "subSequence",
264 "(II)Ljava/lang/CharSequence;",
265 (start, end),
266 )
267 .await?;
268 jvm.invoke_virtual(&group, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
269 .await
270 }
271
272 async fn group_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, group: i32) -> Result<ClassInstanceRef<String>> {
273 tracing::debug!("java.util.regex.Matcher::group({this:?}, {group})");
274
275 let (start, end) = Self::group_range(jvm, &this, group).await?;
276 if start < 0 {
277 return Ok(None.into());
278 }
279 let text: ClassInstanceRef<CharSequence> = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?;
280 let group: ClassInstanceRef<CharSequence> = jvm
281 .invoke_virtual(
282 &text,
283 &text.class_definition().name(),
284 "subSequence",
285 "(II)Ljava/lang/CharSequence;",
286 (start, end),
287 )
288 .await?;
289 jvm.invoke_virtual(&group, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
290 .await
291 }
292
293 async fn group_count(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
294 tracing::debug!("java.util.regex.Matcher::groupCount({this:?})");
295
296 let groups: ClassInstanceRef<Array<i32>> = jvm.get_field(&this, "groups", "[I").await?;
297 Ok(jvm.array_length(&groups).await? as i32 / 2 - 1)
298 }
299
300 async fn append_replacement(
301 jvm: &Jvm,
302 _: &mut RuntimeContext,
303 mut this: ClassInstanceRef<Self>,
304 buffer: ClassInstanceRef<StringBuffer>,
305 replacement: ClassInstanceRef<String>,
306 ) -> Result<ClassInstanceRef<Self>> {
307 tracing::debug!("java.util.regex.Matcher::appendReplacement({this:?}, {buffer:?}, {replacement:?})");
308
309 let has_match: bool = jvm.get_field(&this, "hasMatch", "Z").await?;
310 if !has_match {
311 return Err(jvm.exception("java/lang/IllegalStateException", "No match available").await);
312 }
313
314 let expanded = Self::expand_replacement(jvm, &this, &replacement).await?;
315 let groups: ClassInstanceRef<Array<i32>> = jvm.get_field(&this, "groups", "[I").await?;
316 let match_range: Vec<i32> = jvm.load_array(&groups, 0, 2).await?;
317 let append_position: i32 = jvm.get_field(&this, "appendPosition", "I").await?;
318 let text: ClassInstanceRef<CharSequence> = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?;
319 let prefix: ClassInstanceRef<CharSequence> = jvm
320 .invoke_virtual(
321 &text,
322 &text.class_definition().name(),
323 "subSequence",
324 "(II)Ljava/lang/CharSequence;",
325 (append_position, match_range[0]),
326 )
327 .await?;
328 let prefix: ClassInstanceRef<String> = jvm
329 .invoke_virtual(&prefix, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
330 .await?;
331 let expanded = JavaLangString::from_utf16(jvm, expanded).await?;
332
333 if buffer.is_null() {
334 return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
335 }
336 let _: ClassInstanceRef<StringBuffer> = jvm
337 .invoke_virtual(
338 &buffer,
339 "java/lang/StringBuffer",
340 "append",
341 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
342 (prefix,),
343 )
344 .await?;
345 let _: ClassInstanceRef<StringBuffer> = jvm
346 .invoke_virtual(
347 &buffer,
348 "java/lang/StringBuffer",
349 "append",
350 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
351 (expanded,),
352 )
353 .await?;
354 jvm.put_field(&mut this, "appendPosition", "I", match_range[1]).await?;
355 Ok(this)
356 }
357
358 async fn append_tail(
359 jvm: &Jvm,
360 _: &mut RuntimeContext,
361 this: ClassInstanceRef<Self>,
362 buffer: ClassInstanceRef<StringBuffer>,
363 ) -> Result<ClassInstanceRef<StringBuffer>> {
364 tracing::debug!("java.util.regex.Matcher::appendTail({this:?}, {buffer:?})");
365
366 if buffer.is_null() {
367 return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
368 }
369
370 let append_position: i32 = jvm.get_field(&this, "appendPosition", "I").await?;
371 let text: ClassInstanceRef<CharSequence> = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?;
372 let length: i32 = jvm.invoke_virtual(&text, &text.class_definition().name(), "length", "()I", ()).await?;
373 let tail: ClassInstanceRef<CharSequence> = jvm
374 .invoke_virtual(
375 &text,
376 &text.class_definition().name(),
377 "subSequence",
378 "(II)Ljava/lang/CharSequence;",
379 (append_position, length),
380 )
381 .await?;
382 let tail: ClassInstanceRef<String> = jvm
383 .invoke_virtual(&tail, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
384 .await?;
385 jvm.invoke_virtual(
386 &buffer,
387 "java/lang/StringBuffer",
388 "append",
389 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
390 (tail,),
391 )
392 .await
393 }
394
395 async fn replace_all(
396 jvm: &Jvm,
397 _: &mut RuntimeContext,
398 this: ClassInstanceRef<Self>,
399 replacement: ClassInstanceRef<String>,
400 ) -> Result<ClassInstanceRef<String>> {
401 tracing::debug!("java.util.regex.Matcher::replaceAll({this:?}, {replacement:?})");
402
403 let _: ClassInstanceRef<Self> = jvm
404 .invoke_virtual(&this, "java/util/regex/Matcher", "reset", "()Ljava/util/regex/Matcher;", ())
405 .await?;
406 if !jvm.invoke_virtual::<_, bool>(&this, "java/util/regex/Matcher", "find", "()Z", ()).await? {
407 let text: ClassInstanceRef<CharSequence> = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?;
408 return jvm
409 .invoke_virtual(&text, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
410 .await;
411 }
412
413 let buffer: ClassInstanceRef<StringBuffer> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
414 loop {
415 let _: ClassInstanceRef<Self> = jvm
416 .invoke_virtual(
417 &this,
418 "java/util/regex/Matcher",
419 "appendReplacement",
420 "(Ljava/lang/StringBuffer;Ljava/lang/String;)Ljava/util/regex/Matcher;",
421 (buffer.clone(), replacement.clone()),
422 )
423 .await?;
424 if !jvm.invoke_virtual::<_, bool>(&this, "java/util/regex/Matcher", "find", "()Z", ()).await? {
425 break;
426 }
427 }
428 let _: ClassInstanceRef<StringBuffer> = jvm
429 .invoke_virtual(
430 &this,
431 "java/util/regex/Matcher",
432 "appendTail",
433 "(Ljava/lang/StringBuffer;)Ljava/lang/StringBuffer;",
434 (buffer.clone(),),
435 )
436 .await?;
437 jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
438 .await
439 }
440
441 async fn replace_first(
442 jvm: &Jvm,
443 _: &mut RuntimeContext,
444 this: ClassInstanceRef<Self>,
445 replacement: ClassInstanceRef<String>,
446 ) -> Result<ClassInstanceRef<String>> {
447 tracing::debug!("java.util.regex.Matcher::replaceFirst({this:?}, {replacement:?})");
448
449 let _: ClassInstanceRef<Self> = jvm
450 .invoke_virtual(&this, "java/util/regex/Matcher", "reset", "()Ljava/util/regex/Matcher;", ())
451 .await?;
452 if !jvm.invoke_virtual::<_, bool>(&this, "java/util/regex/Matcher", "find", "()Z", ()).await? {
453 let text: ClassInstanceRef<CharSequence> = jvm.get_field(&this, "text", "Ljava/lang/CharSequence;").await?;
454 return jvm
455 .invoke_virtual(&text, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
456 .await;
457 }
458
459 let buffer: ClassInstanceRef<StringBuffer> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
460 let _: ClassInstanceRef<Self> = jvm
461 .invoke_virtual(
462 &this,
463 "java/util/regex/Matcher",
464 "appendReplacement",
465 "(Ljava/lang/StringBuffer;Ljava/lang/String;)Ljava/util/regex/Matcher;",
466 (buffer.clone(), replacement),
467 )
468 .await?;
469 let _: ClassInstanceRef<StringBuffer> = jvm
470 .invoke_virtual(
471 &this,
472 "java/util/regex/Matcher",
473 "appendTail",
474 "(Ljava/lang/StringBuffer;)Ljava/lang/StringBuffer;",
475 (buffer.clone(),),
476 )
477 .await?;
478 jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
479 .await
480 }
481
482 async fn group_range(jvm: &Jvm, this: &ClassInstanceRef<Self>, group: i32) -> Result<(i32, i32)> {
483 let has_match: bool = jvm.get_field(this, "hasMatch", "Z").await?;
484 if !has_match {
485 return Err(jvm.exception("java/lang/IllegalStateException", "No match found").await);
486 }
487
488 let groups: ClassInstanceRef<Array<i32>> = jvm.get_field(this, "groups", "[I").await?;
489 let length = jvm.array_length(&groups).await?;
490 if group < 0 || group as usize >= length / 2 {
491 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "No group with this index").await);
492 }
493 let range: Vec<i32> = jvm.load_array(&groups, group as usize * 2, 2).await?;
494 Ok((range[0], range[1]))
495 }
496
497 async fn expand_replacement(jvm: &Jvm, this: &ClassInstanceRef<Self>, replacement: &ClassInstanceRef<String>) -> Result<Vec<u16>> {
498 if replacement.is_null() {
499 return Err(jvm.exception("java/lang/NullPointerException", "replacement is null").await);
500 }
501
502 let replacement = JavaLangString::to_utf16(jvm, replacement).await?;
503 let groups: ClassInstanceRef<Array<i32>> = jvm.get_field(this, "groups", "[I").await?;
504 let group_count = jvm.array_length(&groups).await? / 2 - 1;
505 let ranges: Vec<i32> = jvm.load_array(&groups, 0, (group_count + 1) * 2).await?;
506 let text: ClassInstanceRef<CharSequence> = jvm.get_field(this, "text", "Ljava/lang/CharSequence;").await?;
507 let mut expanded = Vec::new();
508 let mut index = 0;
509
510 while index < replacement.len() {
511 match replacement[index] {
512 value if value == '\\' as u16 => {
513 index += 1;
514 if index == replacement.len() {
515 return Err(jvm
516 .exception("java/lang/StringIndexOutOfBoundsException", "character to be escaped is missing")
517 .await);
518 }
519 expanded.push(replacement[index]);
520 index += 1;
521 }
522 value if value == '$' as u16 => {
523 index += 1;
524 if index == replacement.len() {
525 return Err(jvm
526 .exception("java/lang/StringIndexOutOfBoundsException", "group reference is missing")
527 .await);
528 }
529 if !(b'0' as u16..=b'9' as u16).contains(&replacement[index]) {
530 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal group reference").await);
531 }
532
533 let mut group = (replacement[index] - '0' as u16) as usize;
534 index += 1;
535 if group > group_count {
536 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "No group with this index").await);
537 }
538 while index < replacement.len() && (b'0' as u16..=b'9' as u16).contains(&replacement[index]) {
539 let candidate = group * 10 + (replacement[index] - '0' as u16) as usize;
540 if candidate > group_count {
541 break;
542 }
543 group = candidate;
544 index += 1;
545 }
546
547 let start = ranges[group * 2];
548 if start >= 0 {
549 let group: ClassInstanceRef<CharSequence> = jvm
550 .invoke_virtual(
551 &text,
552 &text.class_definition().name(),
553 "subSequence",
554 "(II)Ljava/lang/CharSequence;",
555 (start, ranges[group * 2 + 1]),
556 )
557 .await?;
558 let group: ClassInstanceRef<String> = jvm
559 .invoke_virtual(&group, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
560 .await?;
561 expanded.extend(JavaLangString::to_utf16(jvm, &group).await?);
562 }
563 }
564 value => {
565 expanded.push(value);
566 index += 1;
567 }
568 }
569 }
570
571 Ok(expanded)
572 }
573
574 async fn execute_match(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, mode: MatchMode) -> Result<bool> {
575 if let MatchMode::Find { start, reset: true } = mode {
576 let mut groups: ClassInstanceRef<Array<i32>> = jvm.get_field(this, "groups", "[I").await?;
577 let length = jvm.array_length(&groups).await?;
578 jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?;
579 jvm.put_field(this, "searchPosition", "I", start).await?;
580 jvm.put_field(this, "appendPosition", "I", 0).await?;
581 jvm.put_field(this, "hasMatch", "Z", false).await?;
582 }
583
584 let text: ClassInstanceRef<CharSequence> = jvm.get_field(this, "text", "Ljava/lang/CharSequence;").await?;
585 let snapshot: ClassInstanceRef<String> = jvm
586 .invoke_virtual(&text, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
587 .await?;
588 let utf16 = JavaLangString::to_utf16(jvm, &snapshot).await?;
589 let rust = RustString::from_utf16_lossy(&utf16);
590
591 if let MatchMode::Find { start, .. } = mode
592 && start as usize > utf16.len()
593 {
594 let mut groups: ClassInstanceRef<Array<i32>> = jvm.get_field(this, "groups", "[I").await?;
595 let length = jvm.array_length(&groups).await?;
596 jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?;
597 jvm.put_field(this, "searchPosition", "I", -1).await?;
598 jvm.put_field(this, "hasMatch", "Z", false).await?;
599 return Ok(false);
600 }
601
602 let pattern: ClassInstanceRef<Pattern> = jvm.get_field(this, "parentPattern", "Ljava/util/regex/Pattern;").await?;
603 let source: ClassInstanceRef<String> = jvm.get_field(&pattern, "pattern", "Ljava/lang/String;").await?;
604 let flags: i32 = jvm.get_field(&pattern, "flags", "I").await?;
605 let source_text = JavaLangString::to_rust_string(jvm, &source).await?;
606 let regex = Pattern::build_regex(jvm, &source_text, &source, flags, matches!(mode, MatchMode::Full)).await?;
607
608 let captures = match mode {
609 MatchMode::Full => regex.captures(&rust),
610 MatchMode::Prefix => regex
611 .captures(&rust)
612 .filter(|captures| captures.get(0).is_some_and(|matched| matched.start() == 0)),
613 MatchMode::Find { start, .. } => regex.captures_at(&rust, Self::utf16_to_byte(&rust, start as usize)),
614 };
615 let Some(captures) = captures else {
616 let mut groups: ClassInstanceRef<Array<i32>> = jvm.get_field(this, "groups", "[I").await?;
617 let length = jvm.array_length(&groups).await?;
618 jvm.store_array(&mut groups, 0, vec![-1i32; length]).await?;
619 jvm.put_field(this, "searchPosition", "I", if matches!(mode, MatchMode::Find { .. }) { -1 } else { 0 })
620 .await?;
621 jvm.put_field(this, "hasMatch", "Z", false).await?;
622 return Ok(false);
623 };
624
625 let matched = captures.get_match();
626 let byte_range = (matched.start(), matched.end());
627 let ranges = (0..regex.captures_len())
628 .flat_map(|index| {
629 if let Some(matched) = captures.get(index) {
630 [
631 Self::byte_to_utf16(&rust, matched.start()) as i32,
632 Self::byte_to_utf16(&rust, matched.end()) as i32,
633 ]
634 } else {
635 [-1, -1]
636 }
637 })
638 .collect::<Vec<_>>();
639 let mut groups: ClassInstanceRef<Array<i32>> = jvm.get_field(this, "groups", "[I").await?;
640 jvm.store_array(&mut groups, 0, ranges).await?;
641
642 let end = Self::byte_to_utf16(&rust, byte_range.1) as i32;
643 let search_position = if byte_range.0 == byte_range.1 && byte_range.1 < rust.len() {
644 end + rust[byte_range.1..].chars().next().map(char::len_utf16).unwrap_or_default() as i32
645 } else {
646 end
647 };
648 jvm.put_field(this, "searchPosition", "I", search_position).await?;
649 jvm.put_field(this, "hasMatch", "Z", true).await?;
650 Ok(true)
651 }
652
653 fn byte_to_utf16(value: &str, byte: usize) -> usize {
654 value[..byte].chars().map(char::len_utf16).sum()
655 }
656
657 fn utf16_to_byte(value: &str, index: usize) -> usize {
658 let mut utf16 = 0;
659 for (byte, character) in value.char_indices() {
660 if utf16 == index {
661 return byte;
662 }
663 utf16 += character.len_utf16();
664 if utf16 >= index {
665 return byte + character.len_utf8();
666 }
667 }
668 value.len()
669 }
670}