1use alloc::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::lang::{CharSequence, Object, String},
10};
11
12pub struct Writer;
14
15impl Writer {
16 pub fn as_proto() -> RuntimeClassProto {
17 RuntimeClassProto {
18 name: "java/io/Writer",
19 parent_class: Some("java/lang/Object"),
20 interfaces: vec!["java/lang/Appendable", "java/io/Closeable", "java/io/Flushable"],
21 methods: vec![
22 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
23 JavaMethodProto::new("<init>", "(Ljava/lang/Object;)V", Self::init_with_lock, MethodAccessFlags::PROTECTED),
24 JavaMethodProto::new("write", "(I)V", Self::write_char, MethodAccessFlags::PUBLIC),
25 JavaMethodProto::new("write", "([C)V", Self::write_chars, MethodAccessFlags::PUBLIC),
26 JavaMethodProto::new_abstract("write", "([CII)V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
27 JavaMethodProto::new("write", "(Ljava/lang/String;)V", Self::write_string, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new("write", "(Ljava/lang/String;II)V", Self::write_string_offset, MethodAccessFlags::PUBLIC),
29 JavaMethodProto::new(
30 "append",
31 "(Ljava/lang/CharSequence;)Ljava/io/Writer;",
32 Self::append_char_sequence,
33 MethodAccessFlags::PUBLIC,
34 ),
35 JavaMethodProto::new(
36 "append",
37 "(Ljava/lang/CharSequence;II)Ljava/io/Writer;",
38 Self::append_char_sequence_range,
39 MethodAccessFlags::PUBLIC,
40 ),
41 JavaMethodProto::new("append", "(C)Ljava/io/Writer;", Self::append_char, MethodAccessFlags::PUBLIC),
42 JavaMethodProto::new(
43 "append",
44 "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
45 Self::append_char_sequence,
46 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
47 ),
48 JavaMethodProto::new(
49 "append",
50 "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
51 Self::append_char_sequence_range,
52 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
53 ),
54 JavaMethodProto::new(
55 "append",
56 "(C)Ljava/lang/Appendable;",
57 Self::append_char,
58 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
59 ),
60 JavaMethodProto::new_abstract("flush", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
61 JavaMethodProto::new_abstract("close", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
62 ],
63 fields: vec![JavaFieldProto::new("lock", "Ljava/lang/Object;", FieldAccessFlags::PROTECTED)],
64 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
65 }
66 }
67
68 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
69 tracing::debug!("java.io.Writer::<init>({this:?})");
70
71 let _: () = jvm
72 .invoke_special(&this, "java/io/Writer", "<init>", "(Ljava/lang/Object;)V", (this.clone(),))
73 .await?;
74
75 Ok(())
76 }
77
78 async fn init_with_lock(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, lock: ClassInstanceRef<Object>) -> Result<()> {
79 tracing::debug!("java.io.Writer::<init>({this:?}, {lock:?})");
80
81 if lock.is_null() {
82 return Err(jvm.exception("java/lang/NullPointerException", "lock is null").await);
83 }
84
85 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
86 jvm.put_field(&mut this, "java/io/Writer", "lock", "Ljava/lang/Object;", lock).await?;
87
88 Ok(())
89 }
90
91 async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
92 tracing::debug!("java.io.Writer::write({this:?}, {value})");
93
94 let mut chars = jvm.instantiate_array("C", 1).await?;
95 jvm.store_array(&mut chars, 0, [value as JavaChar]).await?;
96 jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, 1)).await
97 }
98
99 async fn write_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, chars: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
100 tracing::debug!("java.io.Writer::write({this:?}, {chars:?})");
101 if chars.is_null() {
102 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
103 }
104
105 let length = jvm.array_length(&chars).await? as i32;
106 jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, length)).await
107 }
108
109 async fn write_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<()> {
110 tracing::debug!("java.io.Writer::write_string({this:?}, {string:?})");
111 if string.is_null() {
112 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
113 }
114
115 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&string, "java/lang/String", "toCharArray", "()[C", ()).await?;
116 let length = jvm.array_length(&chars).await?;
117
118 let _: () = jvm
119 .invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, length as i32))
120 .await?;
121
122 Ok(())
123 }
124
125 async fn write_string_offset(
126 jvm: &Jvm,
127 _: &mut RuntimeContext,
128 this: ClassInstanceRef<Self>,
129 string: ClassInstanceRef<String>,
130 off: i32,
131 len: i32,
132 ) -> Result<()> {
133 tracing::debug!("java.io.Writer::write({this:?}, {string:?}, {off}, {len})");
134 if string.is_null() {
135 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
136 }
137
138 let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&string, "java/lang/String", "toCharArray", "()[C", ()).await?;
139 jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, off, len)).await
140 }
141
142 async fn append_char_sequence(
143 jvm: &Jvm,
144 _: &mut RuntimeContext,
145 this: ClassInstanceRef<Self>,
146 sequence: ClassInstanceRef<CharSequence>,
147 ) -> Result<ClassInstanceRef<Self>> {
148 let string: ClassInstanceRef<String> = if sequence.is_null() {
149 JavaLangString::from_rust_string(jvm, "null").await?.into()
150 } else {
151 jvm.invoke_virtual(&sequence, &sequence.class_definition().name(), "toString", "()Ljava/lang/String;", ())
152 .await?
153 };
154 let _: () = jvm
155 .invoke_virtual(&this, "java/io/Writer", "write", "(Ljava/lang/String;)V", (string,))
156 .await?;
157 Ok(this)
158 }
159
160 async fn append_char_sequence_range(
161 jvm: &Jvm,
162 _: &mut RuntimeContext,
163 this: ClassInstanceRef<Self>,
164 sequence: ClassInstanceRef<CharSequence>,
165 start: i32,
166 end: i32,
167 ) -> Result<ClassInstanceRef<Self>> {
168 let sequence: ClassInstanceRef<CharSequence> = if sequence.is_null() {
169 JavaLangString::from_rust_string(jvm, "null").await?.into()
170 } else {
171 sequence
172 };
173 let subsequence: ClassInstanceRef<CharSequence> = jvm
174 .invoke_virtual(
175 &sequence,
176 &sequence.class_definition().name(),
177 "subSequence",
178 "(II)Ljava/lang/CharSequence;",
179 (start, end),
180 )
181 .await?;
182 let string: ClassInstanceRef<String> = jvm
183 .invoke_virtual(
184 &subsequence,
185 &subsequence.class_definition().name(),
186 "toString",
187 "()Ljava/lang/String;",
188 (),
189 )
190 .await?;
191 let _: () = jvm
192 .invoke_virtual(&this, "java/io/Writer", "write", "(Ljava/lang/String;)V", (string,))
193 .await?;
194 Ok(this)
195 }
196
197 async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, character: JavaChar) -> Result<ClassInstanceRef<Self>> {
198 let _: () = jvm.invoke_virtual(&this, "java/io/Writer", "write", "(I)V", (character as i32,)).await?;
199 Ok(this)
200 }
201}