1use alloc::{vec, vec::Vec};
2
3use bytemuck::cast_vec;
4
5use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
6use jvm_class_proto::JavaMethodProto;
7use jvm_types::{ClassAccessFlags, MethodAccessFlags};
8
9use crate::{
10 RuntimeClassProto, RuntimeContext,
11 classes::java::{io::OutputStream, lang::String},
12};
13
14pub struct DataOutputStream;
16
17impl DataOutputStream {
18 pub fn as_proto() -> RuntimeClassProto {
19 RuntimeClassProto {
20 name: "java/io/DataOutputStream",
21 parent_class: Some("java/io/FilterOutputStream"),
22 interfaces: vec!["java/io/DataOutput"],
23 methods: vec![
24 JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
25 JavaMethodProto::new("write", "(I)V", Self::write, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
26 JavaMethodProto::new(
27 "writeByte",
28 "(I)V",
29 Self::write_byte,
30 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
31 ),
32 JavaMethodProto::new(
33 "writeBoolean",
34 "(Z)V",
35 Self::write_boolean,
36 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
37 ),
38 JavaMethodProto::new("writeInt", "(I)V", Self::write_int, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
39 JavaMethodProto::new(
40 "writeShort",
41 "(I)V",
42 Self::write_short,
43 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
44 ),
45 JavaMethodProto::new(
46 "writeChar",
47 "(I)V",
48 Self::write_char,
49 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
50 ),
51 JavaMethodProto::new(
52 "writeLong",
53 "(J)V",
54 Self::write_long,
55 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
56 ),
57 JavaMethodProto::new(
58 "writeFloat",
59 "(F)V",
60 Self::write_float,
61 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
62 ),
63 JavaMethodProto::new(
64 "writeDouble",
65 "(D)V",
66 Self::write_double,
67 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
68 ),
69 JavaMethodProto::new(
70 "writeBytes",
71 "(Ljava/lang/String;)V",
72 Self::write_bytes,
73 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
74 ),
75 JavaMethodProto::new(
76 "writeChars",
77 "(Ljava/lang/String;)V",
78 Self::write_chars,
79 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
80 ),
81 JavaMethodProto::new(
82 "writeUTF",
83 "(Ljava/lang/String;)V",
84 Self::write_utf,
85 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
86 ),
87 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
88 JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
89 ],
90 fields: vec![],
91 access_flags: ClassAccessFlags::PUBLIC,
92 }
93 }
94
95 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, out: ClassInstanceRef<OutputStream>) -> Result<()> {
96 tracing::debug!("java.io.DataOutputStream::<init>({this:?}, {out:?})");
97
98 let _: () = jvm
99 .invoke_special(&this, "java/io/FilterOutputStream", "<init>", "(Ljava/io/OutputStream;)V", (out,))
100 .await?;
101
102 Ok(())
103 }
104
105 async fn write(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, b: i32) -> Result<()> {
106 tracing::debug!("java.io.DataOutputStream::write({this:?}, {b:?})");
107
108 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
109 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (b,)).await?;
110
111 Ok(())
112 }
113
114 async fn write_byte(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, v: i32) -> Result<()> {
115 tracing::debug!("java.io.DataOutputStream::writeByte({this:?}, {v:?})");
116
117 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
118 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (v,)).await?;
119
120 Ok(())
121 }
122
123 async fn write_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, v: bool) -> Result<()> {
124 tracing::debug!("java.io.DataOutputStream::writeBoolean({this:?}, {v:?})");
125
126 let _: () = jvm
127 .invoke_virtual(&this, "java/io/DataOutputStream", "writeByte", "(I)V", (v as i32,))
128 .await?;
129
130 Ok(())
131 }
132
133 async fn write_short(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: i32) -> Result<()> {
134 tracing::debug!("java.io.DataOutputStream::writeShort({this:?}, {s:?})");
135
136 let bytes = (s as i16).to_be_bytes();
137 let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
138 jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
139
140 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
141 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
142
143 Ok(())
144 }
145
146 async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
147 tracing::debug!("java.io.DataOutputStream::writeChar({this:?}, {value:?})");
148 jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeShort", "(I)V", (value & 0xffff,))
149 .await
150 }
151
152 async fn write_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, i: i32) -> Result<()> {
153 tracing::debug!("java.io.DataOutputStream::writeInt({this:?}, {i:?})");
154
155 let bytes = i.to_be_bytes();
156 let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
157 jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
158
159 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
160 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
161
162 Ok(())
163 }
164
165 async fn write_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, l: i64) -> Result<()> {
166 tracing::debug!("java.io.DataOutputStream::writeLong({this:?}, {l:?})");
167
168 let bytes = l.to_be_bytes();
169 let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
170 jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;
171
172 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
173 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;
174
175 Ok(())
176 }
177
178 async fn write_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
179 tracing::debug!("java.io.DataOutputStream::writeFloat({this:?}, {value:?})");
180 jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeInt", "(I)V", (value.to_bits() as i32,))
181 .await
182 }
183
184 async fn write_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
185 tracing::debug!("java.io.DataOutputStream::writeDouble({this:?}, {value:?})");
186 jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeLong", "(J)V", (value.to_bits() as i64,))
187 .await
188 }
189
190 async fn write_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
191 tracing::debug!("java.io.DataOutputStream::writeBytes({this:?}, {s:?})");
192
193 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
194 let length = jvm.array_length(&chars).await?;
195 let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
196 let mut bytes = jvm.instantiate_array("B", chars.len()).await?;
197 jvm.store_array(&mut bytes, 0, chars.into_iter().map(|value| value as i8)).await?;
198
199 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
200 jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
201 }
202
203 async fn write_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
204 tracing::debug!("java.io.DataOutputStream::writeChars({this:?}, {s:?})");
205
206 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
207 let length = jvm.array_length(&chars).await?;
208 let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
209 let mut data = Vec::with_capacity(chars.len() * 2);
210 for value in chars {
211 data.push((value >> 8) as i8);
212 data.push(value as i8);
213 }
214
215 let mut bytes = jvm.instantiate_array("B", data.len()).await?;
216 jvm.store_array(&mut bytes, 0, data).await?;
217
218 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
219 jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
220 }
221
222 async fn write_utf(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, s: ClassInstanceRef<String>) -> Result<()> {
223 tracing::debug!("java.io.DataOutputStream::writeUTF({this:?}, {s:?})");
224
225 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
226 let length = jvm.array_length(&chars).await?;
227 let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
228 let mut data = Vec::new();
229 for value in chars {
230 if (0x0001..=0x007f).contains(&value) {
231 data.push(value as i8);
232 } else if value <= 0x07ff {
233 data.push((0xc0 | ((value >> 6) & 0x1f)) as i8);
234 data.push((0x80 | (value & 0x3f)) as i8);
235 } else {
236 data.push((0xe0 | ((value >> 12) & 0x0f)) as i8);
237 data.push((0x80 | ((value >> 6) & 0x3f)) as i8);
238 data.push((0x80 | (value & 0x3f)) as i8);
239 }
240 }
241
242 if data.len() > u16::MAX as usize {
243 return Err(jvm.exception("java/io/UTFDataFormatException", "encoded string is too long").await);
244 }
245
246 let _: () = jvm
247 .invoke_virtual(&this, "java/io/DataOutputStream", "writeShort", "(I)V", (data.len() as i32,))
248 .await?;
249
250 let mut bytes = jvm.instantiate_array("B", data.len()).await?;
251 jvm.store_array(&mut bytes, 0, data).await?;
252
253 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
254 jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
255 }
256
257 async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
258 tracing::debug!("java.io.DataOutputStream::close({this:?})");
259
260 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
261 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", []).await?;
262
263 Ok(())
264 }
265
266 async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
267 tracing::debug!("java.io.DataOutputStream::flush({this:?})");
268
269 let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
270 let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", []).await?;
271
272 Ok(())
273 }
274}