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