1use alloc::vec;
2
3use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::lang::{Object, String},
10};
11
12pub struct StringTokenizer;
14
15impl StringTokenizer {
16 pub fn as_proto() -> RuntimeClassProto {
17 RuntimeClassProto {
18 name: "java/util/StringTokenizer",
19 parent_class: Some("java/lang/Object"),
20 interfaces: vec!["java/util/Enumeration"],
21 methods: vec![
22 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init, MethodAccessFlags::PUBLIC),
23 JavaMethodProto::new(
24 "<init>",
25 "(Ljava/lang/String;Ljava/lang/String;)V",
26 Self::init_with_delimiters,
27 MethodAccessFlags::PUBLIC,
28 ),
29 JavaMethodProto::new(
30 "<init>",
31 "(Ljava/lang/String;Ljava/lang/String;Z)V",
32 Self::init_with_delimiters_and_return,
33 MethodAccessFlags::PUBLIC,
34 ),
35 JavaMethodProto::new("hasMoreTokens", "()Z", Self::has_more_tokens, MethodAccessFlags::PUBLIC),
36 JavaMethodProto::new("nextToken", "()Ljava/lang/String;", Self::next_token, MethodAccessFlags::PUBLIC),
37 JavaMethodProto::new(
38 "nextToken",
39 "(Ljava/lang/String;)Ljava/lang/String;",
40 Self::next_token_with_delimiters,
41 MethodAccessFlags::PUBLIC,
42 ),
43 JavaMethodProto::new("countTokens", "()I", Self::count_tokens, MethodAccessFlags::PUBLIC),
44 JavaMethodProto::new("hasMoreElements", "()Z", Self::has_more_elements, MethodAccessFlags::PUBLIC),
45 JavaMethodProto::new("nextElement", "()Ljava/lang/Object;", Self::next_element, MethodAccessFlags::PUBLIC),
46 ],
47 fields: vec![
48 JavaFieldProto::new("str", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
49 JavaFieldProto::new("delimiters", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
50 JavaFieldProto::new("currentPosition", "I", FieldAccessFlags::PRIVATE),
51 JavaFieldProto::new("maxPosition", "I", FieldAccessFlags::PRIVATE),
52 JavaFieldProto::new("returnDelimiters", "Z", FieldAccessFlags::PRIVATE),
53 ],
54 access_flags: ClassAccessFlags::PUBLIC,
55 }
56 }
57
58 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<()> {
59 tracing::debug!("java.util.StringTokenizer::<init>({this:?}, {string:?})");
60
61 let delimiters = JavaLangString::from_rust_string(jvm, " \t\n\r\u{000c}").await?;
62 jvm.invoke_special(
63 &this,
64 "java/util/StringTokenizer",
65 "<init>",
66 "(Ljava/lang/String;Ljava/lang/String;Z)V",
67 (string, delimiters, false),
68 )
69 .await
70 }
71
72 async fn init_with_delimiters(
73 jvm: &Jvm,
74 _: &mut RuntimeContext,
75 this: ClassInstanceRef<Self>,
76 string: ClassInstanceRef<String>,
77 delimiters: ClassInstanceRef<String>,
78 ) -> Result<()> {
79 tracing::debug!("java.util.StringTokenizer::<init>({this:?}, {string:?}, {delimiters:?})");
80
81 jvm.invoke_special(
82 &this,
83 "java/util/StringTokenizer",
84 "<init>",
85 "(Ljava/lang/String;Ljava/lang/String;Z)V",
86 (string, delimiters, false),
87 )
88 .await
89 }
90
91 async fn init_with_delimiters_and_return(
92 jvm: &Jvm,
93 _: &mut RuntimeContext,
94 mut this: ClassInstanceRef<Self>,
95 string: ClassInstanceRef<String>,
96 delimiters: ClassInstanceRef<String>,
97 return_delimiters: bool,
98 ) -> Result<()> {
99 tracing::debug!("java.util.StringTokenizer::<init>({this:?}, {string:?}, {delimiters:?}, {return_delimiters:?})");
100
101 if string.is_null() {
102 return Err(jvm.exception("java/lang/NullPointerException", "str").await);
103 }
104
105 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
106 let max_position: i32 = jvm.invoke_virtual(&string, "java/lang/String", "length", "()I", ()).await?;
107 jvm.put_field(&mut this, "java/util/StringTokenizer", "str", "Ljava/lang/String;", string)
108 .await?;
109 jvm.put_field(&mut this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;", delimiters)
110 .await?;
111 jvm.put_field(&mut this, "java/util/StringTokenizer", "currentPosition", "I", 0).await?;
112 jvm.put_field(&mut this, "java/util/StringTokenizer", "maxPosition", "I", max_position)
113 .await?;
114 jvm.put_field(&mut this, "java/util/StringTokenizer", "returnDelimiters", "Z", return_delimiters)
115 .await
116 }
117
118 async fn has_more_tokens(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
119 tracing::debug!("java.util.StringTokenizer::hasMoreTokens({this:?})");
120
121 let string: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?;
122 let delimiters: ClassInstanceRef<String> = jvm
123 .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;")
124 .await?;
125 let position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?;
126 let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?;
127 let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?;
128 Ok(
129 Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters)
130 .await?
131 .is_some(),
132 )
133 }
134
135 async fn next_token(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
136 tracing::debug!("java.util.StringTokenizer::nextToken({this:?})");
137
138 let string: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?;
139 let delimiters: ClassInstanceRef<String> = jvm
140 .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;")
141 .await?;
142 let position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?;
143 let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?;
144 let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?;
145 let Some((start, end)) = Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters).await?
146 else {
147 return Err(jvm.exception("java/util/NoSuchElementException", "StringTokenizer exhausted").await);
148 };
149
150 let token: ClassInstanceRef<String> = jvm
151 .invoke_virtual(
152 &string,
153 "java/lang/String",
154 "substring",
155 "(II)Ljava/lang/String;",
156 (start as i32, end as i32),
157 )
158 .await?;
159 jvm.put_field(&mut this, "java/util/StringTokenizer", "currentPosition", "I", end as i32)
160 .await?;
161 Ok(token)
162 }
163
164 async fn next_token_with_delimiters(
165 jvm: &Jvm,
166 _: &mut RuntimeContext,
167 mut this: ClassInstanceRef<Self>,
168 delimiters: ClassInstanceRef<String>,
169 ) -> Result<ClassInstanceRef<String>> {
170 tracing::debug!("java.util.StringTokenizer::nextToken({this:?}, {delimiters:?})");
171
172 jvm.put_field(&mut this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;", delimiters)
173 .await?;
174 jvm.invoke_virtual(&this, "java/util/StringTokenizer", "nextToken", "()Ljava/lang/String;", ())
175 .await
176 }
177
178 async fn count_tokens(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
179 tracing::debug!("java.util.StringTokenizer::countTokens({this:?})");
180
181 let string: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?;
182 let delimiters: ClassInstanceRef<String> = jvm
183 .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;")
184 .await?;
185 let mut position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?;
186 let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?;
187 let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?;
188 let mut count = 0;
189 while let Some((_, end)) = Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters).await? {
190 count += 1;
191 position = end as i32;
192 }
193 Ok(count)
194 }
195
196 async fn has_more_elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
197 jvm.invoke_virtual(&this, "java/util/StringTokenizer", "hasMoreTokens", "()Z", ()).await
198 }
199
200 async fn next_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
201 let token: ClassInstanceRef<String> = jvm
202 .invoke_virtual(&this, "java/util/StringTokenizer", "nextToken", "()Ljava/lang/String;", ())
203 .await?;
204 Ok(ClassInstanceRef::new(token.instance))
205 }
206
207 async fn token_bounds(
208 jvm: &Jvm,
209 string: &ClassInstanceRef<String>,
210 delimiters: &ClassInstanceRef<String>,
211 mut position: usize,
212 max_position: usize,
213 return_delimiters: bool,
214 ) -> Result<Option<(usize, usize)>> {
215 if delimiters.is_null() {
216 return Err(jvm.exception("java/lang/NullPointerException", "delimiters").await);
217 }
218
219 let string_chars = JavaLangString::to_utf16(jvm, string).await?;
220 let delimiter_chars = JavaLangString::to_utf16(jvm, delimiters).await?;
221 let max_position = max_position.min(string_chars.len());
222
223 if !return_delimiters {
224 while position < max_position && delimiter_chars.contains(&string_chars[position]) {
225 position += 1;
226 }
227 }
228 if position >= max_position {
229 return Ok(None);
230 }
231
232 let start = position;
233 if return_delimiters && delimiter_chars.contains(&string_chars[position]) {
234 return Ok(Some((start, start + 1)));
235 }
236 while position < max_position && !delimiter_chars.contains(&string_chars[position]) {
237 position += 1;
238 }
239 Ok(Some((start, position)))
240 }
241}