Add support of trivial strings operations

tests/integration_test.rs

@@ -313,6 +313,15 @@ fn should_do_trivial_treemaps() {
     assert_eq!(84, get_int(last_frame_value))
 }
 
+#[test]
+fn should_do_trivial_strings() {
+    let mut vm = VM::new("std");
+    let last_frame_value = vm
+        .run("samples.javacore.strings.trivial.TrivialStrings")
+        .unwrap();
+    assert_eq!(8, get_int(last_frame_value))
+}
+
 fn get_int(locals: Option<Vec<i32>>) -> i32 {
     *locals.unwrap().last().unwrap()
 }

tests/test_data/TrivialStrings.java

@@ -0,0 +1,12 @@
+package samples.javacore.strings.trivial;
+
+public class TrivialStrings {
+    public static void main(String[] args) {
+        char[] textArray = {'J', 'a', 'v', 'a', ' ', 'i', 's', ' ', 'f', 'l', 'e', 'x', 'i', 'b', 'l', 'e'};
+        String text = new String(textArray);
+        char[] searchArray = {'f', 'l', 'e', 'x', 'i', 'b', 'l', 'e'};
+        String search = new String(searchArray);
+
+        int index = text.indexOf(search);
+    }
+}

vm/src/execution_engine/engine.rs

@@ -322,6 +322,34 @@ impl Engine {
                         objref[0]
                     );
                 }
+                BALOAD => {
+                    let index = stack_frame.pop();
+                    let arrayref = stack_frame.pop();
+                    let value = with_heap_read_lock(|heap| {
+                        heap.get_array_value(arrayref, index).cloned()
+                    })?;
+
+                    stack_frame.push(value[0]);
+                    stack_frame.incr_pc();
+                    println!(
+                        "BALOAD -> arrayref={arrayref}, index={index}, value={}",
+                        value[0]
+                    );
+                }
+                CALOAD => {
+                    let index = stack_frame.pop();
+                    let arrayref = stack_frame.pop();
+                    let value = with_heap_read_lock(|heap| {
+                        heap.get_array_value(arrayref, index).cloned()
+                    })?;
+
+                    stack_frame.push(value[0]);
+                    stack_frame.incr_pc();
+                    println!(
+                        "CALOAD -> arrayref={arrayref}, index={index}, value={}",
+                        value[0]
+                    );
+                }
                 ISTORE => {
                     stack_frame.incr_pc();
                     let pos = stack_frame.get_bytecode_byte() as usize;
@@ -497,6 +525,30 @@ impl Engine {
                     stack_frame.incr_pc();
                     println!("AASTORE -> arrayref={arrayref}, index={index}, objref={objref}");
                 }
+                BASTORE => {
+                    let value = stack_frame.pop();
+                    let index = stack_frame.pop();
+                    let arrayref = stack_frame.pop();
+
+                    with_heap_write_lock(|heap| {
+                        heap.set_array_value(arrayref, index, vec![value])
+                    })?;
+
+                    stack_frame.incr_pc();
+                    println!("BASTORE -> arrayref={arrayref}, index={index}, value={value}");
+                }
+                CASTORE => {
+                    let value = stack_frame.pop();
+                    let index = stack_frame.pop();
+                    let arrayref = stack_frame.pop();
+
+                    with_heap_write_lock(|heap| {
+                        heap.set_array_value(arrayref, index, vec![value])
+                    })?;
+
+                    stack_frame.incr_pc();
+                    println!("CASTORE -> arrayref={arrayref}, index={index}, value={value}");
+                }
                 POP => {
                     stack_frame.pop();
 
@@ -692,6 +744,14 @@ impl Engine {
                     stack_frame.incr_pc();
                     println!("I2F -> {value}F");
                 }
+                I2B => {
+                    let value = stack_frame.pop() as i8;
+
+                    stack_frame.push(value as i32);
+
+                    stack_frame.incr_pc();
+                    println!("I2B -> {value}B");
+                }
                 LCMP => {
                     let b = stack_frame.pop_i64();
                     let a = stack_frame.pop_i64();