Skip to main content

rustjava_runtime/classes/java/io/
output_stream_writer.rs

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
15// class java.io.OutputStreamWriter
16pub 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
110        let array_length = jvm.array_length(&chars).await? as i32;
111        if off < 0 || len < 0 || off > array_length - len {
112            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
113        }
114
115        let mut utf16: Vec<JavaChar> = jvm.load_array(&chars, off as usize, len as usize).await?;
116        let has_pending: bool = jvm.get_field(&this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z").await?;
117        if has_pending {
118            let pending: JavaChar = jvm.get_field(&this, "java/io/OutputStreamWriter", "pendingHighSurrogate", "C").await?;
119            utf16.insert(0, pending);
120            jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", false)
121                .await?;
122        }
123        if utf16.last().is_some_and(|value| (0xd800..=0xdbff).contains(value)) {
124            let Some(pending) = utf16.pop() else {
125                return Ok(());
126            };
127            jvm.put_field(&mut this, "java/io/OutputStreamWriter", "pendingHighSurrogate", "C", pending)
128                .await?;
129            jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", true)
130                .await?;
131        }
132        if utf16.is_empty() {
133            return Ok(());
134        }
135
136        let value: RustString = char::decode_utf16(utf16).map(|value| value.unwrap_or('?')).collect();
137        let encoding: ClassInstanceRef<String> = jvm
138            .get_field(&this, "java/io/OutputStreamWriter", "encoding", "Ljava/lang/String;")
139            .await?;
140        let encoding = JavaLangString::to_rust_string(jvm, &encoding).await?.to_ascii_uppercase();
141        let bytes = if matches!(encoding.as_str(), "UTF-8" | "UTF8") {
142            value.into_bytes()
143        } else {
144            encoding_rs::EUC_KR.encode(&value).0.into_owned()
145        };
146
147        let mut java_bytes = jvm.instantiate_array("B", bytes.len()).await?;
148        jvm.store_array(&mut java_bytes, 0, bytes.into_iter().map(|value| value as i8)).await?;
149
150        let out = jvm
151            .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;")
152            .await?;
153        jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (java_bytes,)).await
154    }
155
156    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
157        tracing::debug!("java.io.OutputStreamWriter::flush({this:?})");
158        let out = jvm
159            .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;")
160            .await?;
161        jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await
162    }
163
164    async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
165        tracing::debug!("java.io.OutputStreamWriter::close({this:?})");
166
167        let has_pending: bool = jvm.get_field(&this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z").await?;
168        if has_pending {
169            jvm.put_field(&mut this, "java/io/OutputStreamWriter", "hasPendingHighSurrogate", "Z", false)
170                .await?;
171            let mut replacement = jvm.instantiate_array("C", 1).await?;
172            jvm.store_array(&mut replacement, 0, ['?' as JavaChar]).await?;
173            let _: () = jvm
174                .invoke_virtual(&this, "java/io/OutputStreamWriter", "write", "([CII)V", (replacement, 0, 1))
175                .await?;
176        }
177
178        let out = jvm
179            .get_field(&this, "java/io/OutputStreamWriter", "out", "Ljava/io/OutputStream;")
180            .await?;
181        jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", ()).await
182    }
183}