1use alloc::{format, string::String as RustString, vec};
2
3use jvm::{
4 ClassInstanceRef, Jvm, Result,
5 runtime::{JavaLangClass, JavaLangString},
6};
7use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
8use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
9
10use crate::{
11 RuntimeClassProto, RuntimeContext,
12 classes::java::lang::{Object, String},
13};
14
15pub struct Float;
17
18impl Float {
19 pub fn as_proto() -> RuntimeClassProto {
20 RuntimeClassProto {
21 name: "java/lang/Float",
22 parent_class: Some("java/lang/Number"),
23 interfaces: vec!["java/lang/Comparable"],
24 methods: vec![
25 JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
26 JavaMethodProto::new("<init>", "(F)V", Self::init, MethodAccessFlags::PUBLIC),
27 JavaMethodProto::new("<init>", "(D)V", Self::init_double, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_string, MethodAccessFlags::PUBLIC),
29 JavaMethodProto::new(
30 "parseFloat",
31 "(Ljava/lang/String;)F",
32 Self::parse_float,
33 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
34 ),
35 JavaMethodProto::new(
36 "valueOf",
37 "(F)Ljava/lang/Float;",
38 Self::value_of,
39 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
40 ),
41 JavaMethodProto::new(
42 "valueOf",
43 "(Ljava/lang/String;)Ljava/lang/Float;",
44 Self::value_of_string,
45 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
46 ),
47 JavaMethodProto::new("byteValue", "()B", Self::byte_value, MethodAccessFlags::PUBLIC),
48 JavaMethodProto::new("shortValue", "()S", Self::short_value, MethodAccessFlags::PUBLIC),
49 JavaMethodProto::new("intValue", "()I", Self::int_value, MethodAccessFlags::PUBLIC),
50 JavaMethodProto::new("longValue", "()J", Self::long_value, MethodAccessFlags::PUBLIC),
51 JavaMethodProto::new("floatValue", "()F", Self::float_value, MethodAccessFlags::PUBLIC),
52 JavaMethodProto::new("doubleValue", "()D", Self::double_value, MethodAccessFlags::PUBLIC),
53 JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
54 JavaMethodProto::new(
55 "toString",
56 "(F)Ljava/lang/String;",
57 Self::to_string_static,
58 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
59 ),
60 JavaMethodProto::new("isNaN", "()Z", Self::is_nan, MethodAccessFlags::PUBLIC),
61 JavaMethodProto::new(
62 "isNaN",
63 "(F)Z",
64 Self::is_nan_static,
65 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
66 ),
67 JavaMethodProto::new("isInfinite", "()Z", Self::is_infinite, MethodAccessFlags::PUBLIC),
68 JavaMethodProto::new(
69 "isInfinite",
70 "(F)Z",
71 Self::is_infinite_static,
72 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
73 ),
74 JavaMethodProto::new(
75 "floatToIntBits",
76 "(F)I",
77 Self::float_to_int_bits,
78 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
79 ),
80 JavaMethodProto::new(
81 "intBitsToFloat",
82 "(I)F",
83 Self::int_bits_to_float,
84 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
85 ),
86 JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
87 JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
88 JavaMethodProto::new("compareTo", "(Ljava/lang/Float;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
89 JavaMethodProto::new("compareTo", "(Ljava/lang/Object;)I", Self::compare_to_object, MethodAccessFlags::PUBLIC),
90 ],
91 fields: vec![
92 JavaFieldProto::new(
93 "POSITIVE_INFINITY",
94 "F",
95 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
96 ),
97 JavaFieldProto::new(
98 "NEGATIVE_INFINITY",
99 "F",
100 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
101 ),
102 JavaFieldProto::new("NaN", "F", FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL),
103 JavaFieldProto::new(
104 "MAX_VALUE",
105 "F",
106 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
107 ),
108 JavaFieldProto::new(
109 "MIN_VALUE",
110 "F",
111 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
112 ),
113 JavaFieldProto::new(
114 "TYPE",
115 "Ljava/lang/Class;",
116 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
117 ),
118 JavaFieldProto::new("value", "F", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
119 ],
120 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
121 }
122 }
123
124 async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
125 jvm.put_static_field("java/lang/Float", "POSITIVE_INFINITY", "F", f32::INFINITY).await?;
126 jvm.put_static_field("java/lang/Float", "NEGATIVE_INFINITY", "F", f32::NEG_INFINITY)
127 .await?;
128 jvm.put_static_field("java/lang/Float", "NaN", "F", f32::NAN).await?;
129 jvm.put_static_field("java/lang/Float", "MAX_VALUE", "F", f32::MAX).await?;
130 jvm.put_static_field("java/lang/Float", "MIN_VALUE", "F", f32::from_bits(1)).await?;
131 jvm.put_static_field(
132 "java/lang/Float",
133 "TYPE",
134 "Ljava/lang/Class;",
135 JavaLangClass::from_rust_primitive(jvm, "float").await?,
136 )
137 .await
138 }
139
140 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
141 let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
142 jvm.put_field(&mut this, "java/lang/Float", "value", "F", value).await
143 }
144
145 async fn init_double(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
146 let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
147 jvm.put_field(&mut this, "java/lang/Float", "value", "F", value as f32).await
148 }
149
150 async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
151 if value.is_null() {
152 return Err(jvm.exception("java/lang/NullPointerException", "value").await);
153 }
154 let value = JavaLangString::to_rust_string(jvm, &value).await?;
155 let value = Self::parse_value(jvm, &value).await?;
156 let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
157 jvm.put_field(&mut this, "java/lang/Float", "value", "F", value).await
158 }
159
160 async fn parse_value(jvm: &Jvm, value: &str) -> Result<f32> {
161 let trimmed = value.trim_matches(|character| character <= '\u{0020}');
162 let parsed = match trimmed {
163 "NaN" | "+NaN" | "-NaN" => Some(f32::NAN),
164 "Infinity" | "+Infinity" => Some(f32::INFINITY),
165 "-Infinity" => Some(f32::NEG_INFINITY),
166 _ => {
167 let number = match trimmed.as_bytes().last() {
168 Some(b'f' | b'F' | b'd' | b'D') => &trimmed[..trimmed.len() - 1],
169 _ => trimmed,
170 };
171 let bytes = number.as_bytes();
172 let mut index = 0;
173 if matches!(bytes.first(), Some(b'+' | b'-')) {
174 index += 1;
175 }
176
177 let mut digits = 0;
178 while index < bytes.len() && bytes[index].is_ascii_digit() {
179 index += 1;
180 digits += 1;
181 }
182 if index < bytes.len() && bytes[index] == b'.' {
183 index += 1;
184 while index < bytes.len() && bytes[index].is_ascii_digit() {
185 index += 1;
186 digits += 1;
187 }
188 }
189
190 if digits == 0 {
191 None
192 } else {
193 if index < bytes.len() && matches!(bytes[index], b'e' | b'E') {
194 index += 1;
195 if index < bytes.len() && matches!(bytes[index], b'+' | b'-') {
196 index += 1;
197 }
198 let exponent_start = index;
199 while index < bytes.len() && bytes[index].is_ascii_digit() {
200 index += 1;
201 }
202 if exponent_start == index {
203 index = bytes.len() + 1;
204 }
205 }
206 if index == bytes.len() { number.parse::<f32>().ok() } else { None }
207 }
208 }
209 };
210
211 match parsed {
212 Some(value) => Ok(value),
213 None => Err(jvm
214 .exception("java/lang/NumberFormatException", &format!("For input string: \"{value}\""))
215 .await),
216 }
217 }
218
219 async fn parse_float(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<f32> {
220 if value.is_null() {
221 return Err(jvm.exception("java/lang/NullPointerException", "value").await);
222 }
223 let value = JavaLangString::to_rust_string(jvm, &value).await?;
224 Self::parse_value(jvm, &value).await
225 }
226
227 async fn value_of_string(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
228 if value.is_null() {
229 return Err(jvm.exception("java/lang/NullPointerException", "value").await);
230 }
231 let value = JavaLangString::to_rust_string(jvm, &value).await?;
232 let value = Self::parse_value(jvm, &value).await?;
233 Ok(jvm.new_class("java/lang/Float", "(F)V", (value,)).await?.into())
234 }
235
236 async fn value_of(jvm: &Jvm, _: &mut RuntimeContext, value: f32) -> Result<ClassInstanceRef<Self>> {
237 Ok(jvm.new_class("java/lang/Float", "(F)V", (value,)).await?.into())
238 }
239
240 async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i8> {
241 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
242 Ok((value as i32) as i8)
243 }
244
245 async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i16> {
246 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
247 Ok((value as i32) as i16)
248 }
249
250 async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
251 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
252 Ok(value as i32)
253 }
254
255 async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
256 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
257 Ok(value as i64)
258 }
259
260 async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
261 jvm.get_field(&this, "java/lang/Float", "value", "F").await
262 }
263
264 async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
265 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
266 Ok(value as f64)
267 }
268
269 fn format_value(value: f32) -> RustString {
270 if value.is_nan() {
271 return "NaN".into();
272 }
273 if value == f32::INFINITY {
274 return "Infinity".into();
275 }
276 if value == f32::NEG_INFINITY {
277 return "-Infinity".into();
278 }
279 if value.to_bits() == 1 {
280 return "1.4E-45".into();
281 }
282 if value.to_bits() == 0x8000_0001 {
283 return "-1.4E-45".into();
284 }
285
286 let magnitude = value.abs();
287 let mut result = if value != 0.0 && !(0.001..10_000_000.0).contains(&magnitude) {
288 format!("{value:e}")
289 } else {
290 format!("{value}")
291 };
292 if let Some(exponent_index) = result.find('e') {
293 let exponent = result.split_off(exponent_index + 1);
294 result.pop();
295 if !result.contains('.') {
296 result.push_str(".0");
297 }
298 result.push('E');
299 result.push_str(exponent.strip_prefix('+').unwrap_or(&exponent));
300 } else if !result.contains('.') {
301 result.push_str(".0");
302 }
303 result
304 }
305
306 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
307 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
308 Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value)).await?.into())
309 }
310
311 async fn to_string_static(jvm: &Jvm, _: &mut RuntimeContext, value: f32) -> Result<ClassInstanceRef<String>> {
312 Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value)).await?.into())
313 }
314
315 async fn is_nan(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
316 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
317 Ok(value.is_nan())
318 }
319
320 async fn is_nan_static(_: &Jvm, _: &mut RuntimeContext, value: f32) -> Result<bool> {
321 Ok(value.is_nan())
322 }
323
324 async fn is_infinite(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
325 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
326 Ok(value.is_infinite())
327 }
328
329 async fn is_infinite_static(_: &Jvm, _: &mut RuntimeContext, value: f32) -> Result<bool> {
330 Ok(value.is_infinite())
331 }
332
333 async fn float_to_int_bits(_: &Jvm, _: &mut RuntimeContext, value: f32) -> Result<i32> {
334 Ok(if value.is_nan() { 0x7fc0_0000 } else { value.to_bits() as i32 })
335 }
336
337 async fn int_bits_to_float(_: &Jvm, _: &mut RuntimeContext, bits: i32) -> Result<f32> {
338 Ok(f32::from_bits(bits as u32))
339 }
340
341 async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
342 let value: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
343 Ok(if value.is_nan() { 0x7fc0_0000 } else { value.to_bits() as i32 })
344 }
345
346 async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
347 if other.is_null() || !jvm.is_instance(&**other, "java/lang/Float") {
348 return Ok(false);
349 }
350 let left: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
351 let right: f32 = jvm.invoke_virtual(&other, "java/lang/Float", "floatValue", "()F", ()).await?;
352 let left_bits = if left.is_nan() { 0x7fc0_0000 } else { left.to_bits() as i32 };
353 let right_bits = if right.is_nan() { 0x7fc0_0000 } else { right.to_bits() as i32 };
354 Ok(left_bits == right_bits)
355 }
356
357 async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
358 if other.is_null() {
359 return Err(jvm.exception("java/lang/NullPointerException", "other").await);
360 }
361 let left: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
362 let right: f32 = jvm.invoke_virtual(&other, "java/lang/Float", "floatValue", "()F", ()).await?;
363 if left < right {
364 return Ok(-1);
365 }
366 if left > right {
367 return Ok(1);
368 }
369 let left_bits = if left.is_nan() { 0x7fc0_0000 } else { left.to_bits() as i32 };
370 let right_bits = if right.is_nan() { 0x7fc0_0000 } else { right.to_bits() as i32 };
371 Ok(left_bits.cmp(&right_bits) as i32)
372 }
373
374 async fn compare_to_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
375 if other.is_null() {
376 return Err(jvm.exception("java/lang/NullPointerException", "other").await);
377 }
378 if !jvm.is_instance(&**other, "java/lang/Float") {
379 return Err(jvm.exception("java/lang/ClassCastException", "not Float").await);
380 }
381 let other = ClassInstanceRef::<Self>::from(other.instance);
382 let left: f32 = jvm.invoke_virtual(&this, "java/lang/Float", "floatValue", "()F", ()).await?;
383 let right: f32 = jvm.invoke_virtual(&other, "java/lang/Float", "floatValue", "()F", ()).await?;
384 if left < right {
385 return Ok(-1);
386 }
387 if left > right {
388 return Ok(1);
389 }
390 let left_bits = if left.is_nan() { 0x7fc0_0000 } else { left.to_bits() as i32 };
391 let right_bits = if right.is_nan() { 0x7fc0_0000 } else { right.to_bits() as i32 };
392 Ok(left_bits.cmp(&right_bits) as i32)
393 }
394}