use alloc::{format, string::String as RustString, vec};
use jvm::{
ClassInstanceRef, Jvm, Result,
runtime::{JavaLangClass, JavaLangString},
};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use crate::{
RuntimeClassProto, RuntimeContext,
classes::java::lang::{Object, String},
};
pub struct Double;
impl Double {
pub fn as_proto() -> RuntimeClassProto {
RuntimeClassProto {
name: "java/lang/Double",
parent_class: Some("java/lang/Number"),
interfaces: vec!["java/lang/Comparable"],
methods: vec![
JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
JavaMethodProto::new("<init>", "(D)V", Self::init, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_string, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"parseDouble",
"(Ljava/lang/String;)D",
Self::parse_double,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new(
"valueOf",
"(D)Ljava/lang/Double;",
Self::value_of,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new(
"valueOf",
"(Ljava/lang/String;)Ljava/lang/Double;",
Self::value_of_string,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new("byteValue", "()B", Self::byte_value, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("shortValue", "()S", Self::short_value, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("intValue", "()I", Self::int_value, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("longValue", "()J", Self::long_value, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("floatValue", "()F", Self::float_value, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("doubleValue", "()D", Self::double_value, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"toString",
"(D)Ljava/lang/String;",
Self::to_string_static,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new("isNaN", "()Z", Self::is_nan, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"isNaN",
"(D)Z",
Self::is_nan_static,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new("isInfinite", "()Z", Self::is_infinite, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"isInfinite",
"(D)Z",
Self::is_infinite_static,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new(
"doubleToLongBits",
"(D)J",
Self::double_to_long_bits,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new(
"longBitsToDouble",
"(J)D",
Self::long_bits_to_double,
MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
),
JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("compareTo", "(Ljava/lang/Double;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("compareTo", "(Ljava/lang/Object;)I", Self::compare_to_object, MethodAccessFlags::PUBLIC),
],
fields: vec![
JavaFieldProto::new(
"POSITIVE_INFINITY",
"D",
FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
),
JavaFieldProto::new(
"NEGATIVE_INFINITY",
"D",
FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
),
JavaFieldProto::new("NaN", "D", FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL),
JavaFieldProto::new(
"MAX_VALUE",
"D",
FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
),
JavaFieldProto::new(
"MIN_VALUE",
"D",
FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
),
JavaFieldProto::new(
"TYPE",
"Ljava/lang/Class;",
FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
),
JavaFieldProto::new("value", "D", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
],
access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
}
}
async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
jvm.put_static_field("java/lang/Double", "POSITIVE_INFINITY", "D", f64::INFINITY).await?;
jvm.put_static_field("java/lang/Double", "NEGATIVE_INFINITY", "D", f64::NEG_INFINITY)
.await?;
jvm.put_static_field("java/lang/Double", "NaN", "D", f64::NAN).await?;
jvm.put_static_field("java/lang/Double", "MAX_VALUE", "D", f64::MAX).await?;
jvm.put_static_field("java/lang/Double", "MIN_VALUE", "D", f64::from_bits(1)).await?;
jvm.put_static_field(
"java/lang/Double",
"TYPE",
"Ljava/lang/Class;",
JavaLangClass::from_rust_primitive(jvm, "double").await?,
)
.await
}
async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
jvm.put_field(&mut this, "java/lang/Double", "value", "D", value).await
}
async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
if value.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "value").await);
}
let value = JavaLangString::to_rust_string(jvm, &value).await?;
let value = Self::parse_value(jvm, &value).await?;
let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
jvm.put_field(&mut this, "java/lang/Double", "value", "D", value).await
}
async fn parse_value(jvm: &Jvm, value: &str) -> Result<f64> {
let trimmed = value.trim_matches(|character| character <= '\u{0020}');
let parsed = match trimmed {
"NaN" | "+NaN" | "-NaN" => Some(f64::NAN),
"Infinity" | "+Infinity" => Some(f64::INFINITY),
"-Infinity" => Some(f64::NEG_INFINITY),
_ => {
let number = match trimmed.as_bytes().last() {
Some(b'f' | b'F' | b'd' | b'D') => &trimmed[..trimmed.len() - 1],
_ => trimmed,
};
let bytes = number.as_bytes();
let mut index = 0;
if matches!(bytes.first(), Some(b'+' | b'-')) {
index += 1;
}
let mut digits = 0;
while index < bytes.len() && bytes[index].is_ascii_digit() {
index += 1;
digits += 1;
}
if index < bytes.len() && bytes[index] == b'.' {
index += 1;
while index < bytes.len() && bytes[index].is_ascii_digit() {
index += 1;
digits += 1;
}
}
if digits == 0 {
None
} else {
if index < bytes.len() && matches!(bytes[index], b'e' | b'E') {
index += 1;
if index < bytes.len() && matches!(bytes[index], b'+' | b'-') {
index += 1;
}
let exponent_start = index;
while index < bytes.len() && bytes[index].is_ascii_digit() {
index += 1;
}
if exponent_start == index {
index = bytes.len() + 1;
}
}
if index == bytes.len() { number.parse::<f64>().ok() } else { None }
}
}
};
match parsed {
Some(value) => Ok(value),
None => Err(jvm
.exception("java/lang/NumberFormatException", &format!("For input string: \"{value}\""))
.await),
}
}
async fn parse_double(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<f64> {
if value.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "value").await);
}
let value = JavaLangString::to_rust_string(jvm, &value).await?;
Self::parse_value(jvm, &value).await
}
async fn value_of_string(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
if value.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "value").await);
}
let value = JavaLangString::to_rust_string(jvm, &value).await?;
let value = Self::parse_value(jvm, &value).await?;
Ok(jvm.new_class("java/lang/Double", "(D)V", (value,)).await?.into())
}
async fn value_of(jvm: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<ClassInstanceRef<Self>> {
Ok(jvm.new_class("java/lang/Double", "(D)V", (value,)).await?.into())
}
async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i8> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
Ok((value as i32) as i8)
}
async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i16> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
Ok((value as i32) as i16)
}
async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
Ok(value as i32)
}
async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
Ok(value as i64)
}
async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
Ok(value as f32)
}
async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
jvm.get_field(&this, "java/lang/Double", "value", "D").await
}
fn format_value(value: f64) -> RustString {
if value.is_nan() {
return "NaN".into();
}
if value == f64::INFINITY {
return "Infinity".into();
}
if value == f64::NEG_INFINITY {
return "-Infinity".into();
}
if value.to_bits() == 1 {
return "4.9E-324".into();
}
if value.to_bits() == 0x8000_0000_0000_0001 {
return "-4.9E-324".into();
}
let magnitude = value.abs();
let mut result = if value != 0.0 && !(0.001..10_000_000.0).contains(&magnitude) {
format!("{value:e}")
} else {
format!("{value}")
};
if let Some(exponent_index) = result.find('e') {
let exponent = result.split_off(exponent_index + 1);
result.pop();
if !result.contains('.') {
result.push_str(".0");
}
result.push('E');
result.push_str(exponent.strip_prefix('+').unwrap_or(&exponent));
} else if !result.contains('.') {
result.push_str(".0");
}
result
}
async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value)).await?.into())
}
async fn to_string_static(jvm: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<ClassInstanceRef<String>> {
Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value)).await?.into())
}
async fn is_nan(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
Ok(value.is_nan())
}
async fn is_nan_static(_: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<bool> {
Ok(value.is_nan())
}
async fn is_infinite(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
Ok(value.is_infinite())
}
async fn is_infinite_static(_: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<bool> {
Ok(value.is_infinite())
}
async fn double_to_long_bits(_: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<i64> {
Ok(if value.is_nan() { 0x7ff8_0000_0000_0000 } else { value.to_bits() as i64 })
}
async fn long_bits_to_double(_: &Jvm, _: &mut RuntimeContext, bits: i64) -> Result<f64> {
Ok(f64::from_bits(bits as u64))
}
async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
let bits = if value.is_nan() { 0x7ff8_0000_0000_0000 } else { value.to_bits() };
Ok((bits ^ (bits >> 32)) as i32)
}
async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
if other.is_null() || !jvm.is_instance(&**other, "java/lang/Double") {
return Ok(false);
}
let left: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
let right: f64 = jvm.invoke_virtual(&other, "java/lang/Double", "doubleValue", "()D", ()).await?;
let left_bits = if left.is_nan() { 0x7ff8_0000_0000_0000 } else { left.to_bits() as i64 };
let right_bits = if right.is_nan() { 0x7ff8_0000_0000_0000 } else { right.to_bits() as i64 };
Ok(left_bits == right_bits)
}
async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
if other.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "other").await);
}
let left: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
let right: f64 = jvm.invoke_virtual(&other, "java/lang/Double", "doubleValue", "()D", ()).await?;
if left < right {
return Ok(-1);
}
if left > right {
return Ok(1);
}
let left_bits = if left.is_nan() { 0x7ff8_0000_0000_0000 } else { left.to_bits() as i64 };
let right_bits = if right.is_nan() { 0x7ff8_0000_0000_0000 } else { right.to_bits() as i64 };
Ok(left_bits.cmp(&right_bits) as i32)
}
async fn compare_to_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
if other.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "other").await);
}
if !jvm.is_instance(&**other, "java/lang/Double") {
return Err(jvm.exception("java/lang/ClassCastException", "not Double").await);
}
let other = ClassInstanceRef::<Self>::from(other.instance);
let left: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
let right: f64 = jvm.invoke_virtual(&other, "java/lang/Double", "doubleValue", "()D", ()).await?;
if left < right {
return Ok(-1);
}
if left > right {
return Ok(1);
}
let left_bits = if left.is_nan() { 0x7ff8_0000_0000_0000 } else { left.to_bits() as i64 };
let right_bits = if right.is_nan() { 0x7ff8_0000_0000_0000 } else { right.to_bits() as i64 };
Ok(left_bits.cmp(&right_bits) as i32)
}
}