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