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, "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}