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
14pub 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, "java/lang/Character", "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, "java/lang/Character", "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}