1use core::future::Future;
2
3use alloc::vec;
4
5use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
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 StringReader;
16
17impl StringReader {
18 pub fn as_proto() -> RuntimeClassProto {
19 RuntimeClassProto {
20 name: "java/io/StringReader",
21 parent_class: Some("java/io/Reader"),
22 interfaces: vec![],
23 methods: vec![
24 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init, MethodAccessFlags::PUBLIC),
25 JavaMethodProto::new("read", "()I", Self::read_char, MethodAccessFlags::PUBLIC),
26 JavaMethodProto::new("read", "([CII)I", Self::read, MethodAccessFlags::PUBLIC),
27 JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new("ready", "()Z", Self::ready, MethodAccessFlags::PUBLIC),
29 JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
30 JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
31 JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC),
32 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
33 ],
34 fields: vec![
35 JavaFieldProto::new("str", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
36 JavaFieldProto::new("length", "I", FieldAccessFlags::PRIVATE),
37 JavaFieldProto::new("next", "I", FieldAccessFlags::PRIVATE),
38 JavaFieldProto::new("mark", "I", FieldAccessFlags::PRIVATE),
39 ],
40 access_flags: ClassAccessFlags::PUBLIC,
41 }
42 }
43
44 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
45 tracing::debug!("java.io.StringReader::<init>({this:?}, {value:?})");
46
47 if value.is_null() {
48 return Err(jvm.exception("java/lang/NullPointerException", "string is null").await);
49 }
50 let _: () = jvm.invoke_special(&this, "java/io/Reader", "<init>", "()V", ()).await?;
51 let length: i32 = jvm.invoke_virtual(&value, "java/lang/String", "length", "()I", ()).await?;
52 jvm.put_field(&mut this, "java/io/StringReader", "str", "Ljava/lang/String;", value)
53 .await?;
54 jvm.put_field(&mut this, "java/io/StringReader", "length", "I", length).await?;
55 jvm.put_field(&mut this, "java/io/StringReader", "next", "I", 0).await?;
56 jvm.put_field(&mut this, "java/io/StringReader", "mark", "I", 0).await
57 }
58
59 async fn with_lock<T, F>(jvm: &Jvm, lock: &ClassInstanceRef<Object>, operation: F) -> Result<T>
60 where
61 F: Future<Output = Result<T>>,
62 {
63 jvm.monitor_enter(lock).await?;
64 match operation.await {
65 Ok(value) => {
66 jvm.monitor_exit(lock).await?;
67 Ok(value)
68 }
69 Err(error) => {
70 if let Err(exit_error) = jvm.monitor_exit(lock).await {
71 tracing::error!(?exit_error, "failed to release StringReader lock");
72 }
73 Err(error)
74 }
75 }
76 }
77
78 async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
79 let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
80 Self::with_lock(jvm, &lock, Self::read_char_locked(jvm, this)).await
81 }
82
83 async fn read_char_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<i32> {
84 tracing::debug!("java.io.StringReader::read({this:?})");
85
86 let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
87 if value.is_null() {
88 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
89 }
90 let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?;
91 let length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?;
92 if next >= length {
93 return Ok(-1);
94 }
95 let result: JavaChar = jvm.invoke_virtual(&value, "java/lang/String", "charAt", "(I)C", (next,)).await?;
96 jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + 1).await?;
97 Ok(result as i32)
98 }
99
100 async fn read(
101 jvm: &Jvm,
102 _: &mut RuntimeContext,
103 this: ClassInstanceRef<Self>,
104 target: ClassInstanceRef<Array<JavaChar>>,
105 offset: i32,
106 length: i32,
107 ) -> Result<i32> {
108 let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
109 Self::with_lock(jvm, &lock, Self::read_locked(jvm, this, target, offset, length)).await
110 }
111
112 async fn read_locked(
113 jvm: &Jvm,
114 mut this: ClassInstanceRef<Self>,
115 target: ClassInstanceRef<Array<JavaChar>>,
116 offset: i32,
117 length: i32,
118 ) -> Result<i32> {
119 tracing::debug!("java.io.StringReader::read({this:?}, {target:?}, {offset}, {length})");
120
121 let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
122 if value.is_null() {
123 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
124 }
125 if target.is_null() {
126 return Err(jvm.exception("java/lang/NullPointerException", "target is null").await);
127 }
128 let target_length = jvm.array_length(&target).await? as i32;
129 if offset < 0 || length < 0 || offset > target_length - length {
130 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
131 }
132 if length == 0 {
133 return Ok(0);
134 }
135
136 let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?;
137 let source_length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?;
138 if next >= source_length {
139 return Ok(-1);
140 }
141 let copied = length.min(source_length - next);
142 let _: () = jvm
143 .invoke_virtual(&value, "java/lang/String", "getChars", "(II[CI)V", (next, next + copied, target, offset))
144 .await?;
145 jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + copied).await?;
146 Ok(copied)
147 }
148
149 async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, amount: i64) -> Result<i64> {
150 let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
151 Self::with_lock(jvm, &lock, Self::skip_locked(jvm, this, amount)).await
152 }
153
154 async fn skip_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>, amount: i64) -> Result<i64> {
155 tracing::debug!("java.io.StringReader::skip({this:?}, {amount})");
156
157 let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
158 if value.is_null() {
159 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
160 }
161 if amount <= 0 {
162 return Ok(0);
163 }
164 let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?;
165 let length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?;
166 let skipped = amount.min((length - next) as i64);
167 jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + skipped as i32)
168 .await?;
169 Ok(skipped)
170 }
171
172 async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
173 let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
174 Self::with_lock(jvm, &lock, Self::ready_locked(jvm, this)).await
175 }
176
177 async fn ready_locked(jvm: &Jvm, this: ClassInstanceRef<Self>) -> Result<bool> {
178 tracing::debug!("java.io.StringReader::ready({this:?})");
179
180 let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
181 if value.is_null() {
182 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
183 }
184 Ok(true)
185 }
186
187 async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
188 tracing::debug!("java.io.StringReader::markSupported({this:?})");
189 Ok(true)
190 }
191
192 async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, read_ahead_limit: i32) -> Result<()> {
193 tracing::debug!("java.io.StringReader::mark({this:?}, {read_ahead_limit})");
194
195 if read_ahead_limit < 0 {
196 return Err(jvm.exception("java/lang/IllegalArgumentException", "Read-ahead limit < 0").await);
197 }
198 let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
199 Self::with_lock(jvm, &lock, Self::mark_locked(jvm, this)).await
200 }
201
202 async fn mark_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
203 let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
204 if value.is_null() {
205 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
206 }
207 let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?;
208 jvm.put_field(&mut this, "java/io/StringReader", "mark", "I", next).await
209 }
210
211 async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
212 let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
213 Self::with_lock(jvm, &lock, Self::reset_locked(jvm, this)).await
214 }
215
216 async fn reset_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
217 tracing::debug!("java.io.StringReader::reset({this:?})");
218
219 let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
220 if value.is_null() {
221 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
222 }
223 let mark: i32 = jvm.get_field(&this, "java/io/StringReader", "mark", "I").await?;
224 jvm.put_field(&mut this, "java/io/StringReader", "next", "I", mark).await
225 }
226
227 async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
228 let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
229 Self::with_lock(jvm, &lock, Self::close_locked(jvm, this)).await
230 }
231
232 async fn close_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
233 tracing::debug!("java.io.StringReader::close({this:?})");
234
235 let null_string: ClassInstanceRef<String> = None.into();
236 jvm.put_field(&mut this, "java/io/StringReader", "str", "Ljava/lang/String;", null_string)
237 .await
238 }
239}