Skip to main content

rustjava_runtime/classes/java/lang/
system.rs

1use alloc::{format, string::String as RustString, vec, vec::Vec};
2
3use jvm::{JavaValue, runtime::JavaLangString};
4
5use jvm::{Array, ClassInstanceRef, Jvm, Result};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10    RuntimeClassProto, RuntimeContext,
11    classes::java::{
12        io::{FileDescriptor, InputStream, PrintStream},
13        lang::{Object, String},
14        util::Properties,
15    },
16};
17
18// class java.lang.System
19pub struct System;
20
21impl System {
22    pub fn as_proto() -> RuntimeClassProto {
23        RuntimeClassProto {
24            name: "java/lang/System",
25            parent_class: Some("java/lang/Object"),
26            interfaces: vec![],
27            methods: vec![
28                JavaMethodProto::new("<clinit>", "()V", Self::cl_init, MethodAccessFlags::STATIC),
29                JavaMethodProto::new(
30                    "currentTimeMillis",
31                    "()J",
32                    Self::current_time_millis,
33                    MethodAccessFlags::NATIVE | MethodAccessFlags::STATIC,
34                ),
35                JavaMethodProto::new("gc", "()V", Self::gc, MethodAccessFlags::STATIC),
36                JavaMethodProto::new(
37                    "arraycopy",
38                    "(Ljava/lang/Object;ILjava/lang/Object;II)V",
39                    Self::arraycopy,
40                    MethodAccessFlags::NATIVE | MethodAccessFlags::STATIC,
41                ),
42                JavaMethodProto::new(
43                    "getProperty",
44                    "(Ljava/lang/String;)Ljava/lang/String;",
45                    Self::get_property,
46                    MethodAccessFlags::STATIC,
47                ),
48                JavaMethodProto::new(
49                    "setProperty",
50                    "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
51                    Self::set_property,
52                    MethodAccessFlags::STATIC,
53                ),
54                JavaMethodProto::new("exit", "(I)V", Self::exit, MethodAccessFlags::STATIC),
55                JavaMethodProto::new(
56                    "identityHashCode",
57                    "(Ljava/lang/Object;)I",
58                    Self::identity_hash_code,
59                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
60                ),
61                JavaMethodProto::new(
62                    "setIn",
63                    "(Ljava/io/InputStream;)V",
64                    Self::set_in,
65                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
66                ),
67                JavaMethodProto::new(
68                    "setOut",
69                    "(Ljava/io/PrintStream;)V",
70                    Self::set_out,
71                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
72                ),
73                JavaMethodProto::new(
74                    "setErr",
75                    "(Ljava/io/PrintStream;)V",
76                    Self::set_err,
77                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
78                ),
79                JavaMethodProto::new(
80                    "getProperties",
81                    "()Ljava/util/Properties;",
82                    Self::get_properties,
83                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
84                ),
85                JavaMethodProto::new(
86                    "getProperty",
87                    "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
88                    Self::get_property_with_default,
89                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
90                ),
91            ],
92            fields: vec![
93                JavaFieldProto::new(
94                    "in",
95                    "Ljava/io/InputStream;",
96                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
97                ),
98                JavaFieldProto::new(
99                    "out",
100                    "Ljava/io/PrintStream;",
101                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
102                ),
103                JavaFieldProto::new(
104                    "err",
105                    "Ljava/io/PrintStream;",
106                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
107                ),
108                JavaFieldProto::new("props", "Ljava/util/Properties;", FieldAccessFlags::PRIVATE | FieldAccessFlags::STATIC),
109            ],
110            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
111        }
112    }
113
114    async fn cl_init(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
115        tracing::debug!("java.lang.System::<clinit>()");
116
117        let in_descriptor: ClassInstanceRef<FileDescriptor> =
118            jvm.get_static_field("java/io/FileDescriptor", "in", "Ljava/io/FileDescriptor;").await?;
119        let input = jvm
120            .new_class("java/io/FileInputStream", "(Ljava/io/FileDescriptor;)V", (in_descriptor,))
121            .await?;
122        jvm.put_static_field("java/lang/System", "in", "Ljava/io/InputStream;", input).await?;
123
124        let out_descriptor: ClassInstanceRef<FileDescriptor> =
125            jvm.get_static_field("java/io/FileDescriptor", "out", "Ljava/io/FileDescriptor;").await?;
126        let out_file_output_stream = jvm
127            .new_class("java/io/FileOutputStream", "(Ljava/io/FileDescriptor;)V", (out_descriptor,))
128            .await?;
129        let out = jvm
130            .new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (out_file_output_stream,))
131            .await?;
132
133        let err_descriptor: ClassInstanceRef<FileDescriptor> =
134            jvm.get_static_field("java/io/FileDescriptor", "err", "Ljava/io/FileDescriptor;").await?;
135        let err_file_output_stream = jvm
136            .new_class("java/io/FileOutputStream", "(Ljava/io/FileDescriptor;)V", (err_descriptor,))
137            .await?;
138        let err = jvm
139            .new_class("java/io/PrintStream", "(Ljava/io/OutputStream;)V", (err_file_output_stream,))
140            .await?;
141
142        jvm.put_static_field("java/lang/System", "out", "Ljava/io/PrintStream;", out).await?;
143        jvm.put_static_field("java/lang/System", "err", "Ljava/io/PrintStream;", err).await?;
144
145        let props = jvm.new_class("java/util/Properties", "()V", ()).await?;
146        jvm.put_static_field("java/lang/System", "props", "Ljava/util/Properties;", props).await?;
147
148        Ok(())
149    }
150
151    async fn current_time_millis(_: &Jvm, context: &mut RuntimeContext) -> Result<i64> {
152        tracing::debug!("java.lang.System::currentTimeMillis()");
153
154        Ok(context.now() as _)
155    }
156
157    async fn gc(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
158        tracing::debug!("java.lang.System::gc()");
159
160        if let Err(error) = jvm.collect_garbage() {
161            return Err(jvm
162                .exception("java/lang/InternalError", &format!("Garbage collection failed: {error:#}"))
163                .await);
164        }
165
166        Ok(())
167    }
168
169    async fn arraycopy(
170        jvm: &Jvm,
171        _: &mut RuntimeContext,
172        src: ClassInstanceRef<Array<()>>, // Any Array
173        src_pos: i32,
174        mut dest: ClassInstanceRef<Array<()>>,
175        dest_pos: i32,
176        length: i32,
177    ) -> Result<()> {
178        tracing::debug!("java.lang.System::arraycopy({src:?}, {src_pos}, {dest:?}, {dest_pos}, {length})");
179
180        if src.is_null() || dest.is_null() {
181            return Err(jvm.exception("java/lang/NullPointerException", "array is null").await);
182        }
183
184        // TODO i think we can make it faster
185        let src: Vec<JavaValue> = jvm.load_array(&src, src_pos as _, length as _).await?;
186        jvm.store_array(&mut dest, dest_pos as _, src).await?;
187
188        Ok(())
189    }
190
191    async fn get_property(jvm: &Jvm, _: &mut RuntimeContext, key: ClassInstanceRef<String>) -> Result<ClassInstanceRef<String>> {
192        tracing::debug!("java.lang.System::getProperty({key:?})");
193
194        if key.is_null() {
195            return Err(jvm.exception("java/lang/NullPointerException", "key").await);
196        }
197
198        let props = jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await?;
199        let value = jvm
200            .invoke_virtual(
201                &props,
202                "java/util/Properties",
203                "getProperty",
204                "(Ljava/lang/String;)Ljava/lang/String;",
205                (key,),
206            )
207            .await?;
208
209        Ok(value)
210    }
211
212    async fn get_property_with_default(
213        jvm: &Jvm,
214        _: &mut RuntimeContext,
215        key: ClassInstanceRef<String>,
216        default_value: ClassInstanceRef<String>,
217    ) -> Result<ClassInstanceRef<String>> {
218        tracing::debug!("java.lang.System::getProperty({key:?}, {default_value:?})");
219
220        if key.is_null() {
221            return Err(jvm.exception("java/lang/NullPointerException", "key").await);
222        }
223
224        let props = jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await?;
225        jvm.invoke_virtual(
226            &props,
227            "java/util/Properties",
228            "getProperty",
229            "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
230            (key, default_value),
231        )
232        .await
233    }
234
235    async fn get_properties(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Properties>> {
236        tracing::debug!("java.lang.System::getProperties()");
237
238        jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await
239    }
240
241    async fn set_in(jvm: &Jvm, _: &mut RuntimeContext, input: ClassInstanceRef<InputStream>) -> Result<()> {
242        tracing::debug!("java.lang.System::setIn({input:?})");
243
244        jvm.put_static_field("java/lang/System", "in", "Ljava/io/InputStream;", input).await
245    }
246
247    async fn set_out(jvm: &Jvm, _: &mut RuntimeContext, output: ClassInstanceRef<PrintStream>) -> Result<()> {
248        tracing::debug!("java.lang.System::setOut({output:?})");
249
250        jvm.put_static_field("java/lang/System", "out", "Ljava/io/PrintStream;", output).await
251    }
252
253    async fn set_err(jvm: &Jvm, _: &mut RuntimeContext, error: ClassInstanceRef<PrintStream>) -> Result<()> {
254        tracing::debug!("java.lang.System::setErr({error:?})");
255
256        jvm.put_static_field("java/lang/System", "err", "Ljava/io/PrintStream;", error).await
257    }
258
259    async fn identity_hash_code(_: &Jvm, _: &mut RuntimeContext, object: ClassInstanceRef<Object>) -> Result<i32> {
260        tracing::debug!("java.lang.System::identityHashCode({object:?})");
261
262        if object.is_null() {
263            return Ok(0);
264        }
265
266        Ok(Object::identity_hash_code(&object))
267    }
268
269    async fn set_property(
270        jvm: &Jvm,
271        _: &mut RuntimeContext,
272        key: ClassInstanceRef<String>,
273        value: ClassInstanceRef<String>,
274    ) -> Result<ClassInstanceRef<String>> {
275        tracing::debug!("java.lang.System::setProperty({key:?}, {value:?})");
276
277        let props = jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await?;
278        let value = jvm
279            .invoke_virtual(
280                &props,
281                "java/util/Properties",
282                "setProperty",
283                "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
284                (key, value),
285            )
286            .await?;
287
288        Ok(value)
289    }
290
291    async fn exit(_jvm: &Jvm, context: &mut RuntimeContext, status: i32) -> Result<()> {
292        tracing::debug!("java.lang.System::exit({status})");
293
294        context.exit(status);
295        Ok(())
296    }
297
298    pub async fn get_charset(jvm: &Jvm) -> Result<RustString> {
299        let charset: ClassInstanceRef<String> = jvm
300            .invoke_static(
301                "java/lang/System",
302                "getProperty",
303                "(Ljava/lang/String;)Ljava/lang/String;",
304                (JavaLangString::from_rust_string(jvm, "file.encoding").await?,),
305            )
306            .await?;
307
308        Ok(if !charset.is_null() {
309            JavaLangString::to_rust_string(jvm, &charset).await?
310        } else {
311            "UTF-8".into()
312        })
313    }
314}