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
17pub 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(¤t, "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}