1use alloc::{format, string::ToString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6use regex::{Regex, RegexBuilder};
7
8use crate::{
9 RuntimeClassProto, RuntimeContext,
10 classes::java::lang::{CharSequence, String},
11};
12
13use super::Matcher;
14
15pub struct Pattern;
17
18impl Pattern {
19 pub fn as_proto() -> RuntimeClassProto {
20 RuntimeClassProto {
21 name: "java/util/regex/Pattern",
22 parent_class: Some("java/lang/Object"),
23 interfaces: vec!["java/io/Serializable"],
24 methods: vec![
25 JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
26 JavaMethodProto::new("<init>", "(Ljava/lang/String;I)V", Self::init, MethodAccessFlags::PRIVATE),
27 JavaMethodProto::new(
28 "compile",
29 "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
30 Self::compile,
31 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
32 ),
33 JavaMethodProto::new(
34 "compile",
35 "(Ljava/lang/String;I)Ljava/util/regex/Pattern;",
36 Self::compile_with_flags,
37 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
38 ),
39 JavaMethodProto::new("pattern", "()Ljava/lang/String;", Self::pattern, MethodAccessFlags::PUBLIC),
40 JavaMethodProto::new("flags", "()I", Self::flags, MethodAccessFlags::PUBLIC),
41 JavaMethodProto::new(
42 "matcher",
43 "(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;",
44 Self::matcher,
45 MethodAccessFlags::PUBLIC,
46 ),
47 JavaMethodProto::new(
48 "matches",
49 "(Ljava/lang/String;Ljava/lang/CharSequence;)Z",
50 Self::matches,
51 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
52 ),
53 JavaMethodProto::new(
54 "split",
55 "(Ljava/lang/CharSequence;)[Ljava/lang/String;",
56 Self::split,
57 MethodAccessFlags::PUBLIC,
58 ),
59 JavaMethodProto::new(
60 "split",
61 "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
62 Self::split_with_limit,
63 MethodAccessFlags::PUBLIC,
64 ),
65 ],
66 fields: vec![
67 JavaFieldProto::new(
68 "UNIX_LINES",
69 "I",
70 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
71 ),
72 JavaFieldProto::new(
73 "CASE_INSENSITIVE",
74 "I",
75 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
76 ),
77 JavaFieldProto::new(
78 "COMMENTS",
79 "I",
80 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
81 ),
82 JavaFieldProto::new(
83 "MULTILINE",
84 "I",
85 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
86 ),
87 JavaFieldProto::new(
88 "DOTALL",
89 "I",
90 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
91 ),
92 JavaFieldProto::new(
93 "UNICODE_CASE",
94 "I",
95 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
96 ),
97 JavaFieldProto::new(
98 "CANON_EQ",
99 "I",
100 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
101 ),
102 JavaFieldProto::new("pattern", "Ljava/lang/String;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
103 JavaFieldProto::new("flags", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
104 ],
105 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
106 }
107 }
108
109 async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
110 tracing::debug!("java.util.regex.Pattern::<clinit>()");
111
112 jvm.put_static_field("java/util/regex/Pattern", "UNIX_LINES", "I", 1i32).await?;
113 jvm.put_static_field("java/util/regex/Pattern", "CASE_INSENSITIVE", "I", 2i32).await?;
114 jvm.put_static_field("java/util/regex/Pattern", "COMMENTS", "I", 4i32).await?;
115 jvm.put_static_field("java/util/regex/Pattern", "MULTILINE", "I", 8i32).await?;
116 jvm.put_static_field("java/util/regex/Pattern", "DOTALL", "I", 32i32).await?;
117 jvm.put_static_field("java/util/regex/Pattern", "UNICODE_CASE", "I", 64i32).await?;
118 jvm.put_static_field("java/util/regex/Pattern", "CANON_EQ", "I", 128i32).await
119 }
120
121 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>, flags: i32) -> Result<()> {
122 tracing::debug!("java.util.regex.Pattern::<init>({this:?}, {pattern:?}, {flags})");
123
124 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
125 jvm.put_field(&mut this, "pattern", "Ljava/lang/String;", pattern).await?;
126 jvm.put_field(&mut this, "flags", "I", flags).await
127 }
128
129 async fn compile(jvm: &Jvm, _: &mut RuntimeContext, pattern: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
130 tracing::debug!("java.util.regex.Pattern::compile({pattern:?})");
131
132 jvm.invoke_static(
133 "java/util/regex/Pattern",
134 "compile",
135 "(Ljava/lang/String;I)Ljava/util/regex/Pattern;",
136 (pattern, 0),
137 )
138 .await
139 }
140
141 async fn compile_with_flags(jvm: &Jvm, _: &mut RuntimeContext, pattern: ClassInstanceRef<String>, flags: i32) -> Result<ClassInstanceRef<Self>> {
142 tracing::debug!("java.util.regex.Pattern::compile({pattern:?}, {flags})");
143
144 if flags & !0xef != 0 {
145 return Err(jvm.exception("java/lang/IllegalArgumentException", "Unknown flag").await);
146 }
147 if pattern.is_null() {
148 return Err(jvm.exception("java/lang/NullPointerException", "regex is null").await);
149 }
150
151 let source = JavaLangString::to_rust_string(jvm, &pattern).await?;
152 let _ = Self::build_regex(jvm, &source, &pattern, flags, false).await?;
153
154 Ok(jvm
155 .new_class("java/util/regex/Pattern", "(Ljava/lang/String;I)V", (pattern, flags))
156 .await?
157 .into())
158 }
159
160 async fn pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
161 tracing::debug!("java.util.regex.Pattern::pattern({this:?})");
162
163 jvm.get_field(&this, "pattern", "Ljava/lang/String;").await
164 }
165
166 async fn flags(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
167 tracing::debug!("java.util.regex.Pattern::flags({this:?})");
168
169 jvm.get_field(&this, "flags", "I").await
170 }
171
172 async fn matcher(
173 jvm: &Jvm,
174 _: &mut RuntimeContext,
175 this: ClassInstanceRef<Self>,
176 input: ClassInstanceRef<CharSequence>,
177 ) -> Result<ClassInstanceRef<Matcher>> {
178 tracing::debug!("java.util.regex.Pattern::matcher({this:?}, {input:?})");
179
180 Ok(jvm
181 .new_class(
182 "java/util/regex/Matcher",
183 "(Ljava/util/regex/Pattern;Ljava/lang/CharSequence;)V",
184 (this, input),
185 )
186 .await?
187 .into())
188 }
189
190 async fn matches(jvm: &Jvm, _: &mut RuntimeContext, pattern: ClassInstanceRef<String>, input: ClassInstanceRef<CharSequence>) -> Result<bool> {
191 tracing::debug!("java.util.regex.Pattern::matches({pattern:?}, {input:?})");
192
193 let pattern: ClassInstanceRef<Self> = jvm
194 .invoke_static(
195 "java/util/regex/Pattern",
196 "compile",
197 "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
198 (pattern,),
199 )
200 .await?;
201 let matcher: ClassInstanceRef<Matcher> = jvm
202 .invoke_virtual(
203 &pattern,
204 "java/util/regex/Pattern",
205 "matcher",
206 "(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;",
207 (input,),
208 )
209 .await?;
210 jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "matches", "()Z", ()).await
211 }
212
213 async fn split(
214 jvm: &Jvm,
215 _: &mut RuntimeContext,
216 this: ClassInstanceRef<Self>,
217 input: ClassInstanceRef<CharSequence>,
218 ) -> Result<ClassInstanceRef<Array<String>>> {
219 tracing::debug!("java.util.regex.Pattern::split({this:?}, {input:?})");
220
221 jvm.invoke_virtual(
222 &this,
223 "java/util/regex/Pattern",
224 "split",
225 "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
226 (input, 0),
227 )
228 .await
229 }
230
231 async fn split_with_limit(
232 jvm: &Jvm,
233 _: &mut RuntimeContext,
234 this: ClassInstanceRef<Self>,
235 input: ClassInstanceRef<CharSequence>,
236 limit: i32,
237 ) -> Result<ClassInstanceRef<Array<String>>> {
238 tracing::debug!("java.util.regex.Pattern::split({this:?}, {input:?}, {limit})");
239
240 let matcher: ClassInstanceRef<Matcher> = jvm
241 .invoke_virtual(
242 &this,
243 "java/util/regex/Pattern",
244 "matcher",
245 "(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;",
246 (input.clone(),),
247 )
248 .await?;
249 let input_length: i32 = jvm.invoke_virtual(&input, &input.class_definition().name(), "length", "()I", ()).await?;
250 let match_limited = limit > 0;
251 let mut index = 0;
252 let mut parts = Vec::new();
253
254 while jvm
255 .invoke_virtual::<_, bool>(&matcher, "java/util/regex/Matcher", "find", "()Z", ())
256 .await?
257 {
258 if !match_limited || parts.len() < (limit - 1) as usize {
259 let start: i32 = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "start", "()I", ()).await?;
260 let part: ClassInstanceRef<CharSequence> = jvm
261 .invoke_virtual(
262 &input,
263 &input.class_definition().name(),
264 "subSequence",
265 "(II)Ljava/lang/CharSequence;",
266 (index, start),
267 )
268 .await?;
269 parts.push(
270 jvm.invoke_virtual(&part, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
271 .await?,
272 );
273 index = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "end", "()I", ()).await?;
274 } else if parts.len() == (limit - 1) as usize {
275 let part: ClassInstanceRef<CharSequence> = jvm
276 .invoke_virtual(
277 &input,
278 &input.class_definition().name(),
279 "subSequence",
280 "(II)Ljava/lang/CharSequence;",
281 (index, input_length),
282 )
283 .await?;
284 parts.push(
285 jvm.invoke_virtual(&part, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
286 .await?,
287 );
288 index = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "end", "()I", ()).await?;
289 }
290 }
291
292 if index == 0 {
293 parts.clear();
294 parts.push(
295 jvm.invoke_virtual(&input, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
296 .await?,
297 );
298 } else {
299 if !match_limited || parts.len() < limit as usize {
300 let part: ClassInstanceRef<CharSequence> = jvm
301 .invoke_virtual(
302 &input,
303 &input.class_definition().name(),
304 "subSequence",
305 "(II)Ljava/lang/CharSequence;",
306 (index, input_length),
307 )
308 .await?;
309 parts.push(
310 jvm.invoke_virtual(&part, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
311 .await?,
312 );
313 }
314 if limit == 0 {
315 while let Some(part) = parts.last() {
316 if jvm
317 .invoke_virtual::<_, i32>(part, &part.class_definition().name(), "length", "()I", ())
318 .await?
319 != 0
320 {
321 break;
322 }
323 parts.pop();
324 }
325 }
326 }
327
328 let mut result: ClassInstanceRef<Array<String>> = jvm.instantiate_array("Ljava/lang/String;", parts.len()).await?.into();
329 jvm.store_array(&mut result, 0, parts).await?;
330 Ok(result)
331 }
332
333 pub(crate) async fn build_regex(jvm: &Jvm, source: &str, original: &ClassInstanceRef<String>, flags: i32, full_match: bool) -> Result<Regex> {
334 let expression = if full_match { format!("\\A(?:{source})\\z") } else { source.to_string() };
335 let mut builder = RegexBuilder::new(&expression);
336 builder
337 .case_insensitive(flags & 2 != 0)
338 .ignore_whitespace(flags & 4 != 0)
339 .multi_line(flags & 8 != 0)
340 .dot_matches_new_line(flags & 32 != 0);
341 let regex = builder.build();
342 let regex = if full_match && regex.is_err() {
343 let expression = format!("\\A(?:{source}\n)\\z");
344 let mut builder = RegexBuilder::new(&expression);
345 builder
346 .case_insensitive(flags & 2 != 0)
347 .ignore_whitespace(flags & 4 != 0)
348 .multi_line(flags & 8 != 0)
349 .dot_matches_new_line(flags & 32 != 0);
350 builder.build()
351 } else {
352 regex
353 };
354
355 match regex {
356 Ok(regex) => Ok(regex),
357 Err(error) => {
358 let description = JavaLangString::from_rust_string(jvm, &error.to_string()).await?;
359 let exception = jvm
360 .new_class(
361 "java/util/regex/PatternSyntaxException",
362 "(Ljava/lang/String;Ljava/lang/String;I)V",
363 (description, original.clone(), -1),
364 )
365 .await?;
366 Err(JavaError::JavaException(exception))
367 }
368 }
369 }
370}