Add CLI classpath options (#184)

* Add CLI classpath options

* Simplify URL classpath lookup

* Fix platform classpath handling

* Use File path separator for class loading

* Separate RustJar class loading

Author: dlunch

java_runtime/src/classes/java/io/file.rs

@@ -1,7 +1,8 @@
 use alloc::vec;
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
-use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
+use java_constants::{FieldAccessFlags, MethodAccessFlags};
+use jvm::{ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
 
 use crate::{FileType, RuntimeClassProto, RuntimeContext, classes::java::lang::String};
 
@@ -15,6 +16,7 @@ impl File {
             parent_class: Some("java/lang/Object"),
             interfaces: vec![],
             methods: vec![
+                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
                 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init, Default::default()),
                 JavaMethodProto::new("getPath", "()Ljava/lang/String;", Self::get_path, Default::default()),
                 JavaMethodProto::new("exists", "()Z", Self::exists, Default::default()),
@@ -23,11 +25,63 @@ impl File {
                 JavaMethodProto::new("delete", "()Z", Self::delete, Default::default()),
                 JavaMethodProto::new("length", "()J", Self::length, Default::default()),
             ],
-            fields: vec![JavaFieldProto::new("path", "Ljava/lang/String;", Default::default())],
+            fields: vec![
+                JavaFieldProto::new(
+                    "separatorChar",
+                    "C",
+                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
+                ),
+                JavaFieldProto::new(
+                    "separator",
+                    "Ljava/lang/String;",
+                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
+                ),
+                JavaFieldProto::new(
+                    "pathSeparatorChar",
+                    "C",
+                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
+                ),
+                JavaFieldProto::new(
+                    "pathSeparator",
+                    "Ljava/lang/String;",
+                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
+                ),
+                JavaFieldProto::new("path", "Ljava/lang/String;", Default::default()),
+            ],
             access_flags: Default::default(),
         }
     }
 
+    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
+        tracing::debug!("java.io.File::<clinit>()");
+
+        let separator_char = if cfg!(windows) { '\\' } else { '/' };
+        let separator = if cfg!(windows) { "\\" } else { "/" };
+        let path_separator_char = if cfg!(windows) { ';' } else { ':' };
+        let path_separator = if cfg!(windows) { ";" } else { ":" };
+
+        jvm.put_static_field("java/io/File", "separatorChar", "C", separator_char as JavaChar)
+            .await?;
+        jvm.put_static_field(
+            "java/io/File",
+            "separator",
+            "Ljava/lang/String;",
+            JavaLangString::from_rust_string(jvm, separator).await?,
+        )
+        .await?;
+        jvm.put_static_field("java/io/File", "pathSeparatorChar", "C", path_separator_char as JavaChar)
+            .await?;
+        jvm.put_static_field(
+            "java/io/File",
+            "pathSeparator",
+            "Ljava/lang/String;",
+            JavaLangString::from_rust_string(jvm, path_separator).await?,
+        )
+        .await?;
+
+        Ok(())
+    }
+
     async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, pathname: ClassInstanceRef<String>) -> Result<()> {
         tracing::debug!("java.io.File::<init>({this:?}, {pathname:?})");
 

java_runtime/src/classes/java/lang/class_loader.rs

@@ -97,28 +97,45 @@ impl ClassLoader {
                 )
                 .await?;
 
-            let url_array = if !class_path.is_null() {
+            let (class_paths, urls) = if !class_path.is_null() {
                 let class_path = JavaLangString::to_rust_string(jvm, &class_path).await?;
+                let path_separator: ClassInstanceRef<String> = jvm.get_static_field("java/io/File", "pathSeparator", "Ljava/lang/String;").await?;
+                let path_separator = JavaLangString::to_rust_string(jvm, &path_separator).await?;
 
+                let mut class_paths = Vec::new();
                 let mut urls = Vec::new();
-                for path in class_path.split(':') {
-                    // TODO File.pathSeparator
+                for path in class_path.split(path_separator.as_str()) {
+                    class_paths.push(JavaLangString::from_rust_string(jvm, path).await?);
+
                     let path = JavaLangString::from_rust_string(jvm, &format!("file:{path}")).await?;
                     let url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (path,)).await?;
-
                     urls.push(url);
                 }
 
-                let mut url_array = jvm.instantiate_array("Ljava/net/URL;", urls.len()).await?;
-                jvm.store_array(&mut url_array, 0, urls).await?;
-
-                url_array
+                (class_paths, urls)
             } else {
-                jvm.instantiate_array("Ljava/net/URL;", 0).await?
+                (Vec::new(), Vec::new())
             };
 
+            let mut class_path_array = jvm.instantiate_array("Ljava/lang/String;", class_paths.len()).await?;
+            jvm.store_array(&mut class_path_array, 0, class_paths).await?;
+            let rustjar_class_loader = jvm
+                .new_class(
+                    "org/rustjava/lang/RustJarClassLoader",
+                    "([Ljava/lang/String;Ljava/lang/ClassLoader;)V",
+                    (class_path_array, None),
+                )
+                .await?;
+
+            let mut url_array = jvm.instantiate_array("Ljava/net/URL;", urls.len()).await?;
+            jvm.store_array(&mut url_array, 0, urls).await?;
+
             let url_class_loader = jvm
-                .new_class("java/net/URLClassLoader", "([Ljava/net/URL;Ljava/lang/ClassLoader;)V", (url_array, None))
+                .new_class(
+                    "java/net/URLClassLoader",
+                    "([Ljava/net/URL;Ljava/lang/ClassLoader;)V",
+                    (url_array, rustjar_class_loader),
+                )
                 .await?;
 
             let class_loader_type: ClassInstanceRef<String> = jvm

java_runtime/src/classes/java/net/url_class_loader.rs

@@ -7,7 +7,7 @@ use jvm::{
 };
 
 use crate::{
-    RuntimeClassProto, RuntimeContext,
+    FileType, RuntimeClassProto, RuntimeContext,
     classes::java::{
         lang::{Class, ClassLoader, String},
         net::{JarURLConnection, URL},
@@ -59,32 +59,14 @@ impl URLClassLoader {
 
     async fn find_class(
         jvm: &Jvm,
-        context: &mut RuntimeContext,
+        _: &mut RuntimeContext,
         this: ClassInstanceRef<Self>,
         name: ClassInstanceRef<String>,
     ) -> Result<ClassInstanceRef<Class>> {
         tracing::debug!("java.net.URLClassLoader::findClass({this:?}, {name:?})");
 
         let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
 
-        // find rustjar first
-        let urls = jvm.get_field(&this, "urls", "[Ljava/net/URL;").await?;
-        let urls: Vec<ClassInstanceRef<URL>> = jvm.load_array(&urls, 0, jvm.array_length(&urls).await? as _).await?;
-
-        for url in urls {
-            let file = jvm.invoke_virtual(&url, "getFile", "()Ljava/lang/String;", ()).await?;
-            let file = JavaLangString::to_rust_string(jvm, &file).await?;
-
-            if file.ends_with(".rustjar") {
-                let class = context.find_rustjar_class(jvm, &file, &name_str).await?;
-                if let Some(class) = class {
-                    let java_class = jvm.register_class(class, Some(this.into())).await?.unwrap();
-
-                    return Ok(java_class.into());
-                }
-            }
-        }
-
         let resource_name = format!("{}.class", name_str.replace('.', "/"));
         let resource_name = JavaLangString::from_rust_string(jvm, &resource_name).await?;
 
@@ -130,12 +112,16 @@ impl URLClassLoader {
         for url in urls {
             let file = jvm.invoke_virtual(&url, "getFile", "()Ljava/lang/String;", ()).await?;
             let file = JavaLangString::to_rust_string(jvm, &file).await?;
-            if file.ends_with('/') || file.is_empty() {
+
+            let metadata = runtime.metadata(&file).await;
+            if file.ends_with('/') || file.is_empty() || metadata.as_ref().is_ok_and(|metadata| metadata.r#type == FileType::Directory) {
                 // directory
-                let final_path = if file.ends_with('/') {
+                let final_path = if file.is_empty() {
+                    name_str.clone()
+                } else if file.ends_with('/') {
                     format!("{file}{name_str}")
                 } else {
-                    name_str.clone()
+                    format!("{file}/{name_str}")
                 };
 
                 if runtime.metadata(&final_path).await.is_ok() {
@@ -153,8 +139,8 @@ impl URLClassLoader {
 
                     return Ok(new_url.into());
                 }
-            } else if file.ends_with(".rustjar") {
-                // TODO rustjar resource
+            } else if metadata.is_err() {
+                continue;
             } else {
                 // treat as jar
                 let name_str = name_str.trim_start_matches('/');

java_runtime/src/classes/java/net/url_stream_handler.rs

@@ -95,8 +95,11 @@ impl URLStreamHandler {
 
         let protocol = parsed_url.scheme();
         let path = parsed_url.path().to_owned() + &parsed_url.query().map(|x| "?".to_owned() + x).unwrap_or("".into());
-        // TODO handle more elegantly..
-        let file = if protocol == "file" { path.trim_start_matches('/') } else { &path };
+        let file = if protocol == "file" && spec_str.strip_prefix("file:").is_some_and(|file| !file.starts_with('/')) {
+            path.trim_start_matches('/')
+        } else {
+            &path
+        };
 
         let protocol = JavaLangString::from_rust_string(jvm, parsed_url.scheme()).await?;
         let host = JavaLangString::from_rust_string(jvm, parsed_url.host_str().unwrap_or("")).await?;

java_runtime/src/classes/org/rustjava.rs

@@ -1 +1,2 @@
+pub mod lang;
 pub mod net;

java_runtime/src/classes/org/rustjava/lang.rs

@@ -0,0 +1,3 @@
+mod rust_jar_class_loader;
+
+pub use rust_jar_class_loader::RustJarClassLoader;

java_runtime/src/classes/org/rustjava/lang/rust_jar_class_loader.rs

@@ -0,0 +1,73 @@
+use alloc::{vec, vec::Vec};
+
+use java_class_proto::{JavaFieldProto, JavaMethodProto};
+use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
+
+use crate::{
+    RuntimeClassProto, RuntimeContext,
+    classes::java::lang::{Class, ClassLoader, String},
+};
+
+// class org.rustjava.lang.RustJarClassLoader
+pub struct RustJarClassLoader;
+
+impl RustJarClassLoader {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "org/rustjava/lang/RustJarClassLoader",
+            parent_class: Some("java/lang/ClassLoader"),
+            interfaces: vec![],
+            methods: vec![
+                JavaMethodProto::new("<init>", "([Ljava/lang/String;Ljava/lang/ClassLoader;)V", Self::init, Default::default()),
+                JavaMethodProto::new("findClass", "(Ljava/lang/String;)Ljava/lang/Class;", Self::find_class, Default::default()),
+            ],
+            fields: vec![JavaFieldProto::new("classPaths", "[Ljava/lang/String;", Default::default())],
+            access_flags: Default::default(),
+        }
+    }
+
+    async fn init(
+        jvm: &Jvm,
+        _: &mut RuntimeContext,
+        mut this: ClassInstanceRef<Self>,
+        class_paths: ClassInstanceRef<Array<String>>,
+        parent: ClassInstanceRef<ClassLoader>,
+    ) -> Result<()> {
+        tracing::debug!("org.rustjava.lang.RustJarClassLoader::<init>({this:?}, {class_paths:?}, {parent:?})");
+
+        let _: () = jvm
+            .invoke_special(&this, "java/lang/ClassLoader", "<init>", "(Ljava/lang/ClassLoader;)V", (parent,))
+            .await?;
+
+        jvm.put_field(&mut this, "classPaths", "[Ljava/lang/String;", class_paths).await?;
+
+        Ok(())
+    }
+
+    async fn find_class(
+        jvm: &Jvm,
+        runtime: &mut RuntimeContext,
+        this: ClassInstanceRef<Self>,
+        name: ClassInstanceRef<String>,
+    ) -> Result<ClassInstanceRef<Class>> {
+        tracing::debug!("org.rustjava.lang.RustJarClassLoader::findClass({this:?}, {name:?})");
+
+        let name = JavaLangString::to_rust_string(jvm, &name).await?;
+        let class_paths = jvm.get_field(&this, "classPaths", "[Ljava/lang/String;").await?;
+        let class_paths: Vec<ClassInstanceRef<String>> = jvm.load_array(&class_paths, 0, jvm.array_length(&class_paths).await? as usize).await?;
+
+        for class_path in class_paths {
+            let class_path = JavaLangString::to_rust_string(jvm, &class_path).await?;
+            if !class_path.ends_with(".rustjar") {
+                continue;
+            }
+
+            if let Some(class) = runtime.find_rustjar_class(jvm, &class_path, &name).await? {
+                let class = jvm.register_class(class, Some(this.clone().into())).await?;
+                return Ok(class.into());
+            }
+        }
+
+        Ok(None.into())
+    }
+}

java_runtime/src/loader.rs

@@ -168,17 +168,18 @@ pub fn get_runtime_class_proto(name: &str) -> Option<RuntimeClassProto> {
         crate::classes::org::rustjava::net::FileURLHandler::as_proto(),
         crate::classes::org::rustjava::net::JarURLConnection::as_proto(),
         crate::classes::org::rustjava::net::JarURLHandler::as_proto(),
+        crate::classes::org::rustjava::lang::RustJarClassLoader::as_proto(),
     ];
 
     protos.into_iter().find(|proto| proto.name == name)
 }
 
-struct JavaRuntimeClassLoader {
+struct JavaRuntimeBootstrapClassLoader {
     runtime: Box<dyn Runtime>,
 }
 
 #[async_trait::async_trait]
-impl BootstrapClassLoader for JavaRuntimeClassLoader {
+impl BootstrapClassLoader for JavaRuntimeBootstrapClassLoader {
     async fn load_class(&self, jvm: &Jvm, name: &str) -> Result<Option<Box<dyn ClassDefinition>>> {
         if let Some(element_type_name) = name.strip_prefix('[') {
             return Ok(Some(self.runtime.define_array_class(jvm, element_type_name).await?));
@@ -189,5 +190,5 @@ impl BootstrapClassLoader for JavaRuntimeClassLoader {
 }
 
 pub fn get_bootstrap_class_loader(runtime: Box<dyn Runtime>) -> impl BootstrapClassLoader {
-    JavaRuntimeClassLoader { runtime }
+    JavaRuntimeBootstrapClassLoader { runtime }
 }

java_runtime/tests/classes/java/io/mod.rs

@@ -3,6 +3,7 @@ mod test_byte_array_input_stream;
 mod test_byte_array_output_stream;
 mod test_data_input_stream;
 mod test_data_output_stream;
+mod test_file;
 mod test_file_input_stream;
 mod test_input_stream_reader;
 mod test_output_stream_writer;

java_runtime/tests/classes/java/io/test_file.rs

@@ -0,0 +1,28 @@
+use java_runtime::classes::java::lang::String;
+use jvm::{ClassInstanceRef, JavaChar, Result, runtime::JavaLangString};
+
+use test_utils::test_jvm;
+
+#[tokio::test]
+async fn test_platform_separators() -> Result<()> {
+    let jvm = test_jvm().await?;
+
+    let separator_char: JavaChar = jvm.get_static_field("java/io/File", "separatorChar", "C").await?;
+    let separator: ClassInstanceRef<String> = jvm.get_static_field("java/io/File", "separator", "Ljava/lang/String;").await?;
+    let path_separator_char: JavaChar = jvm.get_static_field("java/io/File", "pathSeparatorChar", "C").await?;
+    let path_separator: ClassInstanceRef<String> = jvm.get_static_field("java/io/File", "pathSeparator", "Ljava/lang/String;").await?;
+
+    if cfg!(windows) {
+        assert_eq!(separator_char, '\\' as JavaChar);
+        assert_eq!(JavaLangString::to_rust_string(&jvm, &separator).await?, "\\");
+        assert_eq!(path_separator_char, ';' as JavaChar);
+        assert_eq!(JavaLangString::to_rust_string(&jvm, &path_separator).await?, ";");
+    } else {
+        assert_eq!(separator_char, '/' as JavaChar);
+        assert_eq!(JavaLangString::to_rust_string(&jvm, &separator).await?, "/");
+        assert_eq!(path_separator_char, ':' as JavaChar);
+        assert_eq!(JavaLangString::to_rust_string(&jvm, &path_separator).await?, ":");
+    }
+
+    Ok(())
+}