Skip to main content

rustjava_runtime/classes/java/util/regex/
matcher.rs

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
21// public final class java.util.regex.Matcher
22pub 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}