Skip to main content

rustjava_runtime/classes/java/lang/
system.rs

1use alloc::{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        jvm.collect_garbage()?;
161
162        Ok(())
163    }
164
165    async fn arraycopy(
166        jvm: &Jvm,
167        _: &mut RuntimeContext,
168        src: ClassInstanceRef<Array<()>>, // Any Array
169        src_pos: i32,
170        mut dest: ClassInstanceRef<Array<()>>,
171        dest_pos: i32,
172        length: i32,
173    ) -> Result<()> {
174        tracing::debug!("java.lang.System::arraycopy({src:?}, {src_pos}, {dest:?}, {dest_pos}, {length})");
175
176        if src.is_null() || dest.is_null() {
177            return Err(jvm.exception("java/lang/NullPointerException", "array is null").await);
178        }
179
180        // TODO i think we can make it faster
181        let src: Vec<JavaValue> = jvm.load_array(&src, src_pos as _, length as _).await?;
182        jvm.store_array(&mut dest, dest_pos as _, src).await?;
183
184        Ok(())
185    }
186
187    async fn get_property(jvm: &Jvm, _: &mut RuntimeContext, key: ClassInstanceRef<String>) -> Result<ClassInstanceRef<String>> {
188        tracing::debug!("java.lang.System::getProperty({key:?})");
189
190        if key.is_null() {
191            return Err(jvm.exception("java/lang/NullPointerException", "key").await);
192        }
193
194        let props = jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await?;
195        let value = jvm
196            .invoke_virtual(
197                &props,
198                "java/util/Properties",
199                "getProperty",
200                "(Ljava/lang/String;)Ljava/lang/String;",
201                (key,),
202            )
203            .await?;
204
205        Ok(value)
206    }
207
208    async fn get_property_with_default(
209        jvm: &Jvm,
210        _: &mut RuntimeContext,
211        key: ClassInstanceRef<String>,
212        default_value: ClassInstanceRef<String>,
213    ) -> Result<ClassInstanceRef<String>> {
214        tracing::debug!("java.lang.System::getProperty({key:?}, {default_value:?})");
215
216        if key.is_null() {
217            return Err(jvm.exception("java/lang/NullPointerException", "key").await);
218        }
219
220        let props = jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await?;
221        jvm.invoke_virtual(
222            &props,
223            "java/util/Properties",
224            "getProperty",
225            "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
226            (key, default_value),
227        )
228        .await
229    }
230
231    async fn get_properties(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Properties>> {
232        tracing::debug!("java.lang.System::getProperties()");
233
234        jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await
235    }
236
237    async fn set_in(jvm: &Jvm, _: &mut RuntimeContext, input: ClassInstanceRef<InputStream>) -> Result<()> {
238        tracing::debug!("java.lang.System::setIn({input:?})");
239
240        jvm.put_static_field("java/lang/System", "in", "Ljava/io/InputStream;", input).await
241    }
242
243    async fn set_out(jvm: &Jvm, _: &mut RuntimeContext, output: ClassInstanceRef<PrintStream>) -> Result<()> {
244        tracing::debug!("java.lang.System::setOut({output:?})");
245
246        jvm.put_static_field("java/lang/System", "out", "Ljava/io/PrintStream;", output).await
247    }
248
249    async fn set_err(jvm: &Jvm, _: &mut RuntimeContext, error: ClassInstanceRef<PrintStream>) -> Result<()> {
250        tracing::debug!("java.lang.System::setErr({error:?})");
251
252        jvm.put_static_field("java/lang/System", "err", "Ljava/io/PrintStream;", error).await
253    }
254
255    async fn identity_hash_code(_: &Jvm, _: &mut RuntimeContext, object: ClassInstanceRef<Object>) -> Result<i32> {
256        tracing::debug!("java.lang.System::identityHashCode({object:?})");
257
258        if object.is_null() {
259            return Ok(0);
260        }
261
262        Ok(Object::identity_hash_code(&object))
263    }
264
265    async fn set_property(
266        jvm: &Jvm,
267        _: &mut RuntimeContext,
268        key: ClassInstanceRef<String>,
269        value: ClassInstanceRef<String>,
270    ) -> Result<ClassInstanceRef<String>> {
271        tracing::debug!("java.lang.System::setProperty({key:?}, {value:?})");
272
273        let props = jvm.get_static_field("java/lang/System", "props", "Ljava/util/Properties;").await?;
274        let value = jvm
275            .invoke_virtual(
276                &props,
277                "java/util/Properties",
278                "setProperty",
279                "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
280                (key, value),
281            )
282            .await?;
283
284        Ok(value)
285    }
286
287    async fn exit(_jvm: &Jvm, context: &mut RuntimeContext, status: i32) -> Result<()> {
288        tracing::debug!("java.lang.System::exit({status})");
289
290        context.exit(status);
291        Ok(())
292    }
293
294    pub async fn get_charset(jvm: &Jvm) -> Result<RustString> {
295        let charset: ClassInstanceRef<String> = jvm
296            .invoke_static(
297                "java/lang/System",
298                "getProperty",
299                "(Ljava/lang/String;)Ljava/lang/String;",
300                (JavaLangString::from_rust_string(jvm, "file.encoding").await?,),
301            )
302            .await?;
303
304        Ok(if !charset.is_null() {
305            JavaLangString::to_rust_string(jvm, &charset).await?
306        } else {
307            "UTF-8".into()
308        })
309    }
310}