Fix opcode operand parsing, interface instanceof, and runtime class bugs

- invokeinterface/invokedynamic now consume all four operand bytes
- ClassDefinition exposes interface names; is_inherited_from checks interfaces
- putstatic narrows int stack values to the field type like putfield
- JavaLangString::to_rust_string no longer panics on unpaired surrogates
- ByteArrayInputStream.mark saves position instead of readlimit
- InputStream.skip returns actual skipped bytes with bounded buffer
- Integer.parseInt throws NumberFormatException on invalid input
- String.substring validates range, ISO-8859-1 encoding maps unmappable chars to '?'
- Vector.firstElement throws NoSuchElementException on empty vector

Author: dlunch

Cargo.lock

@@ -49,6 +49,9 @@ jvm_rust = { workspace = true }
 java_class_proto = { workspace = true }
 java_runtime = { workspace = true }
 
+[dev-dependencies]
+test_utils = { workspace = true }
+
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread"] }
 

Cargo.toml

@@ -317,12 +317,12 @@ impl Opcode {
                 Opcode::Instanceof(ConstantPoolReference::from_constant_pool(constant_pool, x as _))
             })
             .parse(data),
-            0xba => map(be_u16, |x| {
+            0xba => map((be_u16, be_u16), |(x, _)| {
                 Opcode::Invokedynamic(ConstantPoolReference::from_constant_pool(constant_pool, x as _))
             })
             .parse(data),
-            0xb9 => map(be_u16, |x| {
-                Opcode::Invokeinterface(ConstantPoolReference::from_constant_pool(constant_pool, x as _), 0, 0)
+            0xb9 => map((be_u16, u8, u8), |(x, count, zero)| {
+                Opcode::Invokeinterface(ConstantPoolReference::from_constant_pool(constant_pool, x as _), count, zero)
             })
             .parse(data),
             0xb7 => map(be_u16, |x| {
@@ -432,3 +432,59 @@ impl Opcode {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use alloc::{collections::BTreeMap, string::ToString, sync::Arc};
+
+    use super::Opcode;
+    use crate::constant_pool::ConstantPoolItem;
+
+    fn constant_pool() -> BTreeMap<u16, ConstantPoolItem> {
+        [
+            (1, ConstantPoolItem::Utf8(Arc::new("Foo".to_string()))),
+            (2, ConstantPoolItem::Class { name_index: 1 }),
+            (3, ConstantPoolItem::Utf8(Arc::new("bar".to_string()))),
+            (4, ConstantPoolItem::Utf8(Arc::new("()V".to_string()))),
+            (
+                5,
+                ConstantPoolItem::NameAndType {
+                    name_index: 3,
+                    descriptor_index: 4,
+                },
+            ),
+            (
+                6,
+                ConstantPoolItem::InterfaceMethodref {
+                    class_index: 2,
+                    name_and_type_index: 5,
+                },
+            ),
+            (
+                7,
+                ConstantPoolItem::Methodref {
+                    class_index: 2,
+                    name_and_type_index: 5,
+                },
+            ),
+        ]
+        .into_iter()
+        .collect()
+    }
+
+    #[test]
+    fn test_invokeinterface_consumes_count_and_zero() {
+        let (remaining, opcode) = Opcode::parse(&[0xb9, 0x00, 0x06, 0x01, 0x00], 0, &constant_pool()).unwrap();
+
+        assert!(remaining.is_empty());
+        assert!(matches!(opcode, Opcode::Invokeinterface(_, 1, 0)));
+    }
+
+    #[test]
+    fn test_invokedynamic_consumes_reserved_bytes() {
+        let (remaining, opcode) = Opcode::parse(&[0xba, 0x00, 0x07, 0x00, 0x00], 0, &constant_pool()).unwrap();
+
+        assert!(remaining.is_empty());
+        assert!(matches!(opcode, Opcode::Invokedynamic(_)));
+    }
+}

classfile/src/opcode.rs

@@ -113,3 +113,22 @@ fn test_switch() {
             Opcode::Lookupswitch(default, pairs) if *default == 82 && *pairs == vec![(1, 41), (10, 52), (100, 63), (1000, 74)]));
     }
 }
+
+#[test]
+fn test_invokeinterface() {
+    let interface = include_bytes!("../../test_data/Interface.class");
+
+    let class = ClassInfo::parse(interface).unwrap();
+
+    assert_eq!(class.methods[1].name, "main".to_string().into());
+    if let AttributeInfo::Code(x) = &class.methods[1].attributes[0] {
+        assert_eq!(x.code.len(), 7);
+        assert!(matches!(x.code.get(&9).unwrap(),
+            Opcode::Invokeinterface(ConstantPoolReference::InterfaceMethodref(m), 1, 0) if m.class == "Interface$IInterface".to_string().into() && m.name == "test".to_string().into()));
+        assert!(!x.code.contains_key(&12));
+        assert!(!x.code.contains_key(&13));
+        assert!(matches!(x.code.get(&14).unwrap(), Opcode::Return));
+    } else {
+        panic!("Expected code attribute");
+    }
+}

classfile/tests/test.rs

@@ -151,7 +151,8 @@ impl ByteArrayInputStream {
     async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, readlimit: i32) -> Result<()> {
         tracing::debug!("java.io.ByteArrayInputStream::mark({:?}, {:?})", &this, readlimit);
 
-        jvm.put_field(&mut this, "mark", "I", readlimit).await?;
+        let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
+        jvm.put_field(&mut this, "mark", "I", pos).await?;
 
         Ok(())
     }

java_runtime/src/classes/java/io/byte_array_input_stream.rs

@@ -50,10 +50,25 @@ impl InputStream {
     async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
         tracing::debug!("java.io.InputStream::skip({:?}, {:?})", &this, n);
 
-        let scratch = jvm.instantiate_array("B", n as _).await?;
-        let _: i32 = jvm.invoke_virtual(&this, "read", "([BII)I", (scratch.clone(), 0, n as i32)).await?;
+        if n <= 0 {
+            return Ok(0);
+        }
+
+        let scratch_size = n.min(4096);
+        let scratch = jvm.instantiate_array("B", scratch_size as _).await?;
+
+        let mut remaining = n;
+        while remaining > 0 {
+            let len_to_read = remaining.min(scratch_size) as i32;
+            let read: i32 = jvm.invoke_virtual(&this, "read", "([BII)I", (scratch.clone(), 0, len_to_read)).await?;
+            if read <= 0 {
+                break;
+            }
+
+            remaining -= read as i64;
+        }
 
-        Ok(n)
+        Ok(n - remaining)
     }
 
     async fn mark(_jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, readlimit: i32) -> Result<()> {

java_runtime/src/classes/java/io/input_stream.rs

@@ -19,6 +19,7 @@ mod linkage_error;
 mod math;
 mod negative_array_size_exception;
 mod no_class_def_found_error;
+mod number_format_exception;
 mod no_such_field_error;
 mod no_such_method_error;
 mod null_pointer_exception;
@@ -29,6 +30,7 @@ mod runtime_exception;
 mod security_exception;
 mod string;
 mod string_buffer;
+mod string_index_out_of_bounds_exception;
 mod system;
 mod thread;
 mod throwable;
@@ -41,8 +43,9 @@ pub use self::{
     exception::Exception, illegal_argument_exception::IllegalArgumentException, incompatible_class_change_error::IncompatibleClassChangeError,
     index_out_of_bounds_exception::IndexOutOfBoundsException, instantiation_error::InstantiationError, integer::Integer,
     interrupted_exception::InterruptedException, linkage_error::LinkageError, math::Math, negative_array_size_exception::NegativeArraySizeException,
-    no_class_def_found_error::NoClassDefFoundError, no_such_field_error::NoSuchFieldError, no_such_method_error::NoSuchMethodError,
+    no_class_def_found_error::NoClassDefFoundError, number_format_exception::NumberFormatException, no_such_field_error::NoSuchFieldError, no_such_method_error::NoSuchMethodError,
     null_pointer_exception::NullPointerException, object::Object, runnable::Runnable, runtime::Runtime, runtime_exception::RuntimeException,
-    security_exception::SecurityException, string::String, string_buffer::StringBuffer, system::System, thread::Thread, throwable::Throwable,
+    security_exception::SecurityException, string::String, string_buffer::StringBuffer,
+    string_index_out_of_bounds_exception::StringIndexOutOfBoundsException, system::System, thread::Thread, throwable::Throwable,
     unsupported_operation_exception::UnsupportedOperationException,
 };

java_runtime/src/classes/java/lang.rs

@@ -76,7 +76,10 @@ impl Integer {
 
         let s = JavaLangString::to_rust_string(jvm, &s).await?;
 
-        Ok(s.parse().unwrap())
+        match s.parse() {
+            Ok(x) => Ok(x),
+            Err(_) => Err(jvm.exception("java/lang/NumberFormatException", &format!("For input string: \"{s}\"")).await),
+        }
     }
 
     async fn to_hex_string(jvm: &Jvm, _: &mut RuntimeContext, value: i32) -> Result<ClassInstanceRef<String>> {

java_runtime/src/classes/java/lang/integer.rs

@@ -0,0 +1,43 @@
+use alloc::vec;
+
+use java_class_proto::JavaMethodProto;
+use jvm::{ClassInstanceRef, Jvm, Result};
+
+use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::String};
+
+// class java/lang/NumberFormatException
+pub struct NumberFormatException;
+
+impl NumberFormatException {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/lang/NumberFormatException",
+            parent_class: Some("java/lang/IllegalArgumentException"),
+            interfaces: vec![],
+            methods: vec![
+                JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
+                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_message, Default::default()),
+            ],
+            fields: vec![],
+            access_flags: Default::default(),
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        tracing::debug!("java.lang.NumberFormatException::<init>({:?})", &this);
+
+        let _: () = jvm.invoke_special(&this, "java/lang/IllegalArgumentException", "<init>", "()V", ()).await?;
+
+        Ok(())
+    }
+
+    async fn init_with_message(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, message: ClassInstanceRef<String>) -> Result<()> {
+        tracing::debug!("java.lang.NumberFormatException::<init>({:?}, {:?})", &this, &message);
+
+        let _: () = jvm
+            .invoke_special(&this, "java/lang/IllegalArgumentException", "<init>", "(Ljava/lang/String;)V", (message,))
+            .await?;
+
+        Ok(())
+    }
+}

java_runtime/src/classes/java/lang/number_format_exception.rs

@@ -1,6 +1,7 @@
 use core::cmp::Ordering;
 
 use alloc::{
+    format,
     string::{String as RustString, ToString},
     vec,
     vec::Vec,
@@ -350,10 +351,20 @@ impl String {
 
         let string = JavaLangString::to_rust_string(jvm, &this.clone()).await?;
 
+        let length = string.chars().count() as i32;
+        if begin_index < 0 || end_index > length || begin_index > end_index {
+            return Err(jvm
+                .exception(
+                    "java/lang/StringIndexOutOfBoundsException",
+                    &format!("begin {begin_index}, end {end_index}, length {length}"),
+                )
+                .await);
+        }
+
         let substr = string
             .chars()
             .skip(begin_index as usize)
-            .take(end_index as usize - begin_index as usize)
+            .take((end_index - begin_index) as usize)
             .collect::<RustString>(); // TODO buffer sharing
 
         Ok(JavaLangString::from_rust_string(jvm, &substr).await?.into())
@@ -778,7 +789,7 @@ impl String {
         match charset.to_ascii_uppercase().replace('_', "-").as_str() {
             "UTF-8" | "UTF8" => string.as_bytes().to_vec(),
             "EUC-KR" | "EUCKR" | "KS-C-5601-1987" | "MS949" | "CP949" => encoding_rs::EUC_KR.encode(string).0.to_vec(),
-            "ISO-8859-1" | "LATIN1" | "US-ASCII" | "ASCII" => string.chars().map(|c| c as u8).collect(),
+            "ISO-8859-1" | "LATIN1" | "US-ASCII" | "ASCII" => string.chars().map(|c| if (c as u32) <= 0xff { c as u8 } else { b'?' }).collect(),
             _ => unimplemented!("unsupported charset: {}", charset),
         }
     }