1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::io::InputStream};
8
9const DEFAULT_BUFFER_SIZE: i32 = 8192;
10
11pub struct BufferedInputStream;
13
14impl BufferedInputStream {
15 pub fn as_proto() -> RuntimeClassProto {
16 RuntimeClassProto {
17 name: "java/io/BufferedInputStream",
18 parent_class: Some("java/io/FilterInputStream"),
19 interfaces: vec![],
20 methods: vec![
21 JavaMethodProto::new("<init>", "(Ljava/io/InputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
22 JavaMethodProto::new("<init>", "(Ljava/io/InputStream;I)V", Self::init_with_size, MethodAccessFlags::PUBLIC),
23 JavaMethodProto::new(
24 "read",
25 "()I",
26 Self::read_byte,
27 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
28 ),
29 JavaMethodProto::new("read", "([BII)I", Self::read, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
30 JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
31 JavaMethodProto::new(
32 "available",
33 "()I",
34 Self::available,
35 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
36 ),
37 JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
38 JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
39 JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
40 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
41 ],
42 fields: vec![
43 JavaFieldProto::new("buf", "[B", FieldAccessFlags::PROTECTED | FieldAccessFlags::VOLATILE),
44 JavaFieldProto::new("count", "I", FieldAccessFlags::PROTECTED),
45 JavaFieldProto::new("pos", "I", FieldAccessFlags::PROTECTED),
46 JavaFieldProto::new("markpos", "I", FieldAccessFlags::PROTECTED),
47 JavaFieldProto::new("marklimit", "I", FieldAccessFlags::PROTECTED),
48 ],
49 access_flags: ClassAccessFlags::PUBLIC,
50 }
51 }
52
53 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, r#in: ClassInstanceRef<InputStream>) -> Result<()> {
54 tracing::debug!("java.io.BufferedInputStream::<init>({this:?}, {in:?})", in = &r#in);
55
56 jvm.invoke_special(
57 &this,
58 "java/io/BufferedInputStream",
59 "<init>",
60 "(Ljava/io/InputStream;I)V",
61 (r#in, DEFAULT_BUFFER_SIZE),
62 )
63 .await
64 }
65
66 async fn init_with_size(
67 jvm: &Jvm,
68 _: &mut RuntimeContext,
69 mut this: ClassInstanceRef<Self>,
70 r#in: ClassInstanceRef<InputStream>,
71 size: i32,
72 ) -> Result<()> {
73 tracing::debug!("java.io.BufferedInputStream::<init>({this:?}, {in:?}, {size})", in = &r#in);
74
75 if r#in.is_null() {
76 return Err(jvm.exception("java/lang/NullPointerException", "input is null").await);
77 }
78 if size <= 0 {
79 return Err(jvm.exception("java/lang/IllegalArgumentException", "Buffer size <= 0").await);
80 }
81
82 let _: () = jvm
83 .invoke_special(&this, "java/io/FilterInputStream", "<init>", "(Ljava/io/InputStream;)V", (r#in,))
84 .await?;
85 let buffer = jvm.instantiate_array("B", size as usize).await?;
86 jvm.put_field(&mut this, "buf", "[B", buffer).await?;
87 jvm.put_field(&mut this, "count", "I", 0).await?;
88 jvm.put_field(&mut this, "pos", "I", 0).await?;
89 jvm.put_field(&mut this, "markpos", "I", -1).await?;
90 jvm.put_field(&mut this, "marklimit", "I", 0).await
91 }
92
93 async fn fill(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<i32> {
94 let r#in: ClassInstanceRef<InputStream> = jvm.get_field(this, "in", "Ljava/io/InputStream;").await?;
95 let mut buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(this, "buf", "[B").await?;
96 if r#in.is_null() || buffer.is_null() {
97 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
98 }
99
100 let mut position: i32 = jvm.get_field(this, "pos", "I").await?;
101 let mut mark_position: i32 = jvm.get_field(this, "markpos", "I").await?;
102 let mark_limit: i32 = jvm.get_field(this, "marklimit", "I").await?;
103 let mut buffer_length = jvm.array_length(&buffer).await? as i32;
104
105 if mark_position < 0 {
106 position = 0;
107 } else if position >= buffer_length {
108 if mark_position > 0 {
109 let preserved = position - mark_position;
110 let _: () = jvm
111 .invoke_static(
112 "java/lang/System",
113 "arraycopy",
114 "(Ljava/lang/Object;ILjava/lang/Object;II)V",
115 (buffer.clone(), mark_position, buffer.clone(), 0, preserved),
116 )
117 .await?;
118 position = preserved;
119 mark_position = 0;
120 } else if buffer_length >= mark_limit {
121 mark_position = -1;
122 position = 0;
123 } else {
124 let new_length = (buffer_length.saturating_mul(2)).min(mark_limit).max(buffer_length + 1);
125 let new_buffer: ClassInstanceRef<Array<i8>> = jvm.instantiate_array("B", new_length as usize).await?.into();
126 let _: () = jvm
127 .invoke_static(
128 "java/lang/System",
129 "arraycopy",
130 "(Ljava/lang/Object;ILjava/lang/Object;II)V",
131 (buffer, 0, new_buffer.clone(), 0, position),
132 )
133 .await?;
134 buffer = new_buffer;
135 buffer_length = new_length;
136 jvm.put_field(this, "buf", "[B", buffer.clone()).await?;
137 }
138 }
139
140 jvm.put_field(this, "pos", "I", position).await?;
141 jvm.put_field(this, "markpos", "I", mark_position).await?;
142 jvm.put_field(this, "count", "I", position).await?;
143
144 let read: i32 = jvm
145 .invoke_virtual(
146 &r#in,
147 "java/io/InputStream",
148 "read",
149 "([BII)I",
150 (buffer, position, buffer_length - position),
151 )
152 .await?;
153 if read > 0 {
154 jvm.put_field(this, "count", "I", position + read).await?;
155 }
156 Ok(read)
157 }
158
159 async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
160 tracing::debug!("java.io.BufferedInputStream::read({this:?})");
161
162 let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
163 let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
164 if r#in.is_null() || buffer.is_null() {
165 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
166 }
167
168 let mut position: i32 = jvm.get_field(&this, "pos", "I").await?;
169 let mut count: i32 = jvm.get_field(&this, "count", "I").await?;
170 if position >= count {
171 if Self::fill(jvm, &mut this).await? == -1 {
172 return Ok(-1);
173 }
174 position = jvm.get_field(&this, "pos", "I").await?;
175 count = jvm.get_field(&this, "count", "I").await?;
176 if position >= count {
177 return Ok(-1);
178 }
179 }
180
181 let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
182 let value = jvm.load_array::<i8>(&buffer, position as usize, 1).await?[0];
183 jvm.put_field(&mut this, "pos", "I", position + 1).await?;
184 Ok(value as u8 as i32)
185 }
186
187 async fn read(
188 jvm: &Jvm,
189 _: &mut RuntimeContext,
190 mut this: ClassInstanceRef<Self>,
191 target: ClassInstanceRef<Array<i8>>,
192 offset: i32,
193 length: i32,
194 ) -> Result<i32> {
195 tracing::debug!("java.io.BufferedInputStream::read({this:?}, {target:?}, {offset}, {length})");
196
197 let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
198 let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
199 if r#in.is_null() || buffer.is_null() {
200 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
201 }
202 if target.is_null() {
203 return Err(jvm.exception("java/lang/NullPointerException", "target is null").await);
204 }
205 let target_length = jvm.array_length(&target).await? as i32;
206 if offset < 0 || length < 0 || offset > target_length - length {
207 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
208 }
209 if length == 0 {
210 return Ok(0);
211 }
212
213 let mut total = 0;
214 while total < length {
215 let mut position: i32 = jvm.get_field(&this, "pos", "I").await?;
216 let mut count: i32 = jvm.get_field(&this, "count", "I").await?;
217 if position >= count {
218 if Self::fill(jvm, &mut this).await? == -1 {
219 break;
220 }
221 position = jvm.get_field(&this, "pos", "I").await?;
222 count = jvm.get_field(&this, "count", "I").await?;
223 if position >= count {
224 break;
225 }
226 }
227
228 let copied = (count - position).min(length - total);
229 let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
230 let _: () = jvm
231 .invoke_static(
232 "java/lang/System",
233 "arraycopy",
234 "(Ljava/lang/Object;ILjava/lang/Object;II)V",
235 (buffer, position, target.clone(), offset + total, copied),
236 )
237 .await?;
238 jvm.put_field(&mut this, "pos", "I", position + copied).await?;
239 total += copied;
240
241 if total < length {
242 let available: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?;
243 if available == 0 {
244 break;
245 }
246 }
247 }
248
249 if total == 0 { Ok(-1) } else { Ok(total) }
250 }
251
252 async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, amount: i64) -> Result<i64> {
253 tracing::debug!("java.io.BufferedInputStream::skip({this:?}, {amount})");
254
255 let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
256 let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
257 if r#in.is_null() || buffer.is_null() {
258 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
259 }
260 if amount <= 0 {
261 return Ok(0);
262 }
263
264 let mut position: i32 = jvm.get_field(&this, "pos", "I").await?;
265 let mut count: i32 = jvm.get_field(&this, "count", "I").await?;
266 if position >= count {
267 let mark_position: i32 = jvm.get_field(&this, "markpos", "I").await?;
268 if mark_position < 0 {
269 return jvm.invoke_virtual(&r#in, "java/io/InputStream", "skip", "(J)J", (amount,)).await;
270 }
271 if Self::fill(jvm, &mut this).await? == -1 {
272 return Ok(0);
273 }
274 position = jvm.get_field(&this, "pos", "I").await?;
275 count = jvm.get_field(&this, "count", "I").await?;
276 }
277
278 let skipped = amount.min((count - position) as i64);
279 jvm.put_field(&mut this, "pos", "I", position + skipped as i32).await?;
280 Ok(skipped)
281 }
282
283 async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
284 tracing::debug!("java.io.BufferedInputStream::available({this:?})");
285
286 let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
287 let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
288 if r#in.is_null() || buffer.is_null() {
289 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
290 }
291 let position: i32 = jvm.get_field(&this, "pos", "I").await?;
292 let count: i32 = jvm.get_field(&this, "count", "I").await?;
293 let underlying: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?;
294 Ok((count - position).saturating_add(underlying))
295 }
296
297 async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, read_limit: i32) -> Result<()> {
298 tracing::debug!("java.io.BufferedInputStream::mark({this:?}, {read_limit})");
299
300 let position: i32 = jvm.get_field(&this, "pos", "I").await?;
301 jvm.put_field(&mut this, "marklimit", "I", read_limit).await?;
302 jvm.put_field(&mut this, "markpos", "I", position).await
303 }
304
305 async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
306 tracing::debug!("java.io.BufferedInputStream::reset({this:?})");
307
308 let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
309 let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
310 if r#in.is_null() || buffer.is_null() {
311 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
312 }
313 let mark_position: i32 = jvm.get_field(&this, "markpos", "I").await?;
314 if mark_position < 0 {
315 return Err(jvm.exception("java/io/IOException", "Resetting to invalid mark").await);
316 }
317 jvm.put_field(&mut this, "pos", "I", mark_position).await
318 }
319
320 async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
321 tracing::debug!("java.io.BufferedInputStream::markSupported({this:?})");
322 Ok(true)
323 }
324
325 async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
326 tracing::debug!("java.io.BufferedInputStream::close({this:?})");
327
328 let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
329 if r#in.is_null() {
330 return Ok(());
331 }
332 let null_input: ClassInstanceRef<InputStream> = None.into();
333 let null_buffer: ClassInstanceRef<Array<i8>> = None.into();
334 jvm.put_field(&mut this, "in", "Ljava/io/InputStream;", null_input).await?;
335 jvm.put_field(&mut this, "buf", "[B", null_buffer).await?;
336 jvm.invoke_virtual(&r#in, "java/io/InputStream", "close", "()V", ()).await
337 }
338}