1use alloc::{string::String as RustString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::{
10 io::OutputStream,
11 lang::{String, System},
12 },
13};
14
15pub struct OutputStreamWriter;
17
18impl OutputStreamWriter {
19 pub fn as_proto() -> RuntimeClassProto {
20 RuntimeClassProto {
21 name: "java/io/OutputStreamWriter",
22 parent_class: Some("java/io/Writer"),
23 interfaces: vec![],
24 methods: vec![
25 JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
26 JavaMethodProto::new(
27 "<init>",
28 "(Ljava/io/OutputStream;Ljava/lang/String;)V",
29 Self::init_with_encoding,
30 MethodAccessFlags::PUBLIC,
31 ),
32 JavaMethodProto::new("write", "([CII)V", Self::write, MethodAccessFlags::PUBLIC),
33 JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
34 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
35 ],
36 fields: vec![
37 JavaFieldProto::new("out", "Ljava/io/OutputStream;", FieldAccessFlags::PRIVATE),
38 JavaFieldProto::new("encoding", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
39 JavaFieldProto::new("pendingHighSurrogate", "C", FieldAccessFlags::PRIVATE),
40 JavaFieldProto::new("hasPendingHighSurrogate", "Z", FieldAccessFlags::PRIVATE),
41 ],
42 access_flags: ClassAccessFlags::PUBLIC,
43 }
44 }
45
46 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, out: ClassInstanceRef<OutputStream>) -> Result<()> {
47 tracing::debug!("java.io.OutputStreamWriter::<init>({this:?}, {out:?})");
48
49 let encoding = System::get_charset(jvm).await?;
50 let encoding = JavaLangString::from_rust_string(jvm, &encoding).await?;
51 jvm.invoke_special(
52 &this,
53 "java/io/OutputStreamWriter",
54 "<init>",
55 "(Ljava/io/OutputStream;Ljava/lang/String;)V",
56 (out, encoding),
57 )
58 .await
59 }
60
61 async fn init_with_encoding(
62 jvm: &Jvm,
63 _: &mut RuntimeContext,
64 mut this: ClassInstanceRef<Self>,
65 out: ClassInstanceRef<OutputStream>,
66 encoding: ClassInstanceRef<String>,
67 ) -> Result<()> {
68 tracing::debug!("java.io.OutputStreamWriter::<init>({this:?}, {out:?}, {encoding:?})");
69
70 if out.is_null() {
71 return Err(jvm.exception("java/lang/NullPointerException", "output is null").await);
72 }
73 Self::validate_encoding(jvm, &encoding).await?;
74
75 let _: () = jvm.invoke_special(&this, "java/io/Writer", "<init>", "()V", ()).await?;
76 jvm.put_field(&mut this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;", out)
77 .await?;
78 jvm.put_field(&mut this, "java/io/OutputStreamWriter", "encoding", "Ljava/lang/String;", encoding)
79 .await?;
80 jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", false)
81 .await?;
82
83 Ok(())
84 }
85
86 pub(crate) async fn validate_encoding(jvm: &Jvm, encoding: &ClassInstanceRef<String>) -> Result<()> {
87 if encoding.is_null() {
88 return Err(jvm.exception("java/lang/NullPointerException", "encoding is null").await);
89 }
90 let encoding_name = JavaLangString::to_rust_string(jvm, encoding).await?.to_ascii_uppercase();
91 if !matches!(
92 encoding_name.as_str(),
93 "UTF-8" | "UTF8" | "EUC-KR" | "EUCKR" | "KS-C-5601-1987" | "MS949" | "CP949"
94 ) {
95 return Err(jvm.exception("java/io/UnsupportedEncodingException", &encoding_name).await);
96 }
97 Ok(())
98 }
99
100 async fn write(
101 jvm: &Jvm,
102 _: &mut RuntimeContext,
103 mut this: ClassInstanceRef<Self>,
104 chars: ClassInstanceRef<Array<JavaChar>>,
105 off: i32,
106 len: i32,
107 ) -> Result<()> {
108 tracing::debug!("java.io.OutputStreamWriter::write({this:?}, {chars:?}, {off}, {len})");
109 if chars.is_null() {
110 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
111 }
112
113 let array_length = jvm.array_length(&chars).await? as i32;
114 if off < 0 || len < 0 || off > array_length - len {
115 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
116 }
117
118 let mut utf16: Vec<JavaChar> = jvm.load_array(&chars, off as usize, len as usize).await?;
119 let has_pending: bool = jvm.get_field(&this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z").await?;
120 if has_pending {
121 let pending: JavaChar = jvm.get_field(&this, "java/io/OutputStreamWriter", "pendingHighSurrogate", "C").await?;
122 utf16.insert(0, pending);
123 jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", false)
124 .await?;
125 }
126 if utf16.last().is_some_and(|value| (0xd800..=0xdbff).contains(value)) {
127 let Some(pending) = utf16.pop() else {
128 return Ok(());
129 };
130 jvm.put_field(&mut this, "java/io/OutputStreamWriter", "pendingHighSurrogate", "C", pending)
131 .await?;
132 jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", true)
133 .await?;
134 }
135 if utf16.is_empty() {
136 return Ok(());
137 }
138
139 let value: RustString = char::decode_utf16(utf16).map(|value| value.unwrap_or('?')).collect();
140 let encoding: ClassInstanceRef<String> = jvm
141 .get_field(&this, "java/io/OutputStreamWriter", "encoding", "Ljava/lang/String;")
142 .await?;
143 let encoding = JavaLangString::to_rust_string(jvm, &encoding).await?.to_ascii_uppercase();
144 let bytes = if matches!(encoding.as_str(), "UTF-8" | "UTF8") {
145 value.into_bytes()
146 } else {
147 encoding_rs::EUC_KR.encode(&value).0.into_owned()
148 };
149
150 let mut java_bytes = jvm.instantiate_array("B", bytes.len()).await?;
151 jvm.store_array(&mut java_bytes, 0, bytes.into_iter().map(|value| value as i8)).await?;
152
153 let out = jvm
154 .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;")
155 .await?;
156 jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (java_bytes,)).await
157 }
158
159 async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
160 tracing::debug!("java.io.OutputStreamWriter::flush({this:?})");
161 let out = jvm
162 .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;")
163 .await?;
164 jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await
165 }
166
167 async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
168 tracing::debug!("java.io.OutputStreamWriter::close({this:?})");
169
170 let has_pending: bool = jvm.get_field(&this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z").await?;
171 if has_pending {
172 jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", false)
173 .await?;
174 let mut replacement = jvm.instantiate_array("C", 1).await?;
175 jvm.store_array(&mut replacement, 0, ['?' as JavaChar]).await?;
176 let _: () = jvm
177 .invoke_virtual(&this, "java/io/OutputStreamWriter", "write", "([CII)V", (replacement, 0, 1))
178 .await?;
179 }
180
181 let out = jvm
182 .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;")
183 .await?;
184 jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await
185 }
186}