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