Skip to main content

rustjava_runtime/classes/java/lang/
float.rs

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
15// public final class java.lang.Float
16pub 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, "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, "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, "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, "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}