Skip to main content

rustjava_runtime/classes/java/util/
properties.rs

1use alloc::{format, string::String as RustString, vec, vec::Vec};
2
3use jvm::{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::{
10        io::{InputStream, OutputStream},
11        lang::{Object, String},
12    },
13};
14
15use super::Hashtable;
16
17// class java.util.Properties
18pub struct Properties;
19
20impl Properties {
21    pub fn as_proto() -> RuntimeClassProto {
22        RuntimeClassProto {
23            name: "java/util/Properties",
24            parent_class: Some("java/util/Hashtable"),
25            interfaces: vec![],
26            methods: vec![
27                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("<init>", "(Ljava/util/Properties;)V", Self::init_with_defaults, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new(
30                    "getProperty",
31                    "(Ljava/lang/String;)Ljava/lang/String;",
32                    Self::get_property,
33                    MethodAccessFlags::PUBLIC,
34                ),
35                JavaMethodProto::new(
36                    "getProperty",
37                    "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
38                    Self::get_property_with_default,
39                    MethodAccessFlags::PUBLIC,
40                ),
41                JavaMethodProto::new(
42                    "setProperty",
43                    "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
44                    Self::set_property,
45                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
46                ),
47                JavaMethodProto::new(
48                    "load",
49                    "(Ljava/io/InputStream;)V",
50                    Self::load,
51                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
52                ),
53                JavaMethodProto::new(
54                    "store",
55                    "(Ljava/io/OutputStream;Ljava/lang/String;)V",
56                    Self::store,
57                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
58                ),
59                JavaMethodProto::new(
60                    "propertyNames",
61                    "()Ljava/util/Enumeration;",
62                    Self::property_names,
63                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
64                ),
65            ],
66            fields: vec![JavaFieldProto::new("defaults", "Ljava/util/Properties;", FieldAccessFlags::PROTECTED)],
67            access_flags: ClassAccessFlags::PUBLIC,
68        }
69    }
70
71    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
72        tracing::debug!("java.util.Properties::<init>({this:?})");
73
74        let defaults: ClassInstanceRef<Self> = None.into();
75        jvm.invoke_special(&this, "java/util/Properties", "<init>", "(Ljava/util/Properties;)V", (defaults,))
76            .await
77    }
78
79    async fn init_with_defaults(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, defaults: ClassInstanceRef<Self>) -> Result<()> {
80        tracing::debug!("java.util.Properties::<init>({this:?}, {defaults:?})");
81
82        let _: () = jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "()V", ()).await?;
83        jvm.put_field(&mut this, "defaults", "Ljava/util/Properties;", defaults).await
84    }
85
86    async fn get_property(
87        jvm: &Jvm,
88        _: &mut RuntimeContext,
89        this: ClassInstanceRef<Self>,
90        key: ClassInstanceRef<String>,
91    ) -> Result<ClassInstanceRef<String>> {
92        tracing::debug!("java.util.Properties::getProperty({this:?}, {key:?})");
93
94        let result: ClassInstanceRef<Object> = jvm
95            .invoke_virtual(
96                &this,
97                "java/util/Properties",
98                "get",
99                "(Ljava/lang/Object;)Ljava/lang/Object;",
100                (key.clone(),),
101            )
102            .await?;
103        if !result.is_null() && jvm.is_instance(&**result, "java/lang/String") {
104            return Ok(ClassInstanceRef::new(result.instance));
105        }
106
107        let defaults: ClassInstanceRef<Self> = jvm.get_field(&this, "defaults", "Ljava/util/Properties;").await?;
108        if defaults.is_null() {
109            Ok(None.into())
110        } else {
111            jvm.invoke_virtual(
112                &defaults,
113                "java/util/Properties",
114                "getProperty",
115                "(Ljava/lang/String;)Ljava/lang/String;",
116                (key,),
117            )
118            .await
119        }
120    }
121
122    async fn get_property_with_default(
123        jvm: &Jvm,
124        _: &mut RuntimeContext,
125        this: ClassInstanceRef<Self>,
126        key: ClassInstanceRef<String>,
127        default_value: ClassInstanceRef<String>,
128    ) -> Result<ClassInstanceRef<String>> {
129        tracing::debug!("java.util.Properties::getProperty({this:?}, {key:?}, {default_value:?})");
130
131        let value: ClassInstanceRef<String> = jvm
132            .invoke_virtual(
133                &this,
134                "java/util/Properties",
135                "getProperty",
136                "(Ljava/lang/String;)Ljava/lang/String;",
137                (key,),
138            )
139            .await?;
140        if value.is_null() { Ok(default_value) } else { Ok(value) }
141    }
142
143    async fn set_property(
144        jvm: &Jvm,
145        _: &mut RuntimeContext,
146        this: ClassInstanceRef<Self>,
147        key: ClassInstanceRef<String>,
148        value: ClassInstanceRef<String>,
149    ) -> Result<ClassInstanceRef<Object>> {
150        tracing::debug!("java.util.Properties::setProperty({this:?}, {key:?}, {value:?})");
151
152        jvm.invoke_virtual(
153            &this,
154            "java/util/Properties",
155            "put",
156            "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
157            (key, value),
158        )
159        .await
160    }
161
162    async fn load(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, input: ClassInstanceRef<InputStream>) -> Result<()> {
163        tracing::debug!("java.util.Properties::load({this:?}, {input:?})");
164
165        if input.is_null() {
166            return Err(jvm.exception("java/lang/NullPointerException", "inStream").await);
167        }
168
169        let mut logical_line = Vec::new();
170        let mut skip_lf = false;
171        let mut skip_leading_whitespace = false;
172        loop {
173            let value: i32 = jvm.invoke_virtual(&input, "java/io/InputStream", "read", "()I", ()).await?;
174            if value < 0 {
175                if !logical_line.is_empty() {
176                    let trailing_backslashes = logical_line.iter().rev().take_while(|character| **character == b'\\' as JavaChar).count();
177                    if trailing_backslashes % 2 == 1 {
178                        logical_line.pop();
179                    }
180                    Self::load_logical_line(jvm, &this, &logical_line).await?;
181                }
182                return Ok(());
183            }
184
185            let byte = value as u8;
186            if skip_lf {
187                skip_lf = false;
188                if byte == b'\n' {
189                    continue;
190                }
191            }
192
193            if byte == b'\n' || byte == b'\r' {
194                if byte == b'\r' {
195                    skip_lf = true;
196                }
197
198                let trailing_backslashes = logical_line.iter().rev().take_while(|character| **character == b'\\' as JavaChar).count();
199                let first_non_whitespace = logical_line
200                    .iter()
201                    .position(|character| !matches!(*character, character if character == b' ' as JavaChar || character == b'\t' as JavaChar || character == 0x0c));
202                let is_comment = first_non_whitespace
203                    .is_some_and(|position| logical_line[position] == b'#' as JavaChar || logical_line[position] == b'!' as JavaChar);
204                if !is_comment && trailing_backslashes % 2 == 1 {
205                    logical_line.pop();
206                    skip_leading_whitespace = true;
207                } else {
208                    Self::load_logical_line(jvm, &this, &logical_line).await?;
209                    logical_line.clear();
210                    skip_leading_whitespace = false;
211                }
212                continue;
213            }
214
215            if skip_leading_whitespace && matches!(byte, b' ' | b'\t' | 0x0c) {
216                continue;
217            }
218            skip_leading_whitespace = false;
219            logical_line.push(byte as JavaChar);
220        }
221    }
222
223    async fn load_logical_line(jvm: &Jvm, this: &ClassInstanceRef<Self>, logical_line: &[JavaChar]) -> Result<()> {
224        let mut key_start = 0;
225        while key_start < logical_line.len()
226            && matches!(logical_line[key_start], character if character == b' ' as JavaChar || character == b'\t' as JavaChar || character == 0x0c)
227        {
228            key_start += 1;
229        }
230        if key_start == logical_line.len() || logical_line[key_start] == b'#' as JavaChar || logical_line[key_start] == b'!' as JavaChar {
231            return Ok(());
232        }
233
234        let mut key_end = key_start;
235        let mut preceding_backslash = false;
236        while key_end < logical_line.len() {
237            let character = logical_line[key_end];
238            if !preceding_backslash
239                && (character == b'=' as JavaChar
240                    || character == b':' as JavaChar
241                    || character == b' ' as JavaChar
242                    || character == b'\t' as JavaChar
243                    || character == 0x0c)
244            {
245                break;
246            }
247            if character == b'\\' as JavaChar {
248                preceding_backslash = !preceding_backslash;
249            } else {
250                preceding_backslash = false;
251            }
252            key_end += 1;
253        }
254
255        let mut value_start = key_end;
256        while value_start < logical_line.len()
257            && matches!(logical_line[value_start], character if character == b' ' as JavaChar || character == b'\t' as JavaChar || character == 0x0c)
258        {
259            value_start += 1;
260        }
261        if value_start < logical_line.len() && (logical_line[value_start] == b'=' as JavaChar || logical_line[value_start] == b':' as JavaChar) {
262            value_start += 1;
263        }
264        while value_start < logical_line.len()
265            && matches!(logical_line[value_start], character if character == b' ' as JavaChar || character == b'\t' as JavaChar || character == 0x0c)
266        {
267            value_start += 1;
268        }
269
270        let Some(key_chars) = Self::load_convert(&logical_line[key_start..key_end]) else {
271            return Err(jvm.exception("java/lang/IllegalArgumentException", "Malformed \\uxxxx encoding").await);
272        };
273        let Some(value_chars) = Self::load_convert(&logical_line[value_start..]) else {
274            return Err(jvm.exception("java/lang/IllegalArgumentException", "Malformed \\uxxxx encoding").await);
275        };
276
277        let key = JavaLangString::from_utf16(jvm, key_chars).await?;
278        let value = JavaLangString::from_utf16(jvm, value_chars).await?;
279        let _: ClassInstanceRef<Object> = jvm
280            .invoke_virtual(
281                this,
282                "java/util/Properties",
283                "put",
284                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
285                (key, value),
286            )
287            .await?;
288        Ok(())
289    }
290
291    async fn store(
292        jvm: &Jvm,
293        _: &mut RuntimeContext,
294        this: ClassInstanceRef<Self>,
295        output: ClassInstanceRef<OutputStream>,
296        comments: ClassInstanceRef<String>,
297    ) -> Result<()> {
298        tracing::debug!("java.util.Properties::store({this:?}, {output:?}, {comments:?})");
299
300        if output.is_null() {
301            return Err(jvm.exception("java/lang/NullPointerException", "out").await);
302        }
303
304        let mut text = RustString::new();
305        if !comments.is_null() {
306            let comments = JavaLangString::to_utf16(jvm, &comments).await?;
307            text.push('#');
308            let mut index = 0;
309            while index < comments.len() {
310                let character = comments[index];
311                if character == b'\r' as JavaChar || character == b'\n' as JavaChar {
312                    if character == b'\r' as JavaChar && index + 1 < comments.len() && comments[index + 1] == b'\n' as JavaChar {
313                        index += 1;
314                    }
315                    text.push('\n');
316                    if index + 1 < comments.len() {
317                        text.push('#');
318                    }
319                } else if !(0x20..=0x7e).contains(&character) {
320                    text.push_str(&format!("\\u{character:04X}"));
321                } else {
322                    text.push(char::from_u32(character as u32).unwrap());
323                }
324                index += 1;
325            }
326            text.push('\n');
327        }
328        let date = jvm.new_class("java/util/Date", "()V", ()).await?;
329        let date: ClassInstanceRef<String> = jvm
330            .invoke_virtual(&date, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
331            .await?;
332        text.push('#');
333        text.push_str(&JavaLangString::to_rust_string(jvm, &date).await?);
334        text.push('\n');
335
336        let names: ClassInstanceRef<Object> = jvm
337            .invoke_virtual(&this, "java/util/Properties", "keys", "()Ljava/util/Enumeration;", ())
338            .await?;
339        while jvm
340            .invoke_virtual::<_, bool>(&names, &names.class_definition().name(), "hasMoreElements", "()Z", ())
341            .await?
342        {
343            let key: ClassInstanceRef<Object> = jvm
344                .invoke_virtual(&names, &names.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ())
345                .await?;
346            let value: ClassInstanceRef<Object> = jvm
347                .invoke_virtual(
348                    &this,
349                    "java/util/Properties",
350                    "get",
351                    "(Ljava/lang/Object;)Ljava/lang/Object;",
352                    (key.clone(),),
353                )
354                .await?;
355            if !jvm.is_instance(&**key, "java/lang/String") || value.is_null() || !jvm.is_instance(&**value, "java/lang/String") {
356                return Err(jvm
357                    .exception("java/lang/ClassCastException", "Properties key and value must be String")
358                    .await);
359            }
360
361            let key_chars = JavaLangString::to_utf16(jvm, &key).await?;
362            let value_chars = JavaLangString::to_utf16(jvm, &value).await?;
363            text.push_str(&Self::save_convert(&key_chars, true));
364            text.push('=');
365            text.push_str(&Self::save_convert(&value_chars, false));
366            text.push('\n');
367        }
368
369        let bytes = text.into_bytes();
370        let mut byte_array = jvm.instantiate_array("B", bytes.len()).await?;
371        jvm.store_array(&mut byte_array, 0, bytes.into_iter().map(|byte| byte as i8)).await?;
372        let _: () = jvm
373            .invoke_virtual(&output, "java/io/OutputStream", "write", "([B)V", (byte_array,))
374            .await?;
375        jvm.invoke_virtual(&output, "java/io/OutputStream", "flush", "()V", ()).await
376    }
377
378    async fn property_names(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
379        tracing::debug!("java.util.Properties::propertyNames({this:?})");
380
381        let table = Self::enumerate(jvm, &this).await?;
382        jvm.invoke_virtual(&table, "java/util/Hashtable", "keys", "()Ljava/util/Enumeration;", ())
383            .await
384    }
385
386    async fn enumerate(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Hashtable>> {
387        let table: ClassInstanceRef<Hashtable> = jvm.new_class("java/util/Hashtable", "()V", ()).await?.into();
388        let mut layers = Vec::new();
389        let mut current = this.clone();
390        while !current.is_null() {
391            layers.push(current.clone());
392            current = jvm.get_field(&current, "defaults", "Ljava/util/Properties;").await?;
393        }
394
395        for layer in layers.into_iter().rev() {
396            let names: ClassInstanceRef<Object> = jvm
397                .invoke_virtual(&layer, "java/util/Properties", "keys", "()Ljava/util/Enumeration;", ())
398                .await?;
399            while jvm
400                .invoke_virtual::<_, bool>(&names, &names.class_definition().name(), "hasMoreElements", "()Z", ())
401                .await?
402            {
403                let key: ClassInstanceRef<Object> = jvm
404                    .invoke_virtual(&names, &names.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ())
405                    .await?;
406                if key.is_null() || !jvm.is_instance(&**key, "java/lang/String") {
407                    return Err(jvm.exception("java/lang/ClassCastException", "Properties key must be String").await);
408                }
409                let value: ClassInstanceRef<Object> = jvm
410                    .invoke_virtual(
411                        &layer,
412                        "java/util/Properties",
413                        "get",
414                        "(Ljava/lang/Object;)Ljava/lang/Object;",
415                        (key.clone(),),
416                    )
417                    .await?;
418                let _: ClassInstanceRef<Object> = jvm
419                    .invoke_virtual(
420                        &table,
421                        "java/util/Hashtable",
422                        "put",
423                        "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
424                        (key, value),
425                    )
426                    .await?;
427            }
428        }
429        Ok(table)
430    }
431
432    fn load_convert(input: &[JavaChar]) -> Option<Vec<JavaChar>> {
433        let mut output = Vec::with_capacity(input.len());
434        let mut index = 0;
435        while index < input.len() {
436            let character = input[index];
437            index += 1;
438            if character != b'\\' as JavaChar {
439                output.push(character);
440                continue;
441            }
442            if index == input.len() {
443                output.push(b'\\' as JavaChar);
444                break;
445            }
446
447            let escaped = input[index];
448            index += 1;
449            match escaped {
450                character if character == b't' as JavaChar => output.push(b'\t' as JavaChar),
451                character if character == b'n' as JavaChar => output.push(b'\n' as JavaChar),
452                character if character == b'r' as JavaChar => output.push(b'\r' as JavaChar),
453                character if character == b'f' as JavaChar => output.push(0x0c),
454                character if character == b'u' as JavaChar => {
455                    if index + 4 > input.len() {
456                        return None;
457                    }
458                    let mut value = 0u16;
459                    for digit in &input[index..index + 4] {
460                        value = value.checked_mul(16)?;
461                        value = value.checked_add(match *digit {
462                            character if (b'0' as JavaChar..=b'9' as JavaChar).contains(&character) => character - b'0' as JavaChar,
463                            character if (b'a' as JavaChar..=b'f' as JavaChar).contains(&character) => character - b'a' as JavaChar + 10,
464                            character if (b'A' as JavaChar..=b'F' as JavaChar).contains(&character) => character - b'A' as JavaChar + 10,
465                            _ => return None,
466                        })?;
467                    }
468                    index += 4;
469                    output.push(value);
470                }
471                _ => output.push(escaped),
472            }
473        }
474        Some(output)
475    }
476
477    fn save_convert(input: &[JavaChar], escape_space: bool) -> RustString {
478        let mut output = RustString::new();
479        for (index, character) in input.iter().copied().enumerate() {
480            match character {
481                character if character == b' ' as JavaChar && (index == 0 || escape_space) => output.push_str("\\ "),
482                character if character == b'\\' as JavaChar => output.push_str("\\\\"),
483                character if character == b'\t' as JavaChar => output.push_str("\\t"),
484                character if character == b'\n' as JavaChar => output.push_str("\\n"),
485                character if character == b'\r' as JavaChar => output.push_str("\\r"),
486                0x0c => output.push_str("\\f"),
487                character
488                    if character == b'=' as JavaChar
489                        || character == b':' as JavaChar
490                        || character == b'#' as JavaChar
491                        || character == b'!' as JavaChar =>
492                {
493                    output.push('\\');
494                    output.push(char::from_u32(character as u32).unwrap());
495                }
496                character if !(0x20..=0x7e).contains(&character) => output.push_str(&format!("\\u{character:04X}")),
497                character => output.push(char::from_u32(character as u32).unwrap()),
498            }
499        }
500        output
501    }
502}