1use alloc::{format, string::String as RustString, vec, vec::Vec};
2
3use chrono::{DateTime, Datelike, NaiveDate, TimeZone as ChronoTimeZone, Timelike, Utc};
4use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
5use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
6use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
7
8use crate::{
9 RuntimeClassProto, RuntimeContext,
10 classes::java::{
11 lang::{String, StringBuffer},
12 text::{FieldPosition, NumberFormat, ParsePosition},
13 util::{Calendar, Date, Locale, TimeZone},
14 },
15};
16
17#[derive(Clone)]
18enum DateToken {
19 Literal(RustString),
20 Field(char, usize),
21}
22
23enum DateParseError {
24 Invalid(usize),
25 NullNumberFormat,
26}
27
28impl From<usize> for DateParseError {
29 fn from(index: usize) -> Self {
30 Self::Invalid(index)
31 }
32}
33
34pub struct SimpleDateFormat;
36
37impl SimpleDateFormat {
38 pub fn as_proto() -> RuntimeClassProto {
39 RuntimeClassProto {
40 name: "java/text/SimpleDateFormat",
41 parent_class: Some("java/text/DateFormat"),
42 interfaces: vec![],
43 methods: vec![
44 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
45 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_pattern, MethodAccessFlags::PUBLIC),
46 JavaMethodProto::new(
47 "<init>",
48 "(Ljava/lang/String;Ljava/util/Locale;)V",
49 Self::init_with_pattern_and_locale,
50 MethodAccessFlags::PUBLIC,
51 ),
52 JavaMethodProto::new(
53 "format",
54 "(Ljava/util/Date;Ljava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
55 Self::format,
56 MethodAccessFlags::PUBLIC,
57 ),
58 JavaMethodProto::new(
59 "parse",
60 "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/util/Date;",
61 Self::parse,
62 MethodAccessFlags::PUBLIC,
63 ),
64 JavaMethodProto::new("applyPattern", "(Ljava/lang/String;)V", Self::apply_pattern, MethodAccessFlags::PUBLIC),
65 JavaMethodProto::new("toPattern", "()Ljava/lang/String;", Self::to_pattern, MethodAccessFlags::PUBLIC),
66 ],
67 fields: vec![JavaFieldProto::new("pattern", "Ljava/lang/String;", FieldAccessFlags::PRIVATE)],
68 access_flags: ClassAccessFlags::PUBLIC,
69 }
70 }
71
72 fn tokenize_pattern(pattern: &str) -> Option<Vec<DateToken>> {
73 let characters: Vec<char> = pattern.chars().collect();
74 let mut tokens = Vec::new();
75 let mut literal = RustString::new();
76 let mut quoted = false;
77 let mut index = 0;
78 while index < characters.len() {
79 let character = characters[index];
80 if character == '\'' {
81 if index + 1 < characters.len() && characters[index + 1] == '\'' {
82 literal.push('\'');
83 index += 2;
84 continue;
85 }
86 quoted = !quoted;
87 index += 1;
88 continue;
89 }
90 if !quoted && character.is_ascii_alphabetic() {
91 if !matches!(
92 character,
93 'G' | 'y' | 'M' | 'd' | 'h' | 'H' | 'm' | 's' | 'S' | 'E' | 'D' | 'F' | 'w' | 'W' | 'a' | 'k' | 'K' | 'z'
94 ) {
95 return None;
96 }
97 if !literal.is_empty() {
98 tokens.push(DateToken::Literal(core::mem::take(&mut literal)));
99 }
100 let mut count = 1;
101 while index + count < characters.len() && characters[index + count] == character {
102 count += 1;
103 }
104 tokens.push(DateToken::Field(character, count));
105 index += count;
106 continue;
107 }
108 literal.push(character);
109 index += 1;
110 }
111 if quoted {
112 return None;
113 }
114 if !literal.is_empty() {
115 tokens.push(DateToken::Literal(literal));
116 }
117 Some(tokens)
118 }
119
120 fn parse_number(characters: &[char], index: &mut usize, maximum_digits: Option<usize>) -> Option<i32> {
121 let start = *index;
122 let mut value = 0i32;
123 while *index < characters.len() && characters[*index].is_ascii_digit() && maximum_digits.is_none_or(|maximum| *index - start < maximum) {
124 value = value.checked_mul(10)?.checked_add(characters[*index].to_digit(10)? as i32)?;
125 *index += 1;
126 }
127 if *index == start { None } else { Some(value) }
128 }
129
130 fn starts_with_ignore_ascii_case(characters: &[char], index: usize, value: &str) -> bool {
131 let value: Vec<char> = value.chars().collect();
132 characters
133 .get(index..index + value.len())
134 .is_some_and(|candidate| candidate.iter().zip(value).all(|(left, right)| left.eq_ignore_ascii_case(&right)))
135 }
136
137 fn parse_timestamp(
138 tokens: &[DateToken],
139 characters: &[char],
140 start: usize,
141 default_offset: i32,
142 number_format_is_null: bool,
143 ) -> core::result::Result<(i64, usize), DateParseError> {
144 let months = [
145 ("January", "Jan"),
146 ("February", "Feb"),
147 ("March", "Mar"),
148 ("April", "Apr"),
149 ("May", "May"),
150 ("June", "Jun"),
151 ("July", "Jul"),
152 ("August", "Aug"),
153 ("September", "Sep"),
154 ("October", "Oct"),
155 ("November", "Nov"),
156 ("December", "Dec"),
157 ];
158 let weekdays = [
159 ("Sunday", "Sun"),
160 ("Monday", "Mon"),
161 ("Tuesday", "Tue"),
162 ("Wednesday", "Wed"),
163 ("Thursday", "Thu"),
164 ("Friday", "Fri"),
165 ("Saturday", "Sat"),
166 ];
167
168 let mut index = start;
169 let mut era = 1;
170 let mut year = 1970;
171 let mut month = 1;
172 let mut day = 1;
173 let mut ordinal = None;
174 let mut month_set = false;
175 let mut day_set = false;
176 let mut hour = 0;
177 let mut twelve_hour = None;
178 let mut am_pm = 0;
179 let mut minute = 0;
180 let mut second = 0;
181 let mut millisecond = 0;
182 let mut offset = default_offset;
183
184 for token in tokens {
185 match token {
186 DateToken::Literal(literal) => {
187 let value: Vec<char> = literal.chars().collect();
188 if !characters[index..].starts_with(&value) {
189 return Err(DateParseError::Invalid(index));
190 }
191 index += value.len();
192 }
193 DateToken::Field(character, count)
194 if number_format_is_null
195 && characters[index..].iter().any(|character| !matches!(character, ' ' | '\t'))
196 && (matches!(character, 'y' | 'd' | 'H' | 'k' | 'h' | 'K' | 'm' | 's' | 'S' | 'D' | 'F' | 'w' | 'W')
197 || (*character == 'M' && *count < 3)) =>
198 {
199 return Err(DateParseError::NullNumberFormat);
200 }
201 DateToken::Field(character, count) => match character {
202 'G' => {
203 if Self::starts_with_ignore_ascii_case(characters, index, "AD") {
204 era = 1;
205 index += 2;
206 } else if Self::starts_with_ignore_ascii_case(characters, index, "BC") {
207 era = 0;
208 index += 2;
209 } else {
210 return Err(DateParseError::Invalid(index));
211 }
212 }
213 'y' => {
214 let value = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
215 year = if *count == 2 {
216 if value <= 69 { 2000 + value } else { 1900 + value }
217 } else {
218 value
219 };
220 }
221 'M' if *count >= 3 => {
222 let mut parsed = None;
223 for (position, (full, short)) in months.iter().enumerate() {
224 let candidate = if *count >= 4 { *full } else { *short };
225 if Self::starts_with_ignore_ascii_case(characters, index, candidate) {
226 parsed = Some((position as i32 + 1, candidate.len()));
227 break;
228 }
229 }
230 let Some((value, length)) = parsed else {
231 return Err(DateParseError::Invalid(index));
232 };
233 month = value;
234 month_set = true;
235 index += length;
236 }
237 'M' => {
238 month = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
239 month_set = true;
240 }
241 'd' => {
242 day = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
243 day_set = true;
244 }
245 'H' => hour = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?,
246 'k' => {
247 let value = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
248 if !(1..=24).contains(&value) {
249 return Err(DateParseError::Invalid(index));
250 }
251 hour = value % 24;
252 }
253 'h' | 'K' => {
254 let value = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
255 twelve_hour = Some((*character, value));
256 }
257 'm' => minute = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?,
258 's' => second = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?,
259 'S' => millisecond = Self::parse_number(characters, &mut index, Some((*count).max(1))).ok_or(index)?,
260 'E' => {
261 let mut consumed = None;
262 for (full, short) in weekdays {
263 for candidate in [full, short] {
264 if Self::starts_with_ignore_ascii_case(characters, index, candidate) {
265 consumed = Some(candidate.len());
266 break;
267 }
268 }
269 if consumed.is_some() {
270 break;
271 }
272 }
273 let Some(length) = consumed else {
274 return Err(DateParseError::Invalid(index));
275 };
276 index += length;
277 }
278 'D' => ordinal = Some(Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?),
279 'F' | 'w' | 'W' => {
280 let _ = Self::parse_number(characters, &mut index, if *count > 1 { Some(*count) } else { None }).ok_or(index)?;
281 }
282 'a' => {
283 if Self::starts_with_ignore_ascii_case(characters, index, "AM") {
284 am_pm = 0;
285 index += 2;
286 } else if Self::starts_with_ignore_ascii_case(characters, index, "PM") {
287 am_pm = 1;
288 index += 2;
289 } else {
290 return Err(DateParseError::Invalid(index));
291 }
292 }
293 'z' => {
294 if Self::starts_with_ignore_ascii_case(characters, index, "GMT")
295 || Self::starts_with_ignore_ascii_case(characters, index, "UTC")
296 {
297 index += 3;
298 } else {
299 return Err(DateParseError::Invalid(index));
300 }
301 offset = 0;
302 if index < characters.len() && matches!(characters[index], '+' | '-') {
303 let sign = if characters[index] == '-' { -1 } else { 1 };
304 index += 1;
305 let hours = Self::parse_number(characters, &mut index, Some(2)).ok_or(index)?;
306 if index >= characters.len() || characters[index] != ':' {
307 return Err(DateParseError::Invalid(index));
308 }
309 index += 1;
310 let minutes = Self::parse_number(characters, &mut index, Some(2)).ok_or(index)?;
311 if hours > 23 || minutes > 59 {
312 return Err(DateParseError::Invalid(index));
313 }
314 offset = sign * (hours * 60 + minutes) * 60 * 1000;
315 }
316 }
317 _ => return Err(DateParseError::Invalid(index)),
318 },
319 }
320 }
321
322 if let Some((kind, value)) = twelve_hour {
323 hour = match kind {
324 'h' if (1..=12).contains(&value) => value % 12 + am_pm * 12,
325 'K' if (0..=11).contains(&value) => value + am_pm * 12,
326 _ => return Err(DateParseError::Invalid(index)),
327 };
328 }
329 if era == 0 {
330 year = 1 - year;
331 }
332 if let Some(ordinal) = ordinal.filter(|_| !month_set && !day_set) {
333 let Some(date) = NaiveDate::from_yo_opt(year, ordinal as u32) else {
334 return Err(DateParseError::Invalid(index));
335 };
336 month = date.month() as i32;
337 day = date.day() as i32;
338 }
339 if !(1..=12).contains(&month)
340 || !(1..=31).contains(&day)
341 || !(0..=23).contains(&hour)
342 || !(0..=59).contains(&minute)
343 || !(0..=59).contains(&second)
344 || !(0..=999).contains(&millisecond)
345 {
346 return Err(DateParseError::Invalid(index));
347 }
348 let Some(date_time) = Utc
349 .with_ymd_and_hms(year, month as u32, day as u32, hour as u32, minute as u32, second as u32)
350 .single()
351 else {
352 return Err(DateParseError::Invalid(index));
353 };
354 let Some(timestamp) = date_time
355 .timestamp_millis()
356 .checked_add(i64::from(millisecond))
357 .and_then(|value| value.checked_sub(i64::from(offset)))
358 else {
359 return Err(DateParseError::Invalid(index));
360 };
361 Ok((timestamp, index))
362 }
363
364 fn date_field(character: char) -> Option<i32> {
365 match character {
366 'G' => Some(0),
367 'y' => Some(1),
368 'M' => Some(2),
369 'd' => Some(3),
370 'k' => Some(4),
371 'H' => Some(5),
372 'm' => Some(6),
373 's' => Some(7),
374 'S' => Some(8),
375 'E' => Some(9),
376 'D' => Some(10),
377 'F' => Some(11),
378 'w' => Some(12),
379 'W' => Some(13),
380 'a' => Some(14),
381 'h' => Some(15),
382 'K' => Some(16),
383 'z' => Some(17),
384 _ => None,
385 }
386 }
387
388 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
389 let pattern = JavaLangString::from_rust_string(jvm, "M/d/yy h:mm a").await?;
390 jvm.invoke_special(&this, "java/text/SimpleDateFormat", "<init>", "(Ljava/lang/String;)V", (pattern,))
391 .await
392 }
393
394 async fn init_with_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
395 let locale: ClassInstanceRef<Locale> = jvm.invoke_static("java/util/Locale", "getDefault", "()Ljava/util/Locale;", ()).await?;
396 jvm.invoke_special(
397 &this,
398 "java/text/SimpleDateFormat",
399 "<init>",
400 "(Ljava/lang/String;Ljava/util/Locale;)V",
401 (pattern, locale),
402 )
403 .await
404 }
405
406 async fn init_with_pattern_and_locale(
407 jvm: &Jvm,
408 _: &mut RuntimeContext,
409 mut this: ClassInstanceRef<Self>,
410 pattern: ClassInstanceRef<String>,
411 locale: ClassInstanceRef<Locale>,
412 ) -> Result<()> {
413 if pattern.is_null() || locale.is_null() {
414 return Err(jvm.exception("java/lang/NullPointerException", "pattern or locale").await);
415 }
416 let value = JavaLangString::to_rust_string(jvm, &pattern).await?;
417 if Self::tokenize_pattern(&value).is_none() {
418 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern character").await);
419 }
420 let _: () = jvm.invoke_special(&this, "java/text/DateFormat", "<init>", "()V", ()).await?;
421 jvm.put_field(&mut this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;", pattern)
422 .await
423 }
424
425 async fn apply_pattern(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, pattern: ClassInstanceRef<String>) -> Result<()> {
426 if pattern.is_null() {
427 return Err(jvm.exception("java/lang/NullPointerException", "pattern").await);
428 }
429 let value = JavaLangString::to_rust_string(jvm, &pattern).await?;
430 if Self::tokenize_pattern(&value).is_none() {
431 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern character").await);
432 }
433 jvm.put_field(&mut this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;", pattern)
434 .await
435 }
436
437 async fn to_pattern(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
438 jvm.get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;").await
439 }
440
441 async fn format(
442 jvm: &Jvm,
443 _: &mut RuntimeContext,
444 this: ClassInstanceRef<Self>,
445 date: ClassInstanceRef<Date>,
446 buffer: ClassInstanceRef<StringBuffer>,
447 position: ClassInstanceRef<FieldPosition>,
448 ) -> Result<ClassInstanceRef<StringBuffer>> {
449 if date.is_null() || buffer.is_null() || position.is_null() {
450 return Err(jvm.exception("java/lang/NullPointerException", "date, buffer, or position").await);
451 }
452 let number_format: ClassInstanceRef<NumberFormat> = jvm
453 .get_field(&this, "java/text/DateFormat", "numberFormat", "Ljava/text/NumberFormat;")
454 .await?;
455 if number_format.is_null() {
456 return Err(jvm.exception("java/lang/NullPointerException", "numberFormat").await);
457 }
458 let pattern: ClassInstanceRef<String> = jvm
459 .get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;")
460 .await?;
461 let pattern = JavaLangString::to_rust_string(jvm, &pattern).await?;
462 let Some(tokens) = Self::tokenize_pattern(&pattern) else {
463 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await);
464 };
465 let time: i64 = jvm.invoke_virtual(&date, "java/util/Date", "getTime", "()J", ()).await?;
466 let calendar: ClassInstanceRef<Calendar> = jvm
467 .get_field(&this, "java/text/SimpleDateFormat", "calendar", "Ljava/util/Calendar;")
468 .await?;
469 if calendar.is_null() {
470 return Err(jvm.exception("java/lang/NullPointerException", "calendar").await);
471 }
472 let time_zone: ClassInstanceRef<TimeZone> = jvm
473 .invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ())
474 .await?;
475 if time_zone.is_null() {
476 return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await);
477 }
478 let offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
479 let Some(adjusted) = time.checked_add(i64::from(offset)) else {
480 return Err(jvm.exception("java/lang/IllegalArgumentException", "date out of range").await);
481 };
482 let Some(date_time) = DateTime::<Utc>::from_timestamp_millis(adjusted) else {
483 return Err(jvm.exception("java/lang/IllegalArgumentException", "date out of range").await);
484 };
485
486 let months = [
487 "January",
488 "February",
489 "March",
490 "April",
491 "May",
492 "June",
493 "July",
494 "August",
495 "September",
496 "October",
497 "November",
498 "December",
499 ];
500 let short_months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
501 let weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
502 let short_weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
503 let requested_field: i32 = jvm.invoke_virtual(&position, "java/text/FieldPosition", "getField", "()I", ()).await?;
504 let base: i32 = jvm.invoke_virtual(&buffer, "java/lang/StringBuffer", "length", "()I", ()).await?;
505 let mut field_position_set = false;
506 let mut formatted = RustString::new();
507 for token in tokens {
508 match token {
509 DateToken::Literal(value) => formatted.push_str(&value),
510 DateToken::Field(character, count) => {
511 let begin = formatted.encode_utf16().count() as i32;
512 match character {
513 'G' => formatted.push_str(if date_time.year() <= 0 { "BC" } else { "AD" }),
514 'y' => {
515 let year = if date_time.year() <= 0 { 1 - date_time.year() } else { date_time.year() };
516 if count == 2 {
517 formatted.push_str(&format!("{:02}", year.rem_euclid(100)));
518 } else {
519 formatted.push_str(&format!("{year:0count$}"));
520 }
521 }
522 'M' if count >= 4 => formatted.push_str(months[date_time.month0() as usize]),
523 'M' if count == 3 => formatted.push_str(short_months[date_time.month0() as usize]),
524 'M' => formatted.push_str(&format!("{:0count$}", date_time.month())),
525 'd' => formatted.push_str(&format!("{:0count$}", date_time.day())),
526 'h' => {
527 let hour = date_time.hour() % 12;
528 formatted.push_str(&format!("{:0count$}", if hour == 0 { 12 } else { hour }));
529 }
530 'H' => formatted.push_str(&format!("{:0count$}", date_time.hour())),
531 'm' => formatted.push_str(&format!("{:0count$}", date_time.minute())),
532 's' => formatted.push_str(&format!("{:0count$}", date_time.second())),
533 'S' => formatted.push_str(&format!("{:0count$}", date_time.timestamp_subsec_millis())),
534 'E' if count >= 4 => formatted.push_str(weekdays[date_time.weekday().num_days_from_sunday() as usize]),
535 'E' => formatted.push_str(short_weekdays[date_time.weekday().num_days_from_sunday() as usize]),
536 'D' => formatted.push_str(&format!("{:0count$}", date_time.ordinal())),
537 'F' | 'W' => formatted.push_str(&format!("{:0count$}", (date_time.day() - 1) / 7 + 1)),
538 'w' => formatted.push_str(&format!("{:0count$}", date_time.iso_week().week())),
539 'a' => formatted.push_str(if date_time.hour() < 12 { "AM" } else { "PM" }),
540 'k' => formatted.push_str(&format!("{:0count$}", if date_time.hour() == 0 { 24 } else { date_time.hour() })),
541 'K' => formatted.push_str(&format!("{:0count$}", date_time.hour() % 12)),
542 'z' => {
543 if offset == 0 {
544 formatted.push_str("GMT");
545 } else {
546 let absolute = offset.unsigned_abs() / 60_000;
547 formatted.push_str(&format!(
548 "GMT{}{:02}:{:02}",
549 if offset < 0 { '-' } else { '+' },
550 absolute / 60,
551 absolute % 60
552 ));
553 }
554 }
555 _ => return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await),
556 }
557 if !field_position_set && Self::date_field(character) == Some(requested_field) {
558 let _: () = jvm
559 .invoke_virtual(&position, "java/text/FieldPosition", "setBeginIndex", "(I)V", (base + begin,))
560 .await?;
561 let _: () = jvm
562 .invoke_virtual(
563 &position,
564 "java/text/FieldPosition",
565 "setEndIndex",
566 "(I)V",
567 (base + formatted.encode_utf16().count() as i32,),
568 )
569 .await?;
570 field_position_set = true;
571 }
572 }
573 }
574 }
575 let text = JavaLangString::from_rust_string(jvm, &formatted).await?;
576 jvm.invoke_virtual(
577 &buffer,
578 "java/lang/StringBuffer",
579 "append",
580 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
581 (text,),
582 )
583 .await
584 }
585
586 async fn parse(
587 jvm: &Jvm,
588 _: &mut RuntimeContext,
589 this: ClassInstanceRef<Self>,
590 source: ClassInstanceRef<String>,
591 position: ClassInstanceRef<ParsePosition>,
592 ) -> Result<ClassInstanceRef<Date>> {
593 if source.is_null() || position.is_null() {
594 return Err(jvm.exception("java/lang/NullPointerException", "source or position").await);
595 }
596 let pattern: ClassInstanceRef<String> = jvm
597 .get_field(&this, "java/text/SimpleDateFormat", "pattern", "Ljava/lang/String;")
598 .await?;
599 let pattern = JavaLangString::to_rust_string(jvm, &pattern).await?;
600 let Some(tokens) = Self::tokenize_pattern(&pattern) else {
601 return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal pattern").await);
602 };
603 let source = JavaLangString::to_rust_string(jvm, &source).await?;
604 let characters: Vec<char> = source.chars().collect();
605 let mut utf16_indices = Vec::with_capacity(characters.len() + 1);
606 let mut utf16_index = 0;
607 for character in &characters {
608 utf16_indices.push(utf16_index);
609 utf16_index += character.len_utf16();
610 }
611 utf16_indices.push(utf16_index);
612 let start: i32 = jvm.invoke_virtual(&position, "java/text/ParsePosition", "getIndex", "()I", ()).await?;
613 if start < 0 {
614 let _: () = jvm
615 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
616 .await?;
617 return Ok(ClassInstanceRef::new(None));
618 }
619 let Some(start_index) = utf16_indices.iter().position(|index| *index == start as usize) else {
620 let _: () = jvm
621 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (start,))
622 .await?;
623 return Ok(ClassInstanceRef::new(None));
624 };
625 let calendar: ClassInstanceRef<Calendar> = jvm
626 .get_field(&this, "java/text/SimpleDateFormat", "calendar", "Ljava/util/Calendar;")
627 .await?;
628 if calendar.is_null() {
629 return Err(jvm.exception("java/lang/NullPointerException", "calendar").await);
630 }
631 let time_zone: ClassInstanceRef<TimeZone> = jvm
632 .invoke_virtual(&calendar, "java/util/Calendar", "getTimeZone", "()Ljava/util/TimeZone;", ())
633 .await?;
634 if time_zone.is_null() {
635 return Err(jvm.exception("java/lang/NullPointerException", "timeZone").await);
636 }
637 let offset: i32 = jvm.invoke_virtual(&time_zone, "java/util/TimeZone", "getRawOffset", "()I", ()).await?;
638 let number_format: ClassInstanceRef<NumberFormat> = jvm
639 .get_field(&this, "java/text/DateFormat", "numberFormat", "Ljava/text/NumberFormat;")
640 .await?;
641 match Self::parse_timestamp(&tokens, &characters, start_index, offset, number_format.is_null()) {
642 Ok((timestamp, index)) => {
643 let _: () = jvm
644 .invoke_virtual(&position, "java/text/ParsePosition", "setIndex", "(I)V", (utf16_indices[index] as i32,))
645 .await?;
646 let _: () = jvm
647 .invoke_virtual(&position, "java/text/ParsePosition", "setErrorIndex", "(I)V", (-1,))
648 .await?;
649 Ok(jvm.new_class("java/util/Date", "(J)V", (timestamp,)).await?.into())
650 }
651 Err(DateParseError::NullNumberFormat) => Err(jvm.exception("java/lang/NullPointerException", "numberFormat").await),
652 Err(DateParseError::Invalid(error_index)) => {
653 let _: () = jvm
654 .invoke_virtual(
655 &position,
656 "java/text/ParsePosition",
657 "setErrorIndex",
658 "(I)V",
659 (utf16_indices[error_index] as i32,),
660 )
661 .await?;
662 Ok(ClassInstanceRef::new(None))
663 }
664 }
665 }
666}