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
15pub 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, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;", parent)
89 .await?;
90
91 Ok(())
92 }
93
94 async fn get_system_class_loader(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
95 tracing::debug!("java.lang.ClassLoader::getSystemClassLoader()");
96
97 let system_class_loader: ClassInstanceRef<Self> = jvm
98 .get_static_field("java/lang/ClassLoader", "systemClassLoader", "Ljava/lang/ClassLoader;")
99 .await?;
100
101 if system_class_loader.is_null() {
102 let class_path: ClassInstanceRef<String> = jvm
103 .invoke_static(
104 "java/lang/System",
105 "getProperty",
106 "(Ljava/lang/String;)Ljava/lang/String;",
107 (JavaLangString::from_rust_string(jvm, "java.class.path").await?,),
108 )
109 .await?;
110
111 let (class_paths, urls) = if !class_path.is_null() {
112 let class_path = JavaLangString::to_rust_string(jvm, &class_path).await?;
113 let path_separator: ClassInstanceRef<String> = jvm.get_static_field("java/io/File", "pathSeparator", "Ljava/lang/String;").await?;
114 let path_separator = JavaLangString::to_rust_string(jvm, &path_separator).await?;
115
116 let mut class_paths = Vec::new();
117 let mut urls = Vec::new();
118 for path in class_path.split(path_separator.as_str()) {
119 let path = JavaLangString::from_rust_string(jvm, path).await?;
120 class_paths.push(path.clone());
121 let path = jvm
122 .invoke_static("org/rustjava/net/URLPath", "encode", "(Ljava/lang/String;)Ljava/lang/String;", (path,))
123 .await?;
124 let path = JavaLangString::to_rust_string(jvm, &path).await?;
125 let path = JavaLangString::from_rust_string(jvm, &format!("file:{path}")).await?;
126 let url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (path,)).await?;
127 urls.push(url);
128 }
129
130 (class_paths, urls)
131 } else {
132 (Vec::new(), Vec::new())
133 };
134
135 let mut class_path_array = jvm.instantiate_array("Ljava/lang/String;", class_paths.len()).await?;
136 jvm.store_array(&mut class_path_array, 0, class_paths).await?;
137 let rustjar_class_loader = jvm
138 .new_class(
139 "org/rustjava/lang/RustJarClassLoader",
140 "([Ljava/lang/String;Ljava/lang/ClassLoader;)V",
141 (class_path_array, None),
142 )
143 .await?;
144
145 let mut url_array = jvm.instantiate_array("Ljava/net/URL;", urls.len()).await?;
146 jvm.store_array(&mut url_array, 0, urls).await?;
147
148 let url_class_loader = jvm
149 .new_class(
150 "java/net/URLClassLoader",
151 "([Ljava/net/URL;Ljava/lang/ClassLoader;)V",
152 (url_array, rustjar_class_loader),
153 )
154 .await?;
155
156 let class_loader_type: ClassInstanceRef<String> = jvm
157 .invoke_static(
158 "java/lang/System",
159 "getProperty",
160 "(Ljava/lang/String;)Ljava/lang/String;",
161 (JavaLangString::from_rust_string(jvm, "java.system.class.loader").await?,),
162 )
163 .await?;
164
165 let system_class_loader = if !class_loader_type.is_null() {
166 let class_loader_type_str = JavaLangString::to_rust_string(jvm, &class_loader_type).await?;
167 jvm.new_class(&class_loader_type_str, "(Ljava/lang/ClassLoader;)V", (url_class_loader,))
168 .await?
169 } else {
170 url_class_loader
171 };
172
173 jvm.put_static_field(
174 "java/lang/ClassLoader",
175 "systemClassLoader",
176 "Ljava/lang/ClassLoader;",
177 system_class_loader.clone(),
178 )
179 .await?;
180
181 return Ok(system_class_loader.into());
182 }
183
184 Ok(system_class_loader)
185 }
186
187 async fn load_class(
188 jvm: &Jvm,
189 runtime: &mut RuntimeContext,
190 this: ClassInstanceRef<Self>,
191 name: ClassInstanceRef<String>,
192 ) -> Result<ClassInstanceRef<Class>> {
193 tracing::debug!("java.lang.ClassLoader::loadClass({this:?}, {name:?})");
194
195 if name.is_null() {
196 return Err(jvm.exception("java/lang/NullPointerException", "name is null").await);
197 }
198
199 let class: ClassInstanceRef<Class> = jvm
200 .invoke_virtual(
201 &this,
202 "java/lang/ClassLoader",
203 "findLoadedClass",
204 "(Ljava/lang/String;)Ljava/lang/Class;",
205 (name.clone(),),
206 )
207 .await?;
208
209 if !class.is_null() {
210 return Ok(class);
211 }
212
213 let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
214 let internal_name = name_str.replace('.', "/");
215
216 if let Some(element_type_name) = internal_name.strip_prefix('[') {
217 let ultimate_element_type = name_str.trim_start_matches('[');
218 let defining_loader = if let Some(element_class_name) = ultimate_element_type.strip_prefix('L').and_then(|name| name.strip_suffix(';')) {
219 let element_class_name = JavaLangString::from_rust_string(jvm, element_class_name).await?;
220 let element_class: ClassInstanceRef<Class> = jvm
221 .invoke_virtual(
222 &this,
223 "java/lang/ClassLoader",
224 "loadClass",
225 "(Ljava/lang/String;)Ljava/lang/Class;",
226 (element_class_name,),
227 )
228 .await?;
229 jvm.get_field(&element_class, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;")
230 .await?
231 } else {
232 None
233 };
234
235 let class = runtime.define_array_class(jvm, element_type_name).await?;
236 let java_class = jvm.register_class(class, defining_loader).await?;
237
238 return Ok(java_class.into());
239 }
240
241 let parent: ClassInstanceRef<Self> = jvm.get_field(&this, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;").await?;
242 let class: ClassInstanceRef<Class> = if !parent.is_null() {
243 jvm.invoke_virtual(
244 &parent,
245 "java/lang/ClassLoader",
246 "loadClass",
247 "(Ljava/lang/String;)Ljava/lang/Class;",
248 (name.clone(),),
249 )
250 .await?
251 } else {
252 jvm.load_bootstrap_class(&internal_name).await?.into()
253 };
254
255 if !class.is_null() {
256 return Ok(class);
257 }
258
259 let class = jvm
260 .invoke_virtual(
261 &this,
262 "java/lang/ClassLoader",
263 "findClass",
264 "(Ljava/lang/String;)Ljava/lang/Class;",
265 (name,),
266 )
267 .await?;
268
269 Ok(class)
270 }
271
272 async fn find_class(
273 jvm: &Jvm,
274 _: &mut RuntimeContext,
275 this: ClassInstanceRef<Self>,
276 name: ClassInstanceRef<String>,
277 ) -> Result<ClassInstanceRef<Class>> {
278 tracing::debug!("java.lang.ClassLoader::findClass({this:?}, {name:?})");
279
280 Err(jvm.exception("java/lang/ClassNotFoundException", "class not found").await)
281 }
282
283 async fn find_loaded_class(
284 jvm: &Jvm,
285 _: &mut RuntimeContext,
286 this: ClassInstanceRef<Self>,
287 name: ClassInstanceRef<String>,
288 ) -> Result<ClassInstanceRef<Class>> {
289 tracing::debug!("java.lang.ClassLoader::findLoadedClass({this:?}, {name:?})");
290
291 if name.is_null() {
292 return Ok(None.into());
293 }
294
295 let internal_name = JavaLangString::to_rust_string(jvm, &name).await?.replace('.', "/");
296 if !jvm.has_class(&internal_name) {
297 return Ok(None.into());
298 }
299
300 let class = jvm.resolve_class(&internal_name).await?;
301
302 Ok(class.java_class().into())
303 }
304
305 async fn get_resource(
306 jvm: &Jvm,
307 _: &mut RuntimeContext,
308 this: ClassInstanceRef<Self>,
309 name: ClassInstanceRef<String>,
310 ) -> Result<ClassInstanceRef<URL>> {
311 tracing::debug!("java.lang.ClassLoader::getResource({this:?})");
312
313 if name.is_null() {
314 return Err(jvm.exception("java/lang/NullPointerException", "name is null").await);
315 }
316
317 let parent: ClassInstanceRef<Self> = jvm.get_field(&this, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;").await?;
318
319 let result: ClassInstanceRef<URL> = if !parent.is_null() {
320 jvm.invoke_virtual(
321 &parent,
322 "java/lang/ClassLoader",
323 "getResource",
324 "(Ljava/lang/String;)Ljava/net/URL;",
325 (name.clone(),),
326 )
327 .await?
328 } else {
329 None.into()
330 };
331
332 if !result.is_null() {
333 return Ok(result);
334 }
335
336 let result = jvm
337 .invoke_virtual(
338 &this,
339 "java/lang/ClassLoader",
340 "findResource",
341 "(Ljava/lang/String;)Ljava/net/URL;",
342 (name,),
343 )
344 .await?;
345
346 Ok(result)
347 }
348
349 async fn get_resource_as_stream(
350 jvm: &Jvm,
351 _: &mut RuntimeContext,
352 this: ClassInstanceRef<Self>,
353 name: ClassInstanceRef<String>,
354 ) -> Result<ClassInstanceRef<URL>> {
355 tracing::debug!("java.lang.ClassLoader::getResourceAsStream({this:?})");
356
357 let resource_url: ClassInstanceRef<URL> = jvm
358 .invoke_virtual(
359 &this,
360 "java/lang/ClassLoader",
361 "getResource",
362 "(Ljava/lang/String;)Ljava/net/URL;",
363 (name.clone(),),
364 )
365 .await?;
366
367 if resource_url.is_null() {
368 return Ok(None.into());
369 }
370
371 let stream = jvm
372 .invoke_virtual(&resource_url, "java/net/URL", "openStream", "()Ljava/io/InputStream;", ())
373 .await?;
374
375 Ok(stream)
376 }
377
378 async fn find_resource(
379 _: &Jvm,
380 _: &mut RuntimeContext,
381 this: ClassInstanceRef<Self>,
382 _: ClassInstanceRef<String>,
383 ) -> Result<ClassInstanceRef<URL>> {
384 tracing::debug!("java.lang.ClassLoader::findResource({this:?})");
385
386 Ok(None.into())
387 }
388
389 async fn define_class(
390 jvm: &Jvm,
391 runtime: &mut RuntimeContext,
392 this: ClassInstanceRef<Self>,
393 name: ClassInstanceRef<String>,
394 bytes: ClassInstanceRef<Array<i8>>,
395 offset: i32,
396 length: i32,
397 ) -> Result<ClassInstanceRef<Class>> {
398 tracing::debug!("java.lang.ClassLoader::defineClass({this:?}, {name:?}, {bytes:?}, {offset:?}, {length:?})");
399
400 if bytes.is_null() {
401 return Err(jvm.exception("java/lang/NullPointerException", "class bytes").await);
402 }
403 let array_length = jvm.array_length(&bytes).await?;
404 if offset < 0 || length < 0 || (offset as usize).checked_add(length as usize).is_none_or(|end| end > array_length) {
405 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid class byte range").await);
406 }
407
408 let mut data = vec![0; length as usize];
409 jvm.array_raw_buffer(&bytes).await?.read(offset as _, &mut data)?;
410
411 let class = runtime.define_class(jvm, &data).await?;
412 let java_class = jvm.register_class(class, Some(this.into())).await?;
413
414 Ok(java_class.into())
415 }
416}