Skip to main content

rustjava_runtime/classes/java/io/
data_input_stream.rs

1use alloc::{vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags, modified_utf8};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        io::{DataInput, InputStream},
11        lang::String,
12    },
13};
14
15// class java.io.DataInputStream
16pub struct DataInputStream;
17
18impl DataInputStream {
19    pub fn as_proto() -> RuntimeClassProto {
20        RuntimeClassProto {
21            name: "java/io/DataInputStream",
22            parent_class: Some("java/io/FilterInputStream"),
23            interfaces: vec!["java/io/DataInput"],
24            methods: vec![
25                JavaMethodProto::new("<init>", "(Ljava/io/InputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new(
27                    "readBoolean",
28                    "()Z",
29                    Self::read_boolean,
30                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
31                ),
32                JavaMethodProto::new("readByte", "()B", Self::read_byte, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
33                JavaMethodProto::new("readChar", "()C", Self::read_char, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
34                JavaMethodProto::new(
35                    "readDouble",
36                    "()D",
37                    Self::read_double,
38                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
39                ),
40                JavaMethodProto::new("readFloat", "()F", Self::read_float, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
41                JavaMethodProto::new(
42                    "readFully",
43                    "([B)V",
44                    Self::read_fully,
45                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
46                ),
47                JavaMethodProto::new(
48                    "readFully",
49                    "([BII)V",
50                    Self::read_fully_offset_length,
51                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
52                ),
53                JavaMethodProto::new("readInt", "()I", Self::read_int, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
54                JavaMethodProto::new("readLong", "()J", Self::read_long, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
55                JavaMethodProto::new("readShort", "()S", Self::read_short, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
56                JavaMethodProto::new(
57                    "readUnsignedByte",
58                    "()I",
59                    Self::read_unsigned_byte,
60                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
61                ),
62                JavaMethodProto::new(
63                    "readUnsignedShort",
64                    "()I",
65                    Self::read_unsigned_short,
66                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
67                ),
68                JavaMethodProto::new(
69                    "readUTF",
70                    "()Ljava/lang/String;",
71                    Self::read_utf,
72                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
73                ),
74                JavaMethodProto::new(
75                    "readUTF",
76                    "(Ljava/io/DataInput;)Ljava/lang/String;",
77                    Self::read_utf_from_input,
78                    MethodAccessFlags::STATIC,
79                ),
80                JavaMethodProto::new(
81                    "skipBytes",
82                    "(I)I",
83                    Self::skip_bytes,
84                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
85                ),
86            ],
87            fields: vec![],
88            access_flags: ClassAccessFlags::PUBLIC,
89        }
90    }
91
92    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, r#in: ClassInstanceRef<InputStream>) -> Result<()> {
93        tracing::debug!("java.io.DataInputStream::<init>({this:?}, {:?})", &r#in);
94
95        let _: () = jvm
96            .invoke_special(&this, "java/io/FilterInputStream", "<init>", "(Ljava/io/InputStream;)V", (r#in,))
97            .await?;
98
99        Ok(())
100    }
101
102    async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i8> {
103        tracing::debug!("java.io.DataInputStream::readByte({this:?})");
104
105        Ok(Self::read_required_byte(jvm, &this).await? as i8)
106    }
107
108    async fn read_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
109        tracing::debug!("java.io.DataInputStream::readBoolean({this:?})");
110
111        Ok(Self::read_required_byte(jvm, &this).await? != 0)
112    }
113
114    async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<JavaChar> {
115        tracing::debug!("java.io.DataInputStream::readChar({this:?})");
116
117        let byte1 = Self::read_required_byte(jvm, &this).await?;
118        let byte2 = Self::read_required_byte(jvm, &this).await?;
119        Ok(JavaChar::from_be_bytes([byte1, byte2]))
120    }
121
122    async fn read_short(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i16> {
123        tracing::debug!("java.io.DataInputStream::readShort({this:?})");
124
125        let byte1 = Self::read_required_byte(jvm, &this).await?;
126        let byte2 = Self::read_required_byte(jvm, &this).await?;
127        Ok(i16::from_be_bytes([byte1, byte2]))
128    }
129
130    async fn read_unsigned_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
131        tracing::debug!("java.io.DataInputStream::readUnsignedByte({this:?})");
132        Ok(Self::read_required_byte(jvm, &this).await? as i32)
133    }
134
135    async fn read_unsigned_short(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
136        tracing::debug!("java.io.DataInputStream::readUnsignedShort({this:?})");
137
138        let byte1 = Self::read_required_byte(jvm, &this).await?;
139        let byte2 = Self::read_required_byte(jvm, &this).await?;
140        Ok(u16::from_be_bytes([byte1, byte2]) as i32)
141    }
142
143    async fn read_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
144        tracing::debug!("java.io.DataInputStream::readInt({this:?})");
145
146        Ok(i32::from_be_bytes([
147            Self::read_required_byte(jvm, &this).await?,
148            Self::read_required_byte(jvm, &this).await?,
149            Self::read_required_byte(jvm, &this).await?,
150            Self::read_required_byte(jvm, &this).await?,
151        ]))
152    }
153
154    async fn read_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
155        tracing::debug!("java.io.DataInputStream::readLong({this:?})");
156
157        Ok(i64::from_be_bytes([
158            Self::read_required_byte(jvm, &this).await?,
159            Self::read_required_byte(jvm, &this).await?,
160            Self::read_required_byte(jvm, &this).await?,
161            Self::read_required_byte(jvm, &this).await?,
162            Self::read_required_byte(jvm, &this).await?,
163            Self::read_required_byte(jvm, &this).await?,
164            Self::read_required_byte(jvm, &this).await?,
165            Self::read_required_byte(jvm, &this).await?,
166        ]))
167    }
168
169    async fn read_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
170        tracing::debug!("java.io.DataInputStream::readFloat({this:?})");
171
172        Ok(f32::from_be_bytes([
173            Self::read_required_byte(jvm, &this).await?,
174            Self::read_required_byte(jvm, &this).await?,
175            Self::read_required_byte(jvm, &this).await?,
176            Self::read_required_byte(jvm, &this).await?,
177        ]))
178    }
179
180    async fn read_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
181        tracing::debug!("java.io.DataInputStream::readDouble({this:?})");
182
183        Ok(f64::from_be_bytes([
184            Self::read_required_byte(jvm, &this).await?,
185            Self::read_required_byte(jvm, &this).await?,
186            Self::read_required_byte(jvm, &this).await?,
187            Self::read_required_byte(jvm, &this).await?,
188            Self::read_required_byte(jvm, &this).await?,
189            Self::read_required_byte(jvm, &this).await?,
190            Self::read_required_byte(jvm, &this).await?,
191            Self::read_required_byte(jvm, &this).await?,
192        ]))
193    }
194
195    async fn read_utf(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
196        tracing::debug!("java.io.DataInputStream::readUTF({this:?})");
197
198        let length: i32 = jvm
199            .invoke_virtual(&this, "java/io/DataInputStream", "readUnsignedShort", "()I", ())
200            .await?;
201        let java_array = jvm.instantiate_array("B", length as usize).await?;
202        let _: () = jvm
203            .invoke_virtual(&this, "java/io/DataInputStream", "readFully", "([BII)V", (java_array.clone(), 0, length))
204            .await?;
205        let bytes: Vec<i8> = jvm.load_array(&java_array, 0, length as usize).await?;
206        let bytes: Vec<u8> = bytes.into_iter().map(|value| value as u8).collect();
207
208        let Some(chars) = modified_utf8::decode(&bytes) else {
209            return Err(jvm.exception("java/io/UTFDataFormatException", "malformed modified UTF-8").await);
210        };
211
212        Ok(JavaLangString::from_utf16(jvm, chars).await?.into())
213    }
214
215    async fn read_utf_from_input(jvm: &Jvm, _: &mut RuntimeContext, input: ClassInstanceRef<DataInput>) -> Result<ClassInstanceRef<String>> {
216        tracing::debug!("java.io.DataInputStream::readUTF({input:?})");
217        if input.is_null() {
218            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
219        }
220        jvm.invoke_virtual(&input, &input.class_definition().name(), "readUTF", "()Ljava/lang/String;", ())
221            .await
222    }
223
224    async fn read_fully(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, b: ClassInstanceRef<Array<i8>>) -> Result<()> {
225        tracing::debug!("java.io.DataInputStream::readFully({this:?}, {b:?})");
226        if b.is_null() {
227            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
228        }
229
230        let length = jvm.array_length(&b).await?;
231
232        let _: () = jvm
233            .invoke_virtual(&this, "java/io/DataInputStream", "readFully", "([BII)V", (b.clone(), 0, length as i32))
234            .await?;
235
236        Ok(())
237    }
238
239    async fn read_fully_offset_length(
240        jvm: &Jvm,
241        _: &mut RuntimeContext,
242        this: ClassInstanceRef<Self>,
243        b: ClassInstanceRef<Array<i8>>,
244        off: i32,
245        len: i32,
246    ) -> Result<()> {
247        tracing::debug!("java.io.DataInputStream::readFully({this:?}, {b:?}, {off}, {len})");
248        if b.is_null() {
249            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
250        }
251
252        let mut read = 0;
253        while read < len {
254            let r: i32 = jvm
255                .invoke_virtual(&this, "java/io/DataInputStream", "read", "([BII)I", (b.clone(), off + read, len - read))
256                .await?;
257            if r == -1 {
258                return Err(jvm.exception("java/io/EOFException", "End of stream reached before reading fully").await);
259            }
260            read += r;
261        }
262
263        Ok(())
264    }
265
266    async fn skip_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, n: i32) -> Result<i32> {
267        tracing::debug!("java.io.DataInputStream::skipBytes({this:?}, {n:?})");
268
269        if n <= 0 {
270            return Ok(0);
271        }
272        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "java/io/DataInputStream", "in", "Ljava/io/InputStream;").await?;
273        if r#in.is_null() {
274            return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
275        }
276        let skipped: i64 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "skip", "(J)J", (n as i64,)).await?;
277
278        Ok(skipped as _)
279    }
280
281    async fn read_required_byte(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<u8> {
282        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(this, "java/io/DataInputStream", "in", "Ljava/io/InputStream;").await?;
283        if r#in.is_null() {
284            return Err(jvm.exception("java/lang/NullPointerException", "underlying stream is null").await);
285        }
286        let value: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "read", "()I", ()).await?;
287        if value == -1 {
288            return Err(jvm.exception("java/io/EOFException", "End of stream").await);
289        }
290
291        Ok(value as u8)
292    }
293}