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, "java/io/InputStreamReader", "charset", "Ljava/lang/String;", charset)
91            .await?;
92
93        let read_buf = jvm.instantiate_array("B", BUF_SIZE).await?;
94        jvm.put_field(&mut this, "java/io/InputStreamReader", "readBuf", "[B", read_buf).await?;
95        jvm.put_field(&mut this, "java/io/InputStreamReader", "readBufSize", "I", 0).await?;
96
97        let write_buf = jvm.instantiate_array("C", BUF_SIZE * 3).await?;
98        jvm.put_field(&mut this, "java/io/InputStreamReader", "writeBuf", "[C", write_buf).await?;
99        jvm.put_field(&mut this, "java/io/InputStreamReader", "writeBufSize", "I", 0).await?;
100        jvm.put_field(&mut this, "java/io/InputStreamReader", "endOfInput", "Z", false).await?;
101
102        jvm.put_field(&mut this, "java/io/InputStreamReader", "in", "Ljava/io/InputStream;", r#in)
103            .await?;
104
105        Ok(())
106    }
107
108    async fn read(
109        jvm: &Jvm,
110        _: &mut RuntimeContext,
111        mut this: ClassInstanceRef<Self>,
112        buf: ClassInstanceRef<Array<JavaChar>>,
113        offset: i32,
114        length: i32,
115    ) -> Result<i32> {
116        tracing::debug!("java.io.InputStreamReader::read({this:?}, {buf:?}, {offset:?}, {length:?})");
117        if buf.is_null() {
118            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
119        }
120
121        let destination_length = jvm.array_length(&buf).await? as i32;
122        if offset < 0 || length < 0 || offset > destination_length - length {
123            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
124        }
125        if length == 0 {
126            return Ok(0);
127        }
128
129        let r#in = jvm.get_field(&this, "java/io/InputStreamReader", "in", "Ljava/io/InputStream;").await?;
130        let mut write_buf: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/io/InputStreamReader", "writeBuf", "[C").await?;
131        let mut copied = 0;
132
133        loop {
134            let write_buf_size: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "writeBufSize", "I").await?;
135            let to_copy = min(length - copied, write_buf_size);
136            if to_copy > 0 {
137                let _: () = jvm
138                    .invoke_static(
139                        "java/lang/System",
140                        "arraycopy",
141                        "(Ljava/lang/Object;ILjava/lang/Object;II)V",
142                        (write_buf.clone(), 0, buf.clone(), offset + copied, to_copy),
143                    )
144                    .await?;
145                let _: () = jvm
146                    .invoke_static(
147                        "java/lang/System",
148                        "arraycopy",
149                        "(Ljava/lang/Object;ILjava/lang/Object;II)V",
150                        (write_buf.clone(), to_copy, write_buf.clone(), 0, write_buf_size - to_copy),
151                    )
152                    .await?;
153                jvm.put_field(&mut this, "java/io/InputStreamReader", "writeBufSize", "I", write_buf_size - to_copy)
154                    .await?;
155                copied += to_copy;
156            }
157
158            let mut end_of_input: bool = jvm.get_field(&this, "java/io/InputStreamReader", "endOfInput", "Z").await?;
159            if copied == length || end_of_input {
160                break;
161            }
162            // Once characters are available, do not wait for more input to fill the caller's buffer.
163            if copied > 0 {
164                let available: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?;
165                if available == 0 {
166                    break;
167                }
168            }
169
170            let read_buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/InputStreamReader", "readBuf", "[B").await?;
171            let mut read_buf_size: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "readBufSize", "I").await?;
172            let read: i32 = jvm
173                .invoke_virtual(
174                    &r#in,
175                    "java/io/InputStream",
176                    "read",
177                    "([BII)I",
178                    (read_buf.clone(), read_buf_size, BUF_SIZE as i32 - read_buf_size),
179                )
180                .await?;
181            if read == -1 {
182                end_of_input = true;
183                jvm.put_field(&mut this, "java/io/InputStreamReader", "endOfInput", "Z", true).await?;
184            } else {
185                read_buf_size += read;
186            }
187
188            let mut read_buf_data = vec![0; read_buf_size as _];
189            jvm.array_raw_buffer(&read_buf).await?.read(0, &mut read_buf_data)?;
190
191            let charset_ref = jvm.get_field(&this, "java/io/InputStreamReader", "charset", "Ljava/lang/String;").await?;
192            let charset = JavaLangString::to_rust_string(jvm, &charset_ref).await?;
193            let mut decoder = if charset == "UTF-8" {
194                UTF_8.new_decoder_without_bom_handling()
195            } else if charset == "EUC-KR" {
196                EUC_KR.new_decoder_without_bom_handling()
197            } else {
198                return Err(jvm.exception("java/io/UnsupportedEncodingException", &charset).await);
199            };
200
201            let read_buf_data: Vec<u8> = cast_vec(read_buf_data);
202            let mut decode_length = read_buf_data.len();
203            if !end_of_input && charset == "UTF-8" && decode_length > 0 {
204                let mut lead_index = decode_length - 1;
205                while lead_index > 0 && read_buf_data[lead_index] & 0xc0 == 0x80 {
206                    lead_index -= 1;
207                }
208                let expected_length = match read_buf_data[lead_index] {
209                    0xc0..=0xdf => 2,
210                    0xe0..=0xef => 3,
211                    0xf0..=0xf7 => 4,
212                    _ => 1,
213                };
214                if decode_length - lead_index < expected_length {
215                    decode_length = lead_index;
216                }
217            } else if !end_of_input && charset == "EUC-KR" {
218                let mut index = 0;
219                while index < decode_length {
220                    if (0x81..=0xfe).contains(&read_buf_data[index]) {
221                        if index + 1 == decode_length {
222                            decode_length = index;
223                            break;
224                        }
225                        index += 2;
226                    } else {
227                        index += 1;
228                    }
229                }
230            }
231
232            let mut decoded = vec![0; BUF_SIZE * 3];
233            let (_, read, wrote, _) = decoder.decode_to_utf16(&read_buf_data[..decode_length], &mut decoded, end_of_input);
234
235            // advance readBuf
236            let _: () = jvm
237                .invoke_static(
238                    "java/lang/System",
239                    "arraycopy",
240                    "(Ljava/lang/Object;ILjava/lang/Object;II)V",
241                    (read_buf.clone(), read as i32, read_buf, 0, (read_buf_size - read as i32)),
242                )
243                .await?;
244            jvm.put_field(&mut this, "java/io/InputStreamReader", "readBufSize", "I", read_buf_size - read as i32)
245                .await?;
246
247            // The previous output was drained before reading another chunk.
248            jvm.store_array(&mut write_buf, 0, cast_slice::<u16, JavaChar>(&decoded[..wrote]).to_vec())
249                .await?;
250            jvm.put_field(&mut this, "java/io/InputStreamReader", "writeBufSize", "I", wrote as i32)
251                .await?;
252        }
253
254        Ok(if copied == 0 { -1 } else { copied })
255    }
256
257    async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
258        tracing::debug!("java.io.InputStreamReader::close({this:?})");
259
260        let r#in = jvm.get_field(&this, "java/io/InputStreamReader", "in", "Ljava/io/InputStream;").await?;
261        let _: () = jvm.invoke_virtual(&r#in, "java/io/InputStream", "close", "()V", ()).await?;
262
263        Ok(())
264    }
265
266    async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
267        tracing::debug!("java.io.InputStreamReader::ready({this:?})");
268
269        let write_buf_size: i32 = jvm.get_field(&this, "java/io/InputStreamReader", "writeBufSize", "I").await?;
270        if write_buf_size > 0 {
271            return Ok(true);
272        }
273
274        let r#in = jvm.get_field(&this, "java/io/InputStreamReader", "in", "Ljava/io/InputStream;").await?;
275        let available: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?;
276        Ok(available > 0)
277    }
278}