Skip to main content

rustjava_runtime/classes/java/io/
input_stream_reader.rs

1use core::cmp::min;
2
3use alloc::{vec, vec::Vec};
4
5use bytemuck::{cast_slice, cast_vec};
6use encoding_rs::{EUC_KR, UTF_8};
7
8use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
9use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
10use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
11
12use crate::{
13    RuntimeClassProto, RuntimeContext,
14    classes::java::{io::InputStream, lang::System},
15};
16
17const BUF_SIZE: usize = 10;
18
19// class java.io.InputStreamReader
20pub struct InputStreamReader;
21
22impl InputStreamReader {
23    pub fn as_proto() -> RuntimeClassProto {
24        RuntimeClassProto {
25            name: "java/io/InputStreamReader",
26            parent_class: Some("java/io/Reader"),
27            interfaces: vec![],
28            methods: vec![
29                JavaMethodProto::new("<init>", "(Ljava/io/InputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new(
31                    "<init>",
32                    "(Ljava/io/InputStream;Ljava/lang/String;)V",
33                    Self::init_with_charset,
34                    MethodAccessFlags::PUBLIC,
35                ),
36                JavaMethodProto::new("read", "([CII)I", Self::read, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new("ready", "()Z", Self::ready, MethodAccessFlags::PUBLIC),
38                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
39            ],
40            fields: vec![
41                JavaFieldProto::new("in", "Ljava/io/InputStream;", FieldAccessFlags::PRIVATE),
42                JavaFieldProto::new("readBuf", "[B", FieldAccessFlags::PRIVATE),
43                JavaFieldProto::new("readBufSize", "I", FieldAccessFlags::PRIVATE),
44                JavaFieldProto::new("writeBuf", "[C", FieldAccessFlags::PRIVATE),
45                JavaFieldProto::new("writeBufSize", "I", FieldAccessFlags::PRIVATE),
46                JavaFieldProto::new("charset", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
47                JavaFieldProto::new("endOfInput", "Z", FieldAccessFlags::PRIVATE),
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.InputStreamReader::<init>({this:?}, {:?})", &r#in);
55
56        let charset = System::get_charset(jvm).await?;
57        let charset_java = JavaLangString::from_rust_string(jvm, &charset).await?;
58        jvm.invoke_special(
59            &this,
60            "java/io/InputStreamReader",
61            "<init>",
62            "(Ljava/io/InputStream;Ljava/lang/String;)V",
63            (r#in, charset_java),
64        )
65        .await
66    }
67
68    async fn init_with_charset(
69        jvm: &Jvm,
70        _: &mut RuntimeContext,
71        mut this: ClassInstanceRef<Self>,
72        r#in: ClassInstanceRef<InputStream>,
73        charset: ClassInstanceRef<crate::classes::java::lang::String>,
74    ) -> Result<()> {
75        tracing::debug!("java.io.InputStreamReader::<init>({this:?}, {in:?}, {charset:?})", in = &r#in);
76
77        if r#in.is_null() || charset.is_null() {
78            return Err(jvm.exception("java/lang/NullPointerException", "input or encoding is null").await);
79        }
80
81        let charset_name = JavaLangString::to_rust_string(jvm, &charset).await?.to_ascii_uppercase();
82        let charset_name = match charset_name.as_str() {
83            "UTF-8" | "UTF8" => "UTF-8",
84            "EUC-KR" | "EUCKR" | "KS-C-5601-1987" | "MS949" | "CP949" => "EUC-KR",
85            _ => return Err(jvm.exception("java/io/UnsupportedEncodingException", &charset_name).await),
86        };
87
88        let _: () = jvm.invoke_special(&this, "java/io/Reader", "<init>", "()V", ()).await?;
89        let charset = JavaLangString::from_rust_string(jvm, charset_name).await?;
90        jvm.put_field(&mut this, "charset", "Ljava/lang/String;", charset).await?;
91
92        let read_buf = jvm.instantiate_array("B", BUF_SIZE).await?;
93        jvm.put_field(&mut this, "readBuf", "[B", read_buf).await?;
94        jvm.put_field(&mut this, "readBufSize", "I", 0).await?;
95
96        let write_buf = jvm.instantiate_array("C", BUF_SIZE * 3).await?;
97        jvm.put_field(&mut this, "writeBuf", "[C", write_buf).await?;
98        jvm.put_field(&mut this, "writeBufSize", "I", 0).await?;
99        jvm.put_field(&mut this, "endOfInput", "Z", false).await?;
100
101        jvm.put_field(&mut this, "in", "Ljava/io/InputStream;", r#in).await?;
102
103        Ok(())
104    }
105
106    async fn read(
107        jvm: &Jvm,
108        _: &mut RuntimeContext,
109        mut this: ClassInstanceRef<Self>,
110        buf: ClassInstanceRef<Array<JavaChar>>,
111        offset: i32,
112        length: i32,
113    ) -> Result<i32> {
114        tracing::debug!("java.io.InputStreamReader::read({this:?}, {buf:?}, {offset:?}, {length:?})");
115
116        let destination_length = jvm.array_length(&buf).await? as i32;
117        if offset < 0 || length < 0 || offset > destination_length - length {
118            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
119        }
120        if length == 0 {
121            return Ok(0);
122        }
123
124        let mut write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
125
126        while write_buf_size < length {
127            let read_buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "readBuf", "[B").await?;
128            let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?;
129
130            if read_buf_size < (BUF_SIZE / 2) as _ {
131                let bytes_to_read = BUF_SIZE as i32 - read_buf_size;
132
133                let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
134
135                let temp = jvm.instantiate_array("B", bytes_to_read as _).await?;
136                let read: i32 = jvm
137                    .invoke_virtual(&r#in, "java/io/InputStream", "read", "([BII)I", (temp.clone(), 0, bytes_to_read))
138                    .await?;
139                if read != -1 {
140                    let _: () = jvm
141                        .invoke_static(
142                            "java/lang/System",
143                            "arraycopy",
144                            "(Ljava/lang/Object;ILjava/lang/Object;II)V",
145                            (temp, 0, read_buf.clone(), read_buf_size, read),
146                        )
147                        .await?;
148                    jvm.put_field(&mut this, "readBufSize", "I", read_buf_size + read).await?;
149                } else {
150                    jvm.put_field(&mut this, "endOfInput", "Z", true).await?;
151                    if read_buf_size == 0 && write_buf_size == 0 {
152                        return Ok(-1);
153                    }
154                }
155            }
156
157            let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?;
158            let mut read_buf_data = vec![0; read_buf_size as _];
159            jvm.array_raw_buffer(&read_buf).await?.read(0, &mut read_buf_data)?;
160
161            let charset_ref = jvm.get_field(&this, "charset", "Ljava/lang/String;").await?;
162            let charset = JavaLangString::to_rust_string(jvm, &charset_ref).await?;
163            let mut decoder = if charset == "UTF-8" {
164                UTF_8.new_decoder_without_bom_handling()
165            } else if charset == "EUC-KR" {
166                EUC_KR.new_decoder_without_bom_handling()
167            } else {
168                return Err(jvm.exception("java/io/UnsupportedEncodingException", &charset).await);
169            };
170
171            let read_buf_data: Vec<u8> = cast_vec(read_buf_data);
172            let end_of_input: bool = jvm.get_field(&this, "endOfInput", "Z").await?;
173            let mut decode_length = read_buf_data.len();
174            if !end_of_input && charset == "UTF-8" && decode_length > 0 {
175                let mut lead_index = decode_length - 1;
176                while lead_index > 0 && read_buf_data[lead_index] & 0xc0 == 0x80 {
177                    lead_index -= 1;
178                }
179                let expected_length = match read_buf_data[lead_index] {
180                    0xc0..=0xdf => 2,
181                    0xe0..=0xef => 3,
182                    0xf0..=0xf7 => 4,
183                    _ => 1,
184                };
185                if decode_length - lead_index < expected_length {
186                    decode_length = lead_index;
187                }
188            } else if !end_of_input && charset == "EUC-KR" && read_buf_data.last().is_some_and(|value| *value >= 0x81) {
189                decode_length -= 1;
190            }
191
192            let mut decoded = vec![0; BUF_SIZE * 3];
193            let (_, read, wrote, _) = decoder.decode_to_utf16(&read_buf_data[..decode_length], &mut decoded, end_of_input);
194
195            // advance readBuf
196            let _: () = jvm
197                .invoke_static(
198                    "java/lang/System",
199                    "arraycopy",
200                    "(Ljava/lang/Object;ILjava/lang/Object;II)V",
201                    (read_buf.clone(), read as i32, read_buf, 0, (read_buf_size - read as i32)),
202                )
203                .await?;
204            jvm.put_field(&mut this, "readBufSize", "I", read_buf_size - read as i32).await?;
205
206            // add to writeBuf
207            let mut write_buf = jvm.get_field(&this, "writeBuf", "[C").await?;
208            let buffered_chars: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
209            jvm.store_array(
210                &mut write_buf,
211                buffered_chars as _,
212                cast_slice::<u16, JavaChar>(&decoded[..wrote]).to_vec(),
213            )
214            .await?;
215            write_buf_size = buffered_chars + wrote as i32;
216            jvm.put_field(&mut this, "writeBufSize", "I", write_buf_size).await?;
217            if write_buf_size > 0 {
218                break;
219            }
220        }
221
222        let write_buf: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "writeBuf", "[C").await?;
223        let write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
224
225        let to_copy = min(length, write_buf_size);
226
227        let _: () = jvm
228            .invoke_static(
229                "java/lang/System",
230                "arraycopy",
231                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
232                (write_buf.clone(), 0, buf, offset, to_copy),
233            )
234            .await?;
235
236        // advance writeBuf
237        let _: () = jvm
238            .invoke_static(
239                "java/lang/System",
240                "arraycopy",
241                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
242                (write_buf.clone(), to_copy, write_buf, 0, write_buf_size - to_copy),
243            )
244            .await?;
245        jvm.put_field(&mut this, "writeBufSize", "I", write_buf_size - to_copy).await?;
246
247        Ok(to_copy)
248    }
249
250    async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
251        tracing::debug!("java.io.InputStreamReader::close({this:?})");
252
253        let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
254        let _: () = jvm.invoke_virtual(&r#in, "java/io/InputStream", "close", "()V", ()).await?;
255
256        Ok(())
257    }
258
259    async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
260        tracing::debug!("java.io.InputStreamReader::ready({this:?})");
261
262        let write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
263        if write_buf_size > 0 {
264            return Ok(true);
265        }
266
267        let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
268        let available: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?;
269        Ok(available > 0)
270    }
271}