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
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}