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};
8
9pub struct ByteArrayInputStream;
11
12impl ByteArrayInputStream {
13 pub fn as_proto() -> RuntimeClassProto {
14 RuntimeClassProto {
15 name: "java/io/ByteArrayInputStream",
16 parent_class: Some("java/io/InputStream"),
17 interfaces: vec![],
18 methods: vec![
19 JavaMethodProto::new("<init>", "([B)V", Self::init, MethodAccessFlags::PUBLIC),
20 JavaMethodProto::new("<init>", "([BII)V", Self::init_with_offset_length, MethodAccessFlags::PUBLIC),
21 JavaMethodProto::new(
22 "available",
23 "()I",
24 Self::available,
25 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
26 ),
27 JavaMethodProto::new("read", "([BII)I", Self::read, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
28 JavaMethodProto::new(
29 "read",
30 "()I",
31 Self::read_byte,
32 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
33 ),
34 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
35 JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
36 JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
37 JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
38 JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
39 ],
40 fields: vec![
41 JavaFieldProto::new("buf", "[B", FieldAccessFlags::PROTECTED),
42 JavaFieldProto::new("pos", "I", FieldAccessFlags::PROTECTED),
43 JavaFieldProto::new("count", "I", FieldAccessFlags::PROTECTED),
44 JavaFieldProto::new("mark", "I", FieldAccessFlags::PROTECTED),
45 ],
46 access_flags: ClassAccessFlags::PUBLIC,
47 }
48 }
49
50 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, data: ClassInstanceRef<Array<i8>>) -> Result<()> {
51 tracing::debug!("java.io.ByteArrayInputStream::<init>({this:?}, {data:?})");
52
53 if data.is_null() {
54 return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
55 }
56 let count = jvm.array_length(&data).await?;
57
58 let _: () = jvm
59 .invoke_special(&this, "java/io/ByteArrayInputStream", "<init>", "([BII)V", (data, 0, count as i32))
60 .await?;
61
62 Ok(())
63 }
64
65 async fn init_with_offset_length(
66 jvm: &Jvm,
67 _: &mut RuntimeContext,
68 mut this: ClassInstanceRef<Self>,
69 data: ClassInstanceRef<Array<i8>>,
70 offset: i32,
71 length: i32,
72 ) -> Result<()> {
73 tracing::debug!("java.io.ByteArrayInputStream::<init>({this:?}, {data:?}, {offset}, {length})");
74
75 if data.is_null() {
76 return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
77 }
78 let data_length = jvm.array_length(&data).await? as i32;
79 if offset < 0 || length < 0 || offset > data_length {
80 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
81 }
82
83 let _: () = jvm.invoke_special(&this, "java/io/InputStream", "<init>", "()V", ()).await?;
84
85 jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "buf", "[B", data).await?;
86 jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", offset).await?;
87 jvm.put_field(
88 &mut this,
89 "java/io/ByteArrayInputStream",
90 "count",
91 "I",
92 (offset + length).min(data_length),
93 )
94 .await?;
95 jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "mark", "I", offset).await?;
96
97 Ok(())
98 }
99
100 async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
101 tracing::debug!("java.io.ByteArrayInputStream::available({this:?})");
102
103 let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?;
104 let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
105
106 Ok((count - pos) as _)
107 }
108
109 async fn read(
110 jvm: &Jvm,
111 _: &mut RuntimeContext,
112 mut this: ClassInstanceRef<Self>,
113 b: ClassInstanceRef<Array<i8>>,
114 off: i32,
115 len: i32,
116 ) -> Result<i32> {
117 tracing::debug!("java.io.ByteArrayInputStream::read({this:?}, {b:?}, {off}, {len})");
118
119 if b.is_null() {
120 return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
121 }
122 let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/ByteArrayInputStream", "buf", "[B").await?;
123 let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?;
124 let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
125
126 let target_length = jvm.array_length(&b).await? as i32;
127 if off < 0 || len < 0 || off > target_length - len {
128 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
129 }
130 if len == 0 {
131 return Ok(0);
132 }
133
134 let available = count - pos;
135 if available <= 0 {
136 return Ok(-1);
137 }
138 let len_to_read = if len > available { available } else { len };
139
140 let _: () = jvm
141 .invoke_static(
142 "java/lang/System",
143 "arraycopy",
144 "(Ljava/lang/Object;ILjava/lang/Object;II)V",
145 (buf, pos, b, off, len_to_read),
146 )
147 .await?;
148
149 jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + len_to_read)
150 .await?;
151
152 Ok(len_to_read)
153 }
154
155 async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
156 tracing::debug!("java.io.ByteArrayInputStream::readByte({this:?})");
157
158 let buf = jvm.get_field(&this, "java/io/ByteArrayInputStream", "buf", "[B").await?;
159 let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?;
160 let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
161
162 if pos >= count {
163 return Ok(-1);
164 }
165
166 let result: i8 = jvm.load_array(&buf, pos as _, 1).await?[0];
167
168 jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + 1).await?;
169
170 Ok(result as u8 as _)
171 }
172
173 async fn close(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<ByteArrayInputStream>) -> Result<()> {
174 tracing::debug!("java.io.ByteArrayInputStream::close({this:?})");
175
176 Ok(())
177 }
178
179 async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
180 tracing::debug!("java.io.ByteArrayInputStream::skip({this:?}, {n:?})");
181
182 let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?;
183 let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
184
185 let available = (count - pos) as i64;
186 let len_to_skip = n.max(0).min(available);
187
188 jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + len_to_skip as i32)
189 .await?;
190
191 Ok(len_to_skip)
192 }
193
194 async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, readlimit: i32) -> Result<()> {
195 tracing::debug!("java.io.ByteArrayInputStream::mark({this:?}, {readlimit:?})");
196
197 let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
198 jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "mark", "I", pos).await?;
199
200 Ok(())
201 }
202
203 async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
204 tracing::debug!("java.io.ByteArrayInputStream::reset({this:?})");
205
206 let mark: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "mark", "I").await?;
207 jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", mark).await?;
208
209 Ok(())
210 }
211
212 async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
213 tracing::debug!("java.io.ByteArrayInputStream::markSupported({this:?})");
214 Ok(true)
215 }
216}