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