1use alloc::{format, string::String as RustString, vec};
2
3use jvm::{
4 ClassInstanceRef, JavaChar, JavaError, 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::{Character, Object, String},
13};
14
15pub struct Long;
17
18impl Long {
19 pub fn as_proto() -> RuntimeClassProto {
20 RuntimeClassProto {
21 name: "java/lang/Long",
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>", "(J)V", Self::init, MethodAccessFlags::PUBLIC),
27 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_string, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new(
29 "parseLong",
30 "(Ljava/lang/String;)J",
31 Self::parse_long,
32 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
33 ),
34 JavaMethodProto::new(
35 "parseLong",
36 "(Ljava/lang/String;I)J",
37 Self::parse_long_radix,
38 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
39 ),
40 JavaMethodProto::new(
41 "valueOf",
42 "(J)Ljava/lang/Long;",
43 Self::value_of,
44 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
45 ),
46 JavaMethodProto::new(
47 "valueOf",
48 "(Ljava/lang/String;)Ljava/lang/Long;",
49 Self::value_of_string,
50 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
51 ),
52 JavaMethodProto::new(
53 "valueOf",
54 "(Ljava/lang/String;I)Ljava/lang/Long;",
55 Self::value_of_string_radix,
56 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
57 ),
58 JavaMethodProto::new(
59 "decode",
60 "(Ljava/lang/String;)Ljava/lang/Long;",
61 Self::decode,
62 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
63 ),
64 JavaMethodProto::new(
65 "getLong",
66 "(Ljava/lang/String;)Ljava/lang/Long;",
67 Self::get_long,
68 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
69 ),
70 JavaMethodProto::new(
71 "getLong",
72 "(Ljava/lang/String;J)Ljava/lang/Long;",
73 Self::get_long_value_default,
74 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
75 ),
76 JavaMethodProto::new(
77 "getLong",
78 "(Ljava/lang/String;Ljava/lang/Long;)Ljava/lang/Long;",
79 Self::get_long_object_default,
80 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
81 ),
82 JavaMethodProto::new("byteValue", "()B", Self::byte_value, MethodAccessFlags::PUBLIC),
83 JavaMethodProto::new("shortValue", "()S", Self::short_value, MethodAccessFlags::PUBLIC),
84 JavaMethodProto::new("intValue", "()I", Self::int_value, MethodAccessFlags::PUBLIC),
85 JavaMethodProto::new("longValue", "()J", Self::long_value, MethodAccessFlags::PUBLIC),
86 JavaMethodProto::new("floatValue", "()F", Self::float_value, MethodAccessFlags::PUBLIC),
87 JavaMethodProto::new("doubleValue", "()D", Self::double_value, MethodAccessFlags::PUBLIC),
88 JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
89 JavaMethodProto::new(
90 "toString",
91 "(J)Ljava/lang/String;",
92 Self::to_string_static,
93 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
94 ),
95 JavaMethodProto::new(
96 "toString",
97 "(JI)Ljava/lang/String;",
98 Self::to_string_radix,
99 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
100 ),
101 JavaMethodProto::new(
102 "toBinaryString",
103 "(J)Ljava/lang/String;",
104 Self::to_binary_string,
105 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
106 ),
107 JavaMethodProto::new(
108 "toOctalString",
109 "(J)Ljava/lang/String;",
110 Self::to_octal_string,
111 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
112 ),
113 JavaMethodProto::new(
114 "toHexString",
115 "(J)Ljava/lang/String;",
116 Self::to_hex_string,
117 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
118 ),
119 JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
120 JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
121 JavaMethodProto::new("compareTo", "(Ljava/lang/Long;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
122 JavaMethodProto::new("compareTo", "(Ljava/lang/Object;)I", Self::compare_to_object, MethodAccessFlags::PUBLIC),
123 ],
124 fields: vec![
125 JavaFieldProto::new(
126 "MIN_VALUE",
127 "J",
128 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
129 ),
130 JavaFieldProto::new(
131 "MAX_VALUE",
132 "J",
133 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
134 ),
135 JavaFieldProto::new(
136 "TYPE",
137 "Ljava/lang/Class;",
138 FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
139 ),
140 JavaFieldProto::new("value", "J", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
141 ],
142 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
143 }
144 }
145
146 async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
147 jvm.put_static_field("java/lang/Long", "MIN_VALUE", "J", i64::MIN).await?;
148 jvm.put_static_field("java/lang/Long", "MAX_VALUE", "J", i64::MAX).await?;
149 jvm.put_static_field(
150 "java/lang/Long",
151 "TYPE",
152 "Ljava/lang/Class;",
153 JavaLangClass::from_rust_primitive(jvm, "long").await?,
154 )
155 .await
156 }
157 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
158 let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
159 jvm.put_field(&mut this, "java/lang/Long", "value", "J", value).await
160 }
161 async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
162 let value: i64 = jvm
163 .invoke_static("java/lang/Long", "parseLong", "(Ljava/lang/String;)J", (value,))
164 .await?;
165 let mut this = this;
166 let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
167 jvm.put_field(&mut this, "java/lang/Long", "value", "J", value).await
168 }
169 fn parse_raw(value: &str, radix: u32) -> Option<i64> {
170 if !(2..=36).contains(&radix) || value.is_empty() {
171 return None;
172 }
173 let negative = value.starts_with('-');
174 let body = value.strip_prefix('-').or_else(|| value.strip_prefix('+')).unwrap_or(value);
175 if body.is_empty() {
176 return None;
177 }
178 let limit = if negative { i128::from(i64::MIN) } else { -i128::from(i64::MAX) };
179 let mut result = 0i128;
180 for value in body.chars() {
181 let value = JavaChar::try_from(u32::from(value)).ok()?;
182 let digit = i128::from(Character::digit_value(value, radix as i32));
183 if digit < 0 {
184 return None;
185 }
186 if result < (limit + digit) / i128::from(radix) {
187 return None;
188 }
189 result = result * i128::from(radix) - digit;
190 }
191 if !negative && result == i128::from(i64::MIN) {
192 return None;
193 }
194 Some(if negative { result as i64 } else { -result as i64 })
195 }
196 async fn parse_long(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<i64> {
197 if value.is_null() {
198 return Err(jvm.exception("java/lang/NumberFormatException", "null").await);
199 }
200 let value = JavaLangString::to_rust_string(jvm, &value).await?;
201 match Self::parse_raw(&value, 10) {
202 Some(value) => Ok(value),
203 None => Err(jvm
204 .exception("java/lang/NumberFormatException", &format!("For input string: \"{value}\""))
205 .await),
206 }
207 }
208 async fn parse_long_radix(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>, radix: i32) -> Result<i64> {
209 if value.is_null() {
210 return Err(jvm.exception("java/lang/NumberFormatException", "null").await);
211 }
212 let value = JavaLangString::to_rust_string(jvm, &value).await?;
213 match Self::parse_raw(&value, radix as u32) {
214 Some(value) => Ok(value),
215 None => Err(jvm
216 .exception("java/lang/NumberFormatException", &format!("For input string: \"{value}\""))
217 .await),
218 }
219 }
220 async fn value_of_string(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
221 let value: i64 = jvm
222 .invoke_static("java/lang/Long", "parseLong", "(Ljava/lang/String;)J", (value,))
223 .await?;
224 Ok(jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into())
225 }
226
227 async fn value_of(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<Self>> {
228 Ok(jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into())
229 }
230 async fn value_of_string_radix(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>, radix: i32) -> Result<ClassInstanceRef<Self>> {
231 let value: i64 = jvm
232 .invoke_static("java/lang/Long", "parseLong", "(Ljava/lang/String;I)J", (value, radix))
233 .await?;
234 Ok(jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into())
235 }
236 async fn decode(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
237 if value.is_null() {
238 return Err(jvm.exception("java/lang/NullPointerException", "value").await);
239 }
240 let value = JavaLangString::to_rust_string(jvm, &value).await?;
241 let (sign, body) = if let Some(body) = value.strip_prefix('-') {
242 ("-", body)
243 } else if let Some(body) = value.strip_prefix('+') {
244 ("+", body)
245 } else {
246 ("", value.as_str())
247 };
248 let (radix, body) = if let Some(body) = body
249 .strip_prefix("0x")
250 .or_else(|| body.strip_prefix("0X"))
251 .or_else(|| body.strip_prefix('#'))
252 {
253 (16, body)
254 } else if body.starts_with('0') && body.len() > 1 {
255 (8, &body[1..])
256 } else {
257 (10, body)
258 };
259 if body.starts_with('-') || body.starts_with('+') {
260 return Err(jvm.exception("java/lang/NumberFormatException", "Sign character in wrong position").await);
261 }
262 let mut signed = RustString::from(sign);
263 signed.push_str(body);
264 let value = match Self::parse_raw(&signed, radix) {
265 Some(value) => value,
266 None => return Err(jvm.exception("java/lang/NumberFormatException", "invalid long").await),
267 };
268 Ok(jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into())
269 }
270 async fn get_long(jvm: &Jvm, _: &mut RuntimeContext, key: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
271 let default: ClassInstanceRef<Self> = None.into();
272 jvm.invoke_static(
273 "java/lang/Long",
274 "getLong",
275 "(Ljava/lang/String;Ljava/lang/Long;)Ljava/lang/Long;",
276 (key, default),
277 )
278 .await
279 }
280 async fn get_long_value_default(
281 jvm: &Jvm,
282 _: &mut RuntimeContext,
283 key: ClassInstanceRef<String>,
284 default: i64,
285 ) -> Result<ClassInstanceRef<Self>> {
286 let default = jvm.new_class("java/lang/Long", "(J)V", (default,)).await?;
287 jvm.invoke_static(
288 "java/lang/Long",
289 "getLong",
290 "(Ljava/lang/String;Ljava/lang/Long;)Ljava/lang/Long;",
291 (key, default),
292 )
293 .await
294 }
295 async fn get_long_object_default(
296 jvm: &Jvm,
297 _: &mut RuntimeContext,
298 key: ClassInstanceRef<String>,
299 default: ClassInstanceRef<Self>,
300 ) -> Result<ClassInstanceRef<Self>> {
301 if key.is_null() {
302 return Ok(default);
303 }
304 let value: ClassInstanceRef<String> = jvm
305 .invoke_static("java/lang/System", "getProperty", "(Ljava/lang/String;)Ljava/lang/String;", (key,))
306 .await?;
307 if value.is_null() {
308 return Ok(default);
309 }
310 match jvm
311 .invoke_static("java/lang/Long", "decode", "(Ljava/lang/String;)Ljava/lang/Long;", (value,))
312 .await
313 {
314 Ok(value) => Ok(value),
315 Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/lang/NumberFormatException") => Ok(default),
316 Err(error) => Err(error),
317 }
318 }
319 async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i8> {
320 Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as i8)
321 }
322 async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i16> {
323 Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as i16)
324 }
325 async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
326 Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as i32)
327 }
328 async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
329 jvm.get_field(&this, "java/lang/Long", "value", "J").await
330 }
331 async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
332 Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as f32)
333 }
334 async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
335 Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as f64)
336 }
337 fn format_value(value: i64, radix: u32) -> RustString {
338 let radix = if (2..=36).contains(&radix) { radix } else { 10 };
339 if value == 0 {
340 return "0".into();
341 }
342 let negative = value < 0;
343 let mut magnitude = value.unsigned_abs();
344 let mut result = RustString::new();
345 while magnitude != 0 {
346 result.push(char::from_digit((magnitude % u64::from(radix)) as u32, radix).unwrap_or('0'));
347 magnitude /= u64::from(radix);
348 }
349 if negative {
350 result.push('-');
351 }
352 result.chars().rev().collect()
353 }
354 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
355 let value: i64 = jvm.invoke_virtual(&this, "java/lang/Long", "longValue", "()J", ()).await?;
356 Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value, 10)).await?.into())
357 }
358 async fn to_string_static(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<String>> {
359 Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value, 10)).await?.into())
360 }
361 async fn to_string_radix(jvm: &Jvm, _: &mut RuntimeContext, value: i64, radix: i32) -> Result<ClassInstanceRef<String>> {
362 Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value, radix as u32))
363 .await?
364 .into())
365 }
366 async fn to_binary_string(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<String>> {
367 let text = if value < 0 {
368 format!("{:064b}", value as u64)
369 } else {
370 Self::format_value(value, 2)
371 };
372 Ok(JavaLangString::from_rust_string(jvm, &text).await?.into())
373 }
374 async fn to_octal_string(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<String>> {
375 let text = if value < 0 {
376 format!("{:022o}", value as u64)
377 } else {
378 Self::format_value(value, 8)
379 };
380 Ok(JavaLangString::from_rust_string(jvm, &text).await?.into())
381 }
382 async fn to_hex_string(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<String>> {
383 let text = if value < 0 {
384 format!("{:016x}", value as u64)
385 } else {
386 Self::format_value(value, 16)
387 };
388 Ok(JavaLangString::from_rust_string(jvm, &text).await?.into())
389 }
390 async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
391 let value: i64 = jvm.invoke_virtual(&this, "java/lang/Long", "longValue", "()J", ()).await?;
392 Ok((value ^ (value >> 32)) as i32)
393 }
394 async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
395 if other.is_null() || !jvm.is_instance(&**other, "java/lang/Long") {
396 return Ok(false);
397 }
398 Ok(jvm.invoke_virtual::<_, i64>(&this, "java/lang/Long", "longValue", "()J", ()).await?
399 == jvm.invoke_virtual::<_, i64>(&other, "java/lang/Long", "longValue", "()J", ()).await?)
400 }
401 async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
402 if other.is_null() {
403 return Err(jvm.exception("java/lang/NullPointerException", "other").await);
404 }
405 let left: i64 = jvm.invoke_virtual(&this, "java/lang/Long", "longValue", "()J", ()).await?;
406 let right: i64 = jvm.invoke_virtual(&other, "java/lang/Long", "longValue", "()J", ()).await?;
407 Ok(left.cmp(&right) as i32)
408 }
409 async fn compare_to_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
410 if other.is_null() {
411 return Err(jvm.exception("java/lang/NullPointerException", "other").await);
412 }
413 if !jvm.is_instance(&**other, "java/lang/Long") {
414 return Err(jvm.exception("java/lang/ClassCastException", "not Long").await);
415 }
416 let other = ClassInstanceRef::<Self>::from(other.instance);
417 let left: i64 = jvm.invoke_virtual(&this, "java/lang/Long", "longValue", "()J", ()).await?;
418 let right: i64 = jvm.invoke_virtual(&other, "java/lang/Long", "longValue", "()J", ()).await?;
419 Ok(left.cmp(&right) as i32)
420 }
421}