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