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