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