Skip to main content

rustjava_runtime/classes/java/lang/
character.rs

1use core::char;
2
3use alloc::vec;
4
5use jvm::{ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangClass};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10    RuntimeClassProto, RuntimeContext,
11    classes::java::lang::{Object, String},
12};
13
14// public final class java.lang.Character
15pub struct Character;
16
17impl Character {
18    pub fn as_proto() -> RuntimeClassProto {
19        RuntimeClassProto {
20            name: "java/lang/Character",
21            parent_class: Some("java/lang/Object"),
22            interfaces: vec!["java/io/Serializable", "java/lang/Comparable"],
23            methods: vec![
24                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
25                JavaMethodProto::new("<init>", "(C)V", Self::init, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new(
27                    "valueOf",
28                    "(C)Ljava/lang/Character;",
29                    Self::value_of,
30                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
31                ),
32                JavaMethodProto::new("charValue", "()C", Self::char_value, MethodAccessFlags::PUBLIC),
33                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
35                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new("compareTo", "(Ljava/lang/Character;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new("compareTo", "(Ljava/lang/Object;)I", Self::compare_to_object, MethodAccessFlags::PUBLIC),
38                JavaMethodProto::new(
39                    "isLowerCase",
40                    "(C)Z",
41                    Self::is_lower_case,
42                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
43                ),
44                JavaMethodProto::new(
45                    "isUpperCase",
46                    "(C)Z",
47                    Self::is_upper_case,
48                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
49                ),
50                JavaMethodProto::new(
51                    "isTitleCase",
52                    "(C)Z",
53                    Self::is_title_case,
54                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
55                ),
56                JavaMethodProto::new("isDigit", "(C)Z", Self::is_digit, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
57                JavaMethodProto::new(
58                    "isDefined",
59                    "(C)Z",
60                    Self::is_defined,
61                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
62                ),
63                JavaMethodProto::new("isLetter", "(C)Z", Self::is_letter, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
64                JavaMethodProto::new(
65                    "isLetterOrDigit",
66                    "(C)Z",
67                    Self::is_letter_or_digit,
68                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
69                ),
70                JavaMethodProto::new(
71                    "isJavaLetter",
72                    "(C)Z",
73                    Self::is_java_identifier_start,
74                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
75                ),
76                JavaMethodProto::new(
77                    "isJavaLetterOrDigit",
78                    "(C)Z",
79                    Self::is_java_identifier_part,
80                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
81                ),
82                JavaMethodProto::new(
83                    "isJavaIdentifierStart",
84                    "(C)Z",
85                    Self::is_java_identifier_start,
86                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
87                ),
88                JavaMethodProto::new(
89                    "isJavaIdentifierPart",
90                    "(C)Z",
91                    Self::is_java_identifier_part,
92                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
93                ),
94                JavaMethodProto::new(
95                    "isUnicodeIdentifierStart",
96                    "(C)Z",
97                    Self::is_unicode_identifier_start,
98                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
99                ),
100                JavaMethodProto::new(
101                    "isUnicodeIdentifierPart",
102                    "(C)Z",
103                    Self::is_unicode_identifier_part,
104                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
105                ),
106                JavaMethodProto::new(
107                    "isIdentifierIgnorable",
108                    "(C)Z",
109                    Self::is_identifier_ignorable,
110                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
111                ),
112                JavaMethodProto::new("isSpace", "(C)Z", Self::is_space, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
113                JavaMethodProto::new(
114                    "isSpaceChar",
115                    "(C)Z",
116                    Self::is_space_char,
117                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
118                ),
119                JavaMethodProto::new(
120                    "isWhitespace",
121                    "(C)Z",
122                    Self::is_whitespace,
123                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
124                ),
125                JavaMethodProto::new(
126                    "isISOControl",
127                    "(C)Z",
128                    Self::is_iso_control,
129                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
130                ),
131                JavaMethodProto::new(
132                    "toLowerCase",
133                    "(C)C",
134                    Self::to_lower_case,
135                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
136                ),
137                JavaMethodProto::new(
138                    "toUpperCase",
139                    "(C)C",
140                    Self::to_upper_case,
141                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
142                ),
143                JavaMethodProto::new(
144                    "toTitleCase",
145                    "(C)C",
146                    Self::to_title_case,
147                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
148                ),
149                JavaMethodProto::new("digit", "(CI)I", Self::digit, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
150                JavaMethodProto::new(
151                    "forDigit",
152                    "(II)C",
153                    Self::for_digit,
154                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
155                ),
156                JavaMethodProto::new(
157                    "getNumericValue",
158                    "(C)I",
159                    Self::get_numeric_value,
160                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
161                ),
162                JavaMethodProto::new("getType", "(C)I", Self::get_type, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
163            ],
164            fields: vec![
165                JavaFieldProto::new(
166                    "MIN_VALUE",
167                    "C",
168                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
169                ),
170                JavaFieldProto::new(
171                    "MAX_VALUE",
172                    "C",
173                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
174                ),
175                JavaFieldProto::new(
176                    "MIN_RADIX",
177                    "I",
178                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
179                ),
180                JavaFieldProto::new(
181                    "MAX_RADIX",
182                    "I",
183                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
184                ),
185                JavaFieldProto::new(
186                    "TYPE",
187                    "Ljava/lang/Class;",
188                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
189                ),
190                JavaFieldProto::new(
191                    "UNASSIGNED",
192                    "B",
193                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
194                ),
195                JavaFieldProto::new(
196                    "UPPERCASE_LETTER",
197                    "B",
198                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
199                ),
200                JavaFieldProto::new(
201                    "LOWERCASE_LETTER",
202                    "B",
203                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
204                ),
205                JavaFieldProto::new(
206                    "TITLECASE_LETTER",
207                    "B",
208                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
209                ),
210                JavaFieldProto::new(
211                    "MODIFIER_LETTER",
212                    "B",
213                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
214                ),
215                JavaFieldProto::new(
216                    "OTHER_LETTER",
217                    "B",
218                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
219                ),
220                JavaFieldProto::new(
221                    "NON_SPACING_MARK",
222                    "B",
223                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
224                ),
225                JavaFieldProto::new(
226                    "ENCLOSING_MARK",
227                    "B",
228                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
229                ),
230                JavaFieldProto::new(
231                    "COMBINING_SPACING_MARK",
232                    "B",
233                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
234                ),
235                JavaFieldProto::new(
236                    "DECIMAL_DIGIT_NUMBER",
237                    "B",
238                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
239                ),
240                JavaFieldProto::new(
241                    "LETTER_NUMBER",
242                    "B",
243                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
244                ),
245                JavaFieldProto::new(
246                    "OTHER_NUMBER",
247                    "B",
248                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
249                ),
250                JavaFieldProto::new(
251                    "SPACE_SEPARATOR",
252                    "B",
253                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
254                ),
255                JavaFieldProto::new(
256                    "LINE_SEPARATOR",
257                    "B",
258                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
259                ),
260                JavaFieldProto::new(
261                    "PARAGRAPH_SEPARATOR",
262                    "B",
263                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
264                ),
265                JavaFieldProto::new(
266                    "CONTROL",
267                    "B",
268                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
269                ),
270                JavaFieldProto::new(
271                    "FORMAT",
272                    "B",
273                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
274                ),
275                JavaFieldProto::new(
276                    "PRIVATE_USE",
277                    "B",
278                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
279                ),
280                JavaFieldProto::new(
281                    "SURROGATE",
282                    "B",
283                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
284                ),
285                JavaFieldProto::new(
286                    "DASH_PUNCTUATION",
287                    "B",
288                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
289                ),
290                JavaFieldProto::new(
291                    "START_PUNCTUATION",
292                    "B",
293                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
294                ),
295                JavaFieldProto::new(
296                    "END_PUNCTUATION",
297                    "B",
298                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
299                ),
300                JavaFieldProto::new(
301                    "CONNECTOR_PUNCTUATION",
302                    "B",
303                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
304                ),
305                JavaFieldProto::new(
306                    "OTHER_PUNCTUATION",
307                    "B",
308                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
309                ),
310                JavaFieldProto::new(
311                    "MATH_SYMBOL",
312                    "B",
313                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
314                ),
315                JavaFieldProto::new(
316                    "CURRENCY_SYMBOL",
317                    "B",
318                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
319                ),
320                JavaFieldProto::new(
321                    "MODIFIER_SYMBOL",
322                    "B",
323                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
324                ),
325                JavaFieldProto::new(
326                    "OTHER_SYMBOL",
327                    "B",
328                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
329                ),
330                JavaFieldProto::new("value", "C", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
331            ],
332            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
333        }
334    }
335
336    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
337        jvm.put_static_field("java/lang/Character", "MIN_VALUE", "C", JavaChar::MIN).await?;
338        jvm.put_static_field("java/lang/Character", "MAX_VALUE", "C", JavaChar::MAX).await?;
339        jvm.put_static_field("java/lang/Character", "MIN_RADIX", "I", 2i32).await?;
340        jvm.put_static_field("java/lang/Character", "MAX_RADIX", "I", 36i32).await?;
341        jvm.put_static_field(
342            "java/lang/Character",
343            "TYPE",
344            "Ljava/lang/Class;",
345            JavaLangClass::from_rust_primitive(jvm, "char").await?,
346        )
347        .await?;
348
349        for (name, value) in [
350            ("UNASSIGNED", 0i8),
351            ("UPPERCASE_LETTER", 1),
352            ("LOWERCASE_LETTER", 2),
353            ("TITLECASE_LETTER", 3),
354            ("MODIFIER_LETTER", 4),
355            ("OTHER_LETTER", 5),
356            ("NON_SPACING_MARK", 6),
357            ("ENCLOSING_MARK", 7),
358            ("COMBINING_SPACING_MARK", 8),
359            ("DECIMAL_DIGIT_NUMBER", 9),
360            ("LETTER_NUMBER", 10),
361            ("OTHER_NUMBER", 11),
362            ("SPACE_SEPARATOR", 12),
363            ("LINE_SEPARATOR", 13),
364            ("PARAGRAPH_SEPARATOR", 14),
365            ("CONTROL", 15),
366            ("FORMAT", 16),
367            ("PRIVATE_USE", 18),
368            ("SURROGATE", 19),
369            ("DASH_PUNCTUATION", 20),
370            ("START_PUNCTUATION", 21),
371            ("END_PUNCTUATION", 22),
372            ("CONNECTOR_PUNCTUATION", 23),
373            ("OTHER_PUNCTUATION", 24),
374            ("MATH_SYMBOL", 25),
375            ("CURRENCY_SYMBOL", 26),
376            ("MODIFIER_SYMBOL", 27),
377            ("OTHER_SYMBOL", 28),
378        ] {
379            jvm.put_static_field("java/lang/Character", name, "B", value).await?;
380        }
381
382        Ok(())
383    }
384
385    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: JavaChar) -> Result<()> {
386        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
387        jvm.put_field(&mut this, "value", "C", value).await
388    }
389
390    async fn char_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<JavaChar> {
391        jvm.get_field(&this, "value", "C").await
392    }
393
394    async fn value_of(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<ClassInstanceRef<Self>> {
395        Ok(jvm.new_class("java/lang/Character", "(C)V", (value,)).await?.into())
396    }
397
398    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
399        let value: JavaChar = jvm.invoke_virtual(&this, "java/lang/Character", "charValue", "()C", ()).await?;
400        jvm.invoke_static("java/lang/String", "valueOf", "(C)Ljava/lang/String;", (value,)).await
401    }
402
403    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
404        let value: JavaChar = jvm.invoke_virtual(&this, "java/lang/Character", "charValue", "()C", ()).await?;
405        Ok(i32::from(value))
406    }
407
408    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
409        if other.is_null() || !jvm.is_instance(&**other, "java/lang/Character") {
410            return Ok(false);
411        }
412
413        let this_value: JavaChar = jvm.invoke_virtual(&this, "java/lang/Character", "charValue", "()C", ()).await?;
414        let other_value: JavaChar = jvm.invoke_virtual(&other, "java/lang/Character", "charValue", "()C", ()).await?;
415        Ok(this_value == other_value)
416    }
417
418    async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
419        if other.is_null() {
420            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
421        }
422        if !jvm.is_instance(&**other, "java/lang/Character") {
423            return Err(jvm.exception("java/lang/ClassCastException", "not Character").await);
424        }
425
426        let this_value: JavaChar = jvm.invoke_virtual(&this, "java/lang/Character", "charValue", "()C", ()).await?;
427        let other_value: JavaChar = jvm.invoke_virtual(&other, "java/lang/Character", "charValue", "()C", ()).await?;
428        Ok(this_value.cmp(&other_value) as i32)
429    }
430
431    async fn compare_to_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
432        if other.is_null() {
433            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
434        }
435        if !jvm.is_instance(&**other, "java/lang/Character") {
436            return Err(jvm.exception("java/lang/ClassCastException", "not Character").await);
437        }
438
439        let other = ClassInstanceRef::<Self>::from(other.instance);
440        let this_value: JavaChar = jvm.invoke_virtual(&this, "java/lang/Character", "charValue", "()C", ()).await?;
441        let other_value: JavaChar = jvm.invoke_virtual(&other, "java/lang/Character", "charValue", "()C", ()).await?;
442        Ok(this_value.cmp(&other_value) as i32)
443    }
444
445    async fn is_lower_case(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
446        Ok(char::from_u32(u32::from(value)).is_some_and(char::is_lowercase))
447    }
448
449    async fn is_upper_case(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
450        Ok(char::from_u32(u32::from(value)).is_some_and(char::is_uppercase))
451    }
452
453    async fn is_title_case(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
454        Ok(matches!(
455            value,
456            0x01c5 | 0x01c8 | 0x01cb | 0x01f2 | 0x1f88..=0x1f8f | 0x1f98..=0x1f9f | 0x1fa8..=0x1faf | 0x1fbc | 0x1fcc | 0x1ffc
457        ))
458    }
459
460    async fn is_digit(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
461        Ok(Self::decimal_digit_value(value).is_some())
462    }
463
464    async fn is_defined(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
465        let category: i32 = jvm.invoke_static("java/lang/Character", "getType", "(C)I", (value,)).await?;
466        Ok(category != 0)
467    }
468
469    async fn is_letter(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
470        let category: i32 = jvm.invoke_static("java/lang/Character", "getType", "(C)I", (value,)).await?;
471        Ok((1..=5).contains(&category))
472    }
473
474    async fn is_letter_or_digit(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
475        let category: i32 = jvm.invoke_static("java/lang/Character", "getType", "(C)I", (value,)).await?;
476        Ok((1..=5).contains(&category) || category == 9)
477    }
478
479    async fn is_java_identifier_start(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
480        let category: i32 = jvm.invoke_static("java/lang/Character", "getType", "(C)I", (value,)).await?;
481        Ok((1..=5).contains(&category) || matches!(category, 10 | 23 | 26))
482    }
483
484    async fn is_java_identifier_part(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
485        let category: i32 = jvm.invoke_static("java/lang/Character", "getType", "(C)I", (value,)).await?;
486        Ok((1..=10).contains(&category)
487            || matches!(category, 23 | 26)
488            || matches!(
489                value,
490                0x0000..=0x0008 | 0x000e..=0x001b | 0x007f..=0x009f | 0x200b..=0x200f | 0x202a..=0x202e | 0x2060..=0x206f | 0xfeff
491            ))
492    }
493
494    async fn is_unicode_identifier_start(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
495        let category: i32 = jvm.invoke_static("java/lang/Character", "getType", "(C)I", (value,)).await?;
496        Ok((1..=5).contains(&category) || category == 10)
497    }
498
499    async fn is_unicode_identifier_part(jvm: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
500        let category: i32 = jvm.invoke_static("java/lang/Character", "getType", "(C)I", (value,)).await?;
501        Ok((1..=10).contains(&category)
502            || category == 23
503            || matches!(
504                value,
505                0x0000..=0x0008 | 0x000e..=0x001b | 0x007f..=0x009f | 0x200b..=0x200f | 0x202a..=0x202e | 0x2060..=0x206f | 0xfeff
506            ))
507    }
508
509    async fn is_identifier_ignorable(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
510        Ok(matches!(
511            value,
512            0x0000..=0x0008 | 0x000e..=0x001b | 0x007f..=0x009f | 0x200b..=0x200f | 0x202a..=0x202e | 0x2060..=0x206f | 0xfeff
513        ))
514    }
515
516    async fn is_space(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
517        Ok(matches!(value, 0x0009 | 0x000a | 0x000c | 0x000d | 0x0020))
518    }
519
520    async fn is_space_char(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
521        Ok(matches!(
522            value,
523            0x0020 | 0x00a0 | 0x1680 | 0x2000..=0x200a | 0x2028..=0x2029 | 0x202f | 0x205f | 0x3000
524        ))
525    }
526
527    async fn is_whitespace(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
528        let Some(value) = char::from_u32(u32::from(value)) else {
529            return Ok(false);
530        };
531        Ok((value.is_whitespace() && !matches!(value, '\u{00a0}' | '\u{2007}' | '\u{202f}')) || matches!(value, '\u{001c}'..='\u{001f}'))
532    }
533
534    async fn is_iso_control(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<bool> {
535        Ok(matches!(value, 0x0000..=0x001f | 0x007f..=0x009f))
536    }
537
538    async fn to_lower_case(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<JavaChar> {
539        let Some(character) = char::from_u32(u32::from(value)) else {
540            return Ok(value);
541        };
542        let mut mapped = character.to_lowercase();
543        let Some(first) = mapped.next() else {
544            return Ok(value);
545        };
546        if mapped.next().is_some() || u32::from(first) > u32::from(JavaChar::MAX) {
547            return Ok(value);
548        }
549        Ok(first as JavaChar)
550    }
551
552    async fn to_upper_case(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<JavaChar> {
553        let Some(character) = char::from_u32(u32::from(value)) else {
554            return Ok(value);
555        };
556        let mut mapped = character.to_uppercase();
557        let Some(first) = mapped.next() else {
558            return Ok(value);
559        };
560        if mapped.next().is_some() || u32::from(first) > u32::from(JavaChar::MAX) {
561            return Ok(value);
562        }
563        Ok(first as JavaChar)
564    }
565
566    async fn to_title_case(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<JavaChar> {
567        let title = match value {
568            0x01c4..=0x01c6 => 0x01c5,
569            0x01c7..=0x01c9 => 0x01c8,
570            0x01ca..=0x01cc => 0x01cb,
571            0x01f1..=0x01f3 => 0x01f2,
572            _ => {
573                let Some(character) = char::from_u32(u32::from(value)) else {
574                    return Ok(value);
575                };
576                let mut mapped = character.to_uppercase();
577                let Some(first) = mapped.next() else {
578                    return Ok(value);
579                };
580                if mapped.next().is_some() || u32::from(first) > u32::from(JavaChar::MAX) {
581                    return Ok(value);
582                }
583                first as JavaChar
584            }
585        };
586        Ok(title)
587    }
588
589    async fn digit(_: &Jvm, _: &mut RuntimeContext, value: JavaChar, radix: i32) -> Result<i32> {
590        Ok(Self::digit_value(value, radix))
591    }
592
593    pub(crate) fn digit_value(value: JavaChar, radix: i32) -> i32 {
594        if !(2..=36).contains(&radix) {
595            return -1;
596        }
597
598        let numeric = if let Some(value) = Self::decimal_digit_value(value) {
599            value
600        } else if (b'a' as JavaChar..=b'z' as JavaChar).contains(&value) {
601            i32::from(value - b'a' as JavaChar) + 10
602        } else if (b'A' as JavaChar..=b'Z' as JavaChar).contains(&value) {
603            i32::from(value - b'A' as JavaChar) + 10
604        } else if (0xff41..=0xff5a).contains(&value) {
605            i32::from(value - 0xff41) + 10
606        } else if (0xff21..=0xff3a).contains(&value) {
607            i32::from(value - 0xff21) + 10
608        } else {
609            return -1;
610        };
611
612        if numeric < radix { numeric } else { -1 }
613    }
614
615    async fn for_digit(_: &Jvm, _: &mut RuntimeContext, digit: i32, radix: i32) -> Result<JavaChar> {
616        if !(2..=36).contains(&radix) || !(0..radix).contains(&digit) {
617            return Ok(0);
618        }
619
620        Ok(if digit < 10 {
621            (i32::from(b'0') + digit) as JavaChar
622        } else {
623            (i32::from(b'a') + digit - 10) as JavaChar
624        })
625    }
626
627    async fn get_numeric_value(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<i32> {
628        if let Some(value) = Self::decimal_digit_value(value) {
629            return Ok(value);
630        }
631        if (b'a' as JavaChar..=b'z' as JavaChar).contains(&value) {
632            return Ok(i32::from(value - b'a' as JavaChar) + 10);
633        }
634        if (b'A' as JavaChar..=b'Z' as JavaChar).contains(&value) {
635            return Ok(i32::from(value - b'A' as JavaChar) + 10);
636        }
637        if (0xff41..=0xff5a).contains(&value) {
638            return Ok(i32::from(value - 0xff41) + 10);
639        }
640        if (0xff21..=0xff3a).contains(&value) {
641            return Ok(i32::from(value - 0xff21) + 10);
642        }
643
644        Ok(match value {
645            0x00b2 => 2,
646            0x00b3 => 3,
647            0x00b9 => 1,
648            0x2160..=0x216b => i32::from(value - 0x2160) + 1,
649            0x2170..=0x217b => i32::from(value - 0x2170) + 1,
650            0x00bc..=0x00be => -2,
651            _ => -1,
652        })
653    }
654
655    async fn get_type(_: &Jvm, _: &mut RuntimeContext, value: JavaChar) -> Result<i32> {
656        if char::from_u32(u32::from(value)).is_none() || matches!(value, 0xfdd0..=0xfdef | 0xfffe | 0xffff) {
657            return Ok(0);
658        }
659        if matches!(
660            value,
661            0x01c5 | 0x01c8 | 0x01cb | 0x01f2 | 0x1f88..=0x1f8f | 0x1f98..=0x1f9f | 0x1fa8..=0x1faf | 0x1fbc | 0x1fcc | 0x1ffc
662        ) {
663            return Ok(3);
664        }
665
666        if matches!(value, 0x2160..=0x2188) {
667            return Ok(10);
668        }
669        if Self::decimal_digit_value(value).is_some() {
670            return Ok(9);
671        }
672        if matches!(value, 0x20dd..=0x20e0) {
673            return Ok(7);
674        }
675        if matches!(value, 0x0300..=0x036f | 0x1ab0..=0x1aff | 0x1dc0..=0x1dff | 0x20d0..=0x20ff | 0xfe00..=0xfe0f | 0xfe20..=0xfe2f) {
676            return Ok(6);
677        }
678        if matches!(value, 0x0903 | 0x093b | 0x093e..=0x0940 | 0x0949..=0x094c) {
679            return Ok(8);
680        }
681
682        let character = char::from_u32(u32::from(value));
683        if character.is_some_and(char::is_uppercase) {
684            return Ok(1);
685        }
686        if character.is_some_and(char::is_lowercase) {
687            return Ok(2);
688        }
689        if character.is_some_and(char::is_alphabetic) {
690            return Ok(5);
691        }
692        if matches!(value, 0x00b2..=0x00b3 | 0x00b9 | 0x00bc..=0x00be | 0x2070 | 0x2074..=0x2079 | 0x2080..=0x2089) {
693            return Ok(11);
694        }
695        if value == 0x2028 {
696            return Ok(13);
697        }
698        if value == 0x2029 {
699            return Ok(14);
700        }
701        if matches!(value, 0x0020 | 0x00a0 | 0x1680 | 0x2000..=0x200a | 0x202f | 0x205f | 0x3000) {
702            return Ok(12);
703        }
704        if matches!(value, 0x0000..=0x001f | 0x007f..=0x009f) {
705            return Ok(15);
706        }
707        if matches!(value, 0x00ad | 0x200b..=0x200f | 0x202a..=0x202e | 0x2060..=0x206f | 0xfeff) {
708            return Ok(16);
709        }
710        if matches!(value, 0xe000..=0xf8ff) {
711            return Ok(18);
712        }
713        if matches!(value, 0x002d | 0x058a | 0x2010..=0x2015 | 0x2e17 | 0x2e1a | 0x2e3a..=0x2e3b | 0x301c | 0x3030) {
714            return Ok(20);
715        }
716        if matches!(value, 0x0028 | 0x005b | 0x007b | 0x0f3a | 0x0f3c | 0x169b | 0x201a | 0x201e | 0x2045) {
717            return Ok(21);
718        }
719        if matches!(value, 0x0029 | 0x005d | 0x007d | 0x0f3b | 0x0f3d | 0x169c | 0x2046) {
720            return Ok(22);
721        }
722        if value == 0x00ab {
723            return Ok(21);
724        }
725        if value == 0x00bb {
726            return Ok(22);
727        }
728        if matches!(value, 0x005f | 0x203f..=0x2040 | 0x2054 | 0xfe33..=0xfe34 | 0xfe4d..=0xfe4f | 0xff3f) {
729            return Ok(23);
730        }
731        if matches!(value, 0x0024 | 0x00a2..=0x00a5 | 0x058f | 0x060b | 0x09f2..=0x09f3 | 0x0af1 | 0x0bf9 | 0x0e3f | 0x17db | 0x20a0..=0x20cf | 0xa838 | 0xfdfc | 0xfe69 | 0xff04 | 0xffe0..=0xffe6)
732        {
733            return Ok(26);
734        }
735        if matches!(value, 0x005e | 0x0060 | 0x00a8 | 0x00af | 0x00b4 | 0x00b8 | 0x02b0..=0x02ff) {
736            return Ok(27);
737        }
738        if matches!(value, 0x002b | 0x003c..=0x003e | 0x007c | 0x007e | 0x00ac | 0x00b1 | 0x00d7 | 0x00f7 | 0x2200..=0x22ff) {
739            return Ok(25);
740        }
741        if matches!(value, 0x00a6 | 0x00a9 | 0x00ae | 0x00b0 | 0x2300..=0x23ff | 0x2460..=0x24ff | 0x2600..=0x27bf) {
742            return Ok(28);
743        }
744        if matches!(value, 0x00a1 | 0x00a7 | 0x00b6..=0x00b7 | 0x00bf) {
745            return Ok(24);
746        }
747        if (value <= 0x007e && (value as u8).is_ascii_punctuation()) || matches!(value, 0x2000..=0x206f | 0x3001..=0x303f) {
748            return Ok(24);
749        }
750
751        Ok(0)
752    }
753
754    fn decimal_digit_value(value: JavaChar) -> Option<i32> {
755        let zero = match value {
756            0x0030..=0x0039 => 0x0030,
757            0x0660..=0x0669 => 0x0660,
758            0x06f0..=0x06f9 => 0x06f0,
759            0x07c0..=0x07c9 => 0x07c0,
760            0x0966..=0x096f => 0x0966,
761            0x09e6..=0x09ef => 0x09e6,
762            0x0a66..=0x0a6f => 0x0a66,
763            0x0ae6..=0x0aef => 0x0ae6,
764            0x0b66..=0x0b6f => 0x0b66,
765            0x0be6..=0x0bef => 0x0be6,
766            0x0c66..=0x0c6f => 0x0c66,
767            0x0ce6..=0x0cef => 0x0ce6,
768            0x0d66..=0x0d6f => 0x0d66,
769            0x0e50..=0x0e59 => 0x0e50,
770            0x0ed0..=0x0ed9 => 0x0ed0,
771            0x0f20..=0x0f29 => 0x0f20,
772            0x1040..=0x1049 => 0x1040,
773            0x1090..=0x1099 => 0x1090,
774            0x17e0..=0x17e9 => 0x17e0,
775            0x1810..=0x1819 => 0x1810,
776            0x1946..=0x194f => 0x1946,
777            0x19d0..=0x19d9 => 0x19d0,
778            0x1a80..=0x1a89 => 0x1a80,
779            0x1a90..=0x1a99 => 0x1a90,
780            0x1b50..=0x1b59 => 0x1b50,
781            0x1bb0..=0x1bb9 => 0x1bb0,
782            0x1c40..=0x1c49 => 0x1c40,
783            0x1c50..=0x1c59 => 0x1c50,
784            0xa620..=0xa629 => 0xa620,
785            0xa8d0..=0xa8d9 => 0xa8d0,
786            0xa900..=0xa909 => 0xa900,
787            0xa9d0..=0xa9d9 => 0xa9d0,
788            0xa9f0..=0xa9f9 => 0xa9f0,
789            0xaa50..=0xaa59 => 0xaa50,
790            0xabf0..=0xabf9 => 0xabf0,
791            0xff10..=0xff19 => 0xff10,
792            _ => return None,
793        };
794        Some(i32::from(value - zero))
795    }
796}