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