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