Skip to main content

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

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
15// public final class java.util.regex.Pattern
16pub 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}