Skip to main content

rustjava_runtime/classes/java/lang/
class_loader.rs

1use alloc::{format, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, 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        lang::{Class, String},
11        net::URL,
12    },
13};
14
15// class java.lang.ClassLoader
16pub struct ClassLoader;
17
18impl ClassLoader {
19    pub fn as_proto() -> RuntimeClassProto {
20        RuntimeClassProto {
21            name: "java/lang/ClassLoader",
22            parent_class: Some("java/lang/Object"),
23            interfaces: vec![],
24            methods: vec![
25                JavaMethodProto::new("<init>", "(Ljava/lang/ClassLoader;)V", Self::init, MethodAccessFlags::PROTECTED),
26                JavaMethodProto::new(
27                    "loadClass",
28                    "(Ljava/lang/String;)Ljava/lang/Class;",
29                    Self::load_class,
30                    MethodAccessFlags::PUBLIC,
31                ),
32                JavaMethodProto::new(
33                    "findClass",
34                    "(Ljava/lang/String;)Ljava/lang/Class;",
35                    Self::find_class,
36                    MethodAccessFlags::PROTECTED,
37                ),
38                JavaMethodProto::new(
39                    "findLoadedClass",
40                    "(Ljava/lang/String;)Ljava/lang/Class;",
41                    Self::find_loaded_class,
42                    MethodAccessFlags::PROTECTED | MethodAccessFlags::FINAL,
43                ),
44                JavaMethodProto::new(
45                    "getSystemClassLoader",
46                    "()Ljava/lang/ClassLoader;",
47                    Self::get_system_class_loader,
48                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
49                ),
50                JavaMethodProto::new(
51                    "getResource",
52                    "(Ljava/lang/String;)Ljava/net/URL;",
53                    Self::get_resource,
54                    MethodAccessFlags::PUBLIC,
55                ),
56                JavaMethodProto::new(
57                    "getResourceAsStream",
58                    "(Ljava/lang/String;)Ljava/io/InputStream;",
59                    Self::get_resource_as_stream,
60                    MethodAccessFlags::PUBLIC,
61                ),
62                JavaMethodProto::new(
63                    "findResource",
64                    "(Ljava/lang/String;)Ljava/net/URL;",
65                    Self::find_resource,
66                    MethodAccessFlags::PROTECTED,
67                ),
68                JavaMethodProto::new(
69                    "defineClass",
70                    "(Ljava/lang/String;[BII)Ljava/lang/Class;",
71                    Self::define_class,
72                    MethodAccessFlags::PROTECTED | MethodAccessFlags::FINAL,
73                ),
74            ],
75            fields: vec![
76                JavaFieldProto::new("systemClassLoader", "Ljava/lang/ClassLoader;", FieldAccessFlags::STATIC),
77                JavaFieldProto::new("parent", "Ljava/lang/ClassLoader;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
78            ],
79            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
80        }
81    }
82
83    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, parent: ClassInstanceRef<Self>) -> Result<()> {
84        tracing::debug!("java.lang.ClassLoader::<init>({this:?}, {parent:?})");
85
86        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
87
88        jvm.put_field(&mut this, "parent", "Ljava/lang/ClassLoader;", parent).await?;
89
90        Ok(())
91    }
92
93    async fn get_system_class_loader(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
94        tracing::debug!("java.lang.ClassLoader::getSystemClassLoader()");
95
96        let system_class_loader: ClassInstanceRef<Self> = jvm
97            .get_static_field("java/lang/ClassLoader", "systemClassLoader", "Ljava/lang/ClassLoader;")
98            .await?;
99
100        if system_class_loader.is_null() {
101            let class_path: ClassInstanceRef<String> = jvm
102                .invoke_static(
103                    "java/lang/System",
104                    "getProperty",
105                    "(Ljava/lang/String;)Ljava/lang/String;",
106                    (JavaLangString::from_rust_string(jvm, "java.class.path").await?,),
107                )
108                .await?;
109
110            let (class_paths, urls) = if !class_path.is_null() {
111                let class_path = JavaLangString::to_rust_string(jvm, &class_path).await?;
112                let path_separator: ClassInstanceRef<String> = jvm.get_static_field("java/io/File", "pathSeparator", "Ljava/lang/String;").await?;
113                let path_separator = JavaLangString::to_rust_string(jvm, &path_separator).await?;
114
115                let mut class_paths = Vec::new();
116                let mut urls = Vec::new();
117                for path in class_path.split(path_separator.as_str()) {
118                    class_paths.push(JavaLangString::from_rust_string(jvm, path).await?);
119
120                    let path = JavaLangString::from_rust_string(jvm, &format!("file:{path}")).await?;
121                    let url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (path,)).await?;
122                    urls.push(url);
123                }
124
125                (class_paths, urls)
126            } else {
127                (Vec::new(), Vec::new())
128            };
129
130            let mut class_path_array = jvm.instantiate_array("Ljava/lang/String;", class_paths.len()).await?;
131            jvm.store_array(&mut class_path_array, 0, class_paths).await?;
132            let rustjar_class_loader = jvm
133                .new_class(
134                    "org/rustjava/lang/RustJarClassLoader",
135                    "([Ljava/lang/String;Ljava/lang/ClassLoader;)V",
136                    (class_path_array, None),
137                )
138                .await?;
139
140            let mut url_array = jvm.instantiate_array("Ljava/net/URL;", urls.len()).await?;
141            jvm.store_array(&mut url_array, 0, urls).await?;
142
143            let url_class_loader = jvm
144                .new_class(
145                    "java/net/URLClassLoader",
146                    "([Ljava/net/URL;Ljava/lang/ClassLoader;)V",
147                    (url_array, rustjar_class_loader),
148                )
149                .await?;
150
151            let class_loader_type: ClassInstanceRef<String> = jvm
152                .invoke_static(
153                    "java/lang/System",
154                    "getProperty",
155                    "(Ljava/lang/String;)Ljava/lang/String;",
156                    (JavaLangString::from_rust_string(jvm, "java.system.class.loader").await?,),
157                )
158                .await?;
159
160            let system_class_loader = if !class_loader_type.is_null() {
161                let class_loader_type_str = JavaLangString::to_rust_string(jvm, &class_loader_type).await?;
162                jvm.new_class(&class_loader_type_str, "(Ljava/lang/ClassLoader;)V", (url_class_loader,))
163                    .await?
164            } else {
165                url_class_loader
166            };
167
168            jvm.put_static_field(
169                "java/lang/ClassLoader",
170                "systemClassLoader",
171                "Ljava/lang/ClassLoader;",
172                system_class_loader.clone(),
173            )
174            .await?;
175
176            return Ok(system_class_loader.into());
177        }
178
179        Ok(system_class_loader)
180    }
181
182    async fn load_class(
183        jvm: &Jvm,
184        runtime: &mut RuntimeContext,
185        this: ClassInstanceRef<Self>,
186        name: ClassInstanceRef<String>,
187    ) -> Result<ClassInstanceRef<Class>> {
188        tracing::debug!("java.lang.ClassLoader::loadClass({this:?}, {name:?})");
189
190        let class: ClassInstanceRef<Class> = jvm
191            .invoke_virtual(
192                &this,
193                "java/lang/ClassLoader",
194                "findLoadedClass",
195                "(Ljava/lang/String;)Ljava/lang/Class;",
196                (name.clone(),),
197            )
198            .await?;
199
200        if !class.is_null() {
201            return Ok(class);
202        }
203
204        let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
205        let internal_name = name_str.replace('.', "/");
206
207        if let Some(element_type_name) = internal_name.strip_prefix('[') {
208            let ultimate_element_type = name_str.trim_start_matches('[');
209            let defining_loader = if let Some(element_class_name) = ultimate_element_type.strip_prefix('L').and_then(|name| name.strip_suffix(';')) {
210                let element_class_name = JavaLangString::from_rust_string(jvm, element_class_name).await?;
211                let element_class: ClassInstanceRef<Class> = jvm
212                    .invoke_virtual(
213                        &this,
214                        "java/lang/ClassLoader",
215                        "loadClass",
216                        "(Ljava/lang/String;)Ljava/lang/Class;",
217                        (element_class_name,),
218                    )
219                    .await?;
220                jvm.get_field(&element_class, "classLoader", "Ljava/lang/ClassLoader;").await?
221            } else {
222                None
223            };
224
225            let class = runtime.define_array_class(jvm, element_type_name).await?;
226            let java_class = jvm.register_class(class, defining_loader).await?;
227
228            return Ok(java_class.into());
229        }
230
231        let parent: ClassInstanceRef<Self> = jvm.get_field(&this, "parent", "Ljava/lang/ClassLoader;").await?;
232        let class: ClassInstanceRef<Class> = if !parent.is_null() {
233            jvm.invoke_virtual(
234                &parent,
235                "java/lang/ClassLoader",
236                "loadClass",
237                "(Ljava/lang/String;)Ljava/lang/Class;",
238                (name.clone(),),
239            )
240            .await?
241        } else {
242            jvm.load_bootstrap_class(&internal_name).await?.into()
243        };
244
245        if !class.is_null() {
246            return Ok(class);
247        }
248
249        let class = jvm
250            .invoke_virtual(
251                &this,
252                "java/lang/ClassLoader",
253                "findClass",
254                "(Ljava/lang/String;)Ljava/lang/Class;",
255                (name,),
256            )
257            .await?;
258
259        Ok(class)
260    }
261
262    async fn find_class(
263        jvm: &Jvm,
264        _: &mut RuntimeContext,
265        this: ClassInstanceRef<Self>,
266        name: ClassInstanceRef<String>,
267    ) -> Result<ClassInstanceRef<Class>> {
268        tracing::debug!("java.lang.ClassLoader::findClass({this:?}, {name:?})");
269
270        Err(jvm.exception("java/lang/ClassNotFoundException", "class not found").await)
271    }
272
273    async fn find_loaded_class(
274        jvm: &Jvm,
275        _: &mut RuntimeContext,
276        this: ClassInstanceRef<Self>,
277        name: ClassInstanceRef<String>,
278    ) -> Result<ClassInstanceRef<Class>> {
279        tracing::debug!("java.lang.ClassLoader::findLoadedClass({this:?}, {name:?})");
280
281        let internal_name = JavaLangString::to_rust_string(jvm, &name).await?.replace('.', "/");
282        if !jvm.has_class(&internal_name) {
283            return Ok(None.into());
284        }
285
286        let class = jvm.resolve_class(&internal_name).await?;
287
288        Ok(class.java_class().into())
289    }
290
291    async fn get_resource(
292        jvm: &Jvm,
293        _: &mut RuntimeContext,
294        this: ClassInstanceRef<Self>,
295        name: ClassInstanceRef<String>,
296    ) -> Result<ClassInstanceRef<URL>> {
297        tracing::debug!("java.lang.ClassLoader::getResource({this:?})");
298
299        let parent: ClassInstanceRef<Self> = jvm.get_field(&this, "parent", "Ljava/lang/ClassLoader;").await?;
300
301        let result: ClassInstanceRef<URL> = if !parent.is_null() {
302            jvm.invoke_virtual(
303                &parent,
304                "java/lang/ClassLoader",
305                "getResource",
306                "(Ljava/lang/String;)Ljava/net/URL;",
307                (name.clone(),),
308            )
309            .await?
310        } else {
311            None.into()
312        };
313
314        if !result.is_null() {
315            return Ok(result);
316        }
317
318        let result = jvm
319            .invoke_virtual(
320                &this,
321                "java/lang/ClassLoader",
322                "findResource",
323                "(Ljava/lang/String;)Ljava/net/URL;",
324                (name,),
325            )
326            .await?;
327
328        Ok(result)
329    }
330
331    async fn get_resource_as_stream(
332        jvm: &Jvm,
333        _: &mut RuntimeContext,
334        this: ClassInstanceRef<Self>,
335        name: ClassInstanceRef<String>,
336    ) -> Result<ClassInstanceRef<URL>> {
337        tracing::debug!("java.lang.ClassLoader::getResourceAsStream({this:?})");
338
339        let resource_url: ClassInstanceRef<URL> = jvm
340            .invoke_virtual(
341                &this,
342                "java/lang/ClassLoader",
343                "getResource",
344                "(Ljava/lang/String;)Ljava/net/URL;",
345                (name.clone(),),
346            )
347            .await?;
348
349        if resource_url.is_null() {
350            return Ok(None.into());
351        }
352
353        let stream = jvm
354            .invoke_virtual(&resource_url, "java/net/URL", "openStream", "()Ljava/io/InputStream;", ())
355            .await?;
356
357        Ok(stream)
358    }
359
360    async fn find_resource(
361        _: &Jvm,
362        _: &mut RuntimeContext,
363        this: ClassInstanceRef<Self>,
364        _: ClassInstanceRef<String>,
365    ) -> Result<ClassInstanceRef<URL>> {
366        tracing::debug!("java.lang.ClassLoader::findResource({this:?})");
367
368        Ok(None.into())
369    }
370
371    async fn define_class(
372        jvm: &Jvm,
373        runtime: &mut RuntimeContext,
374        this: ClassInstanceRef<Self>,
375        name: ClassInstanceRef<String>,
376        bytes: ClassInstanceRef<Array<i8>>,
377        offset: i32,
378        length: i32,
379    ) -> Result<ClassInstanceRef<Class>> {
380        tracing::debug!("java.lang.ClassLoader::defineClass({this:?}, {name:?}, {bytes:?}, {offset:?}, {length:?})");
381
382        if bytes.is_null() {
383            return Err(jvm.exception("java/lang/NullPointerException", "class bytes").await);
384        }
385        let array_length = jvm.array_length(&bytes).await?;
386        if offset < 0 || length < 0 || (offset as usize).checked_add(length as usize).is_none_or(|end| end > array_length) {
387            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid class byte range").await);
388        }
389
390        let mut data = vec![0; length as usize];
391        jvm.array_raw_buffer(&bytes).await?.read(offset as _, &mut data)?;
392
393        let class = runtime.define_class(jvm, &data).await?;
394        let java_class = jvm.register_class(class, Some(this.into())).await?;
395
396        Ok(java_class.into())
397    }
398}