1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext};
8
9pub struct Random;
11
12impl Random {
13 pub fn as_proto() -> RuntimeClassProto {
14 RuntimeClassProto {
15 name: "java/util/Random",
16 parent_class: Some("java/lang/Object"),
17 interfaces: vec!["java/io/Serializable"],
18 methods: vec![
19 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
20 JavaMethodProto::new("<init>", "(J)V", Self::init_with_seed, MethodAccessFlags::PUBLIC),
21 JavaMethodProto::new("next", "(I)I", Self::next, MethodAccessFlags::PROTECTED | MethodAccessFlags::SYNCHRONIZED),
22 JavaMethodProto::new("nextBoolean", "()Z", Self::next_boolean, MethodAccessFlags::PUBLIC),
23 JavaMethodProto::new("nextBytes", "([B)V", Self::next_bytes, MethodAccessFlags::PUBLIC),
24 JavaMethodProto::new("nextInt", "()I", Self::next_int, MethodAccessFlags::PUBLIC),
25 JavaMethodProto::new("nextInt", "(I)I", Self::next_int_with_bound, MethodAccessFlags::PUBLIC),
26 JavaMethodProto::new("nextLong", "()J", Self::next_long, MethodAccessFlags::PUBLIC),
27 JavaMethodProto::new("nextFloat", "()F", Self::next_float, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new("nextDouble", "()D", Self::next_double, MethodAccessFlags::PUBLIC),
29 JavaMethodProto::new(
30 "nextGaussian",
31 "()D",
32 Self::next_gaussian,
33 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
34 ),
35 JavaMethodProto::new(
36 "setSeed",
37 "(J)V",
38 Self::set_seed,
39 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
40 ),
41 ],
42 fields: vec![
43 JavaFieldProto::new("seed", "J", FieldAccessFlags::PRIVATE),
44 JavaFieldProto::new("nextNextGaussian", "D", FieldAccessFlags::PRIVATE),
45 JavaFieldProto::new("haveNextNextGaussian", "Z", FieldAccessFlags::PRIVATE),
46 ],
47 access_flags: ClassAccessFlags::PUBLIC,
48 }
49 }
50
51 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
52 tracing::debug!("java.util.Random::<init>({this:?})");
53
54 let default_seed: i64 = jvm.invoke_static("java/lang/System", "currentTimeMillis", "()J", ()).await?;
55 let _: () = jvm.invoke_special(&this, "java/util/Random", "<init>", "(J)V", (default_seed,)).await?;
56
57 Ok(())
58 }
59
60 async fn init_with_seed(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, seed: i64) -> Result<()> {
61 tracing::debug!("java.util.Random::<init>({this:?}, {seed:?})");
62
63 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
64
65 let _: () = jvm.invoke_virtual(&this, "java/util/Random", "setSeed", "(J)V", (seed,)).await?;
66
67 Ok(())
68 }
69
70 async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, bits: i32) -> Result<i32> {
71 tracing::debug!("java.util.Random::next({this:?}, {bits:?})");
72
73 let seed: i64 = jvm.get_field(&this, "java/util/Random", "seed", "J").await?;
74 let next_seed = seed.wrapping_mul(0x5DEECE66D).wrapping_add(0xB) & 0xFFFFFFFFFFFF;
75
76 jvm.put_field(&mut this, "java/util/Random", "seed", "J", next_seed).await?;
77
78 let value = (next_seed as u64).wrapping_shr(((48 - bits) & 63) as u32) as i32;
79
80 Ok(value)
81 }
82
83 async fn next_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
84 tracing::debug!("java.util.Random::nextBoolean({this:?})");
85
86 let value: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (1,)).await?;
87 Ok(value != 0)
88 }
89
90 async fn next_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, mut bytes: ClassInstanceRef<Array<i8>>) -> Result<()> {
91 tracing::debug!("java.util.Random::nextBytes({this:?}, {bytes:?})");
92
93 if bytes.is_null() {
94 return Err(jvm.exception("java/lang/NullPointerException", "bytes is null").await);
95 }
96
97 let length = jvm.array_length(&bytes).await?;
98 let mut index = 0;
99 while index < length {
100 let mut random: i32 = jvm.invoke_virtual(&this, "java/util/Random", "nextInt", "()I", ()).await?;
101 let chunk_length = core::cmp::min(length - index, 4);
102 let mut chunk = alloc::vec::Vec::with_capacity(chunk_length);
103 for _ in 0..chunk_length {
104 chunk.push(random as i8);
105 random >>= 8;
106 }
107 jvm.store_array(&mut bytes, index, chunk).await?;
108 index += chunk_length;
109 }
110
111 Ok(())
112 }
113
114 async fn next_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
115 tracing::debug!("java.util.Random::nextInt({this:?})");
116 jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (32,)).await
117 }
118
119 async fn next_int_with_bound(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, bound: i32) -> Result<i32> {
120 tracing::debug!("java.util.Random::nextInt({this:?}, {bound:?})");
121
122 if bound <= 0 {
123 return Err(jvm.exception("java/lang/IllegalArgumentException", "n must be positive").await);
124 }
125
126 if (bound as u32).is_power_of_two() {
127 let bits: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (31,)).await?;
128 return Ok(((bound as i64 * bits as i64) >> 31) as i32);
129 }
130
131 loop {
132 let bits: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (31,)).await?;
133 let value = bits % bound;
134 if bits.wrapping_sub(value).wrapping_add(bound - 1) >= 0 {
135 return Ok(value);
136 }
137 }
138 }
139
140 async fn next_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
141 tracing::debug!("java.util.Random::nextLong({this:?})");
142
143 let high: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (32,)).await?;
144 let low: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (32,)).await?;
145 Ok((high as i64).wrapping_shl(32).wrapping_add(low as i64))
146 }
147
148 async fn next_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
149 tracing::debug!("java.util.Random::nextFloat({this:?})");
150
151 let bits: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (24,)).await?;
152 Ok(bits as f32 / (1u32 << 24) as f32)
153 }
154
155 async fn next_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
156 tracing::debug!("java.util.Random::nextDouble({this:?})");
157
158 let high: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (26,)).await?;
159 let low: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (27,)).await?;
160 Ok(((high as i64) << 27 | low as i64) as f64 / (1u64 << 53) as f64)
161 }
162
163 async fn next_gaussian(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<f64> {
164 tracing::debug!("java.util.Random::nextGaussian({this:?})");
165
166 let have_next_next_gaussian: bool = jvm.get_field(&this, "java/util/Random", "haveNextNextGaussian", "Z").await?;
167 if have_next_next_gaussian {
168 let next_next_gaussian: f64 = jvm.get_field(&this, "java/util/Random", "nextNextGaussian", "D").await?;
169 jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", false).await?;
170 return Ok(next_next_gaussian);
171 }
172
173 let (first, second, radius_squared) = loop {
174 let first = 2.0 * jvm.invoke_virtual::<_, f64>(&this, "java/util/Random", "nextDouble", "()D", ()).await? - 1.0;
175 let second = 2.0 * jvm.invoke_virtual::<_, f64>(&this, "java/util/Random", "nextDouble", "()D", ()).await? - 1.0;
176 let radius_squared = first * first + second * second;
177 if radius_squared < 1.0 && radius_squared != 0.0 {
178 break (first, second, radius_squared);
179 }
180 };
181 let multiplier = libm::sqrt(-2.0 * libm::log(radius_squared) / radius_squared);
182 jvm.put_field(&mut this, "java/util/Random", "nextNextGaussian", "D", second * multiplier)
183 .await?;
184 jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", true).await?;
185 Ok(first * multiplier)
186 }
187
188 async fn set_seed(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, seed: i64) -> Result<()> {
189 tracing::debug!("java.util.Random::setSeed({this:?}, {seed:?})");
190
191 let seed = (seed ^ 0x5DEECE66D) & ((1 << 48) - 1);
192
193 jvm.put_field(&mut this, "java/util/Random", "seed", "J", seed).await?;
194 jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", false).await?;
195
196 Ok(())
197 }
198}