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, "java/util/regex/Pattern", "pattern", "Ljava/lang/String;", pattern)
126 .await?;
127 jvm.put_field(&mut this, "java/util/regex/Pattern", "flags", "I", flags).await
128 }
129
130 async fn compile(jvm: &Jvm, _: &mut RuntimeContext, pattern: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
131 tracing::debug!("java.util.regex.Pattern::compile({pattern:?})");
132
133 jvm.invoke_static(
134 "java/util/regex/Pattern",
135 "compile",
136 "(Ljava/lang/String;I)Ljava/util/regex/Pattern;",
137 (pattern, 0),
138 )
139 .await
140 }
141
142 async fn compile_with_flags(jvm: &Jvm, _: &mut RuntimeContext, pattern: ClassInstanceRef<String>, flags: i32) -> Result<ClassInstanceRef<Self>> {
143 tracing::debug!("java.util.regex.Pattern::compile({pattern:?}, {flags})");
144
145 if flags & !0xef != 0 {
146 return Err(jvm.exception("java/lang/IllegalArgumentException", "Unknown flag").await);
147 }
148 if pattern.is_null() {
149 return Err(jvm.exception("java/lang/NullPointerException", "regex is null").await);
150 }
151
152 let source = JavaLangString::to_rust_string(jvm, &pattern).await?;
153 let _ = Self::build_regex(jvm, &source, &pattern, flags, false).await?;
154
155 Ok(jvm
156 .new_class("java/util/regex/Pattern", "(Ljava/lang/String;I)V", (pattern, flags))
157 .await?
158 .into())
159 }
160
161 async fn pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
162 tracing::debug!("java.util.regex.Pattern::pattern({this:?})");
163
164 jvm.get_field(&this, "java/util/regex/Pattern", "pattern", "Ljava/lang/String;").await
165 }
166
167 async fn flags(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
168 tracing::debug!("java.util.regex.Pattern::flags({this:?})");
169
170 jvm.get_field(&this, "java/util/regex/Pattern", "flags", "I").await
171 }
172
173 async fn matcher(
174 jvm: &Jvm,
175 _: &mut RuntimeContext,
176 this: ClassInstanceRef<Self>,
177 input: ClassInstanceRef<CharSequence>,
178 ) -> Result<ClassInstanceRef<Matcher>> {
179 tracing::debug!("java.util.regex.Pattern::matcher({this:?}, {input:?})");
180
181 Ok(jvm
182 .new_class(
183 "java/util/regex/Matcher",
184 "(Ljava/util/regex/Pattern;Ljava/lang/CharSequence;)V",
185 (this, input),
186 )
187 .await?
188 .into())
189 }
190
191 async fn matches(jvm: &Jvm, _: &mut RuntimeContext, pattern: ClassInstanceRef<String>, input: ClassInstanceRef<CharSequence>) -> Result<bool> {
192 tracing::debug!("java.util.regex.Pattern::matches({pattern:?}, {input:?})");
193
194 let pattern: ClassInstanceRef<Self> = jvm
195 .invoke_static(
196 "java/util/regex/Pattern",
197 "compile",
198 "(Ljava/lang/String;)Ljava/util/regex/Pattern;",
199 (pattern,),
200 )
201 .await?;
202 let matcher: ClassInstanceRef<Matcher> = jvm
203 .invoke_virtual(
204 &pattern,
205 "java/util/regex/Pattern",
206 "matcher",
207 "(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;",
208 (input,),
209 )
210 .await?;
211 jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "matches", "()Z", ()).await
212 }
213
214 async fn split(
215 jvm: &Jvm,
216 _: &mut RuntimeContext,
217 this: ClassInstanceRef<Self>,
218 input: ClassInstanceRef<CharSequence>,
219 ) -> Result<ClassInstanceRef<Array<String>>> {
220 tracing::debug!("java.util.regex.Pattern::split({this:?}, {input:?})");
221
222 jvm.invoke_virtual(
223 &this,
224 "java/util/regex/Pattern",
225 "split",
226 "(Ljava/lang/CharSequence;I)[Ljava/lang/String;",
227 (input, 0),
228 )
229 .await
230 }
231
232 async fn split_with_limit(
233 jvm: &Jvm,
234 _: &mut RuntimeContext,
235 this: ClassInstanceRef<Self>,
236 input: ClassInstanceRef<CharSequence>,
237 limit: i32,
238 ) -> Result<ClassInstanceRef<Array<String>>> {
239 tracing::debug!("java.util.regex.Pattern::split({this:?}, {input:?}, {limit})");
240
241 let matcher: ClassInstanceRef<Matcher> = jvm
242 .invoke_virtual(
243 &this,
244 "java/util/regex/Pattern",
245 "matcher",
246 "(Ljava/lang/CharSequence;)Ljava/util/regex/Matcher;",
247 (input.clone(),),
248 )
249 .await?;
250 let input_length: i32 = jvm.invoke_virtual(&input, &input.class_definition().name(), "length", "()I", ()).await?;
251 let match_limited = limit > 0;
252 let mut index = 0;
253 let mut parts = Vec::new();
254
255 while jvm
256 .invoke_virtual::<_, bool>(&matcher, "java/util/regex/Matcher", "find", "()Z", ())
257 .await?
258 {
259 if !match_limited || parts.len() < (limit - 1) as usize {
260 let start: i32 = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "start", "()I", ()).await?;
261 let part: ClassInstanceRef<CharSequence> = jvm
262 .invoke_virtual(
263 &input,
264 &input.class_definition().name(),
265 "subSequence",
266 "(II)Ljava/lang/CharSequence;",
267 (index, start),
268 )
269 .await?;
270 parts.push(
271 jvm.invoke_virtual(&part, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
272 .await?,
273 );
274 index = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "end", "()I", ()).await?;
275 } else if parts.len() == (limit - 1) as usize {
276 let part: ClassInstanceRef<CharSequence> = jvm
277 .invoke_virtual(
278 &input,
279 &input.class_definition().name(),
280 "subSequence",
281 "(II)Ljava/lang/CharSequence;",
282 (index, input_length),
283 )
284 .await?;
285 parts.push(
286 jvm.invoke_virtual(&part, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
287 .await?,
288 );
289 index = jvm.invoke_virtual(&matcher, "java/util/regex/Matcher", "end", "()I", ()).await?;
290 }
291 }
292
293 if index == 0 {
294 parts.clear();
295 parts.push(
296 jvm.invoke_virtual(&input, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
297 .await?,
298 );
299 } else {
300 if !match_limited || parts.len() < limit as usize {
301 let part: ClassInstanceRef<CharSequence> = jvm
302 .invoke_virtual(
303 &input,
304 &input.class_definition().name(),
305 "subSequence",
306 "(II)Ljava/lang/CharSequence;",
307 (index, input_length),
308 )
309 .await?;
310 parts.push(
311 jvm.invoke_virtual(&part, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
312 .await?,
313 );
314 }
315 if limit == 0 {
316 while let Some(part) = parts.last() {
317 if jvm
318 .invoke_virtual::<_, i32>(part, &part.class_definition().name(), "length", "()I", ())
319 .await?
320 != 0
321 {
322 break;
323 }
324 parts.pop();
325 }
326 }
327 }
328
329 let mut result: ClassInstanceRef<Array<String>> = jvm.instantiate_array("Ljava/lang/String;", parts.len()).await?.into();
330 jvm.store_array(&mut result, 0, parts).await?;
331 Ok(result)
332 }
333
334 pub(crate) async fn build_regex(jvm: &Jvm, source: &str, original: &ClassInstanceRef<String>, flags: i32, full_match: bool) -> Result<Regex> {
335 let expression = if full_match { format!("\\A(?:{source})\\z") } else { source.to_string() };
336 let mut builder = RegexBuilder::new(&expression);
337 builder
338 .case_insensitive(flags & 2 != 0)
339 .ignore_whitespace(flags & 4 != 0)
340 .multi_line(flags & 8 != 0)
341 .dot_matches_new_line(flags & 32 != 0);
342 let regex = builder.build();
343 let regex = if full_match && regex.is_err() {
344 let expression = format!("\\A(?:{source}\n)\\z");
345 let mut builder = RegexBuilder::new(&expression);
346 builder
347 .case_insensitive(flags & 2 != 0)
348 .ignore_whitespace(flags & 4 != 0)
349 .multi_line(flags & 8 != 0)
350 .dot_matches_new_line(flags & 32 != 0);
351 builder.build()
352 } else {
353 regex
354 };
355
356 match regex {
357 Ok(regex) => Ok(regex),
358 Err(error) => {
359 let description = JavaLangString::from_rust_string(jvm, &error.to_string()).await?;
360 let exception = jvm
361 .new_class(
362 "java/util/regex/PatternSyntaxException",
363 "(Ljava/lang/String;Ljava/lang/String;I)V",
364 (description, original.clone(), -1),
365 )
366 .await?;
367 Err(JavaError::JavaException(exception))
368 }
369 }
370 }
371}