https://github.com/andreabergia/rjvm

class StackTracePrinting {    public static void main(String[] args) {        Throwable ex = new Exception();        StackTraceElement[] stackTrace = ex.getStackTrace();        for (StackTraceElement element : stackTrace) {            tempPrint(                    element.getClassName() + "::" + element.getMethodName() + " - " +                            element.getFileName() + ":" + element.getLineNumber());        }    }
    // We use this in place of System.out.println because we don't have real I/O    private static native void tempPrint(String value);}

https://github.com/andreabergia/rjvm/blob/main/reader/src/class_file.rs

/// Models a generic value that can be stored in a local variable or on the stack.#[derive(Debug, Default, Clone, PartialEq)]pub enum Value<'a> {    /// An unitialized element. Should never be on the stack,    /// but it is the default state for local variables.    #[default]    Uninitialized,
    /// Models all the 32-or-lower-bits types in the jvm: `boolean`,    /// `byte`, `char`, `short`, and `int`.    Int(i32),
    /// Models a `long` value.    Long(i64),
    /// Models a `float` value.    Float(f32),
    /// Models a `double` value.    Double(f64),
    /// Models an object value    Object(AbstractObject<'a>),
    /// Models a null object    Null,}

/// Represents a Java bytecode instruction.#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub enum Instruction {    Aaload,    Aastore,    Aconst_null,    Aload(u8),    // ...

 fn execute_instruction(    &mut self,    vm: &mut Vm<'a>,    call_stack: &mut CallStack<'a>,    instruction: Instruction,) -> Result<InstructionCompleted<'a>, MethodCallFailed<'a>>

/// Possible execution result of an instructionenum InstructionCompleted<'a> {    /// Indicates that the instruction executed was one of the return family. The caller    /// should stop the method execution and return the value.    ReturnFromMethod(Option<Value<'a>>),
    /// Indicates that the instruction was not a return, and thus the execution should    /// resume from the instruction at the program counter.    ContinueMethodExecution,}
/// Models the fact that a method execution has failedpub enum MethodCallFailed<'a> {    InternalError(VmError),    ExceptionThrown(JavaException<'a>),}

enum Result<T, E> {   Ok(T),   Err(E),}

/// Executes the whole methodimpl<'a> CallFrame<'a> {    pub fn execute(        &mut self,        vm: &mut Vm<'a>,        call_stack: &mut CallStack<'a>,    ) -> MethodCallResult<'a> {        self.debug_start_execution();
        loop {            let executed_instruction_pc = self.pc;            let (instruction, new_address) =                Instruction::parse(                    self.code,                    executed_instruction_pc.0.into_usize_safe()                ).map_err(|_| MethodCallFailed::InternalError(                    VmError::ValidationException)                )?;            self.debug_print_status(&instruction);
            // Move pc to the next instruction, _before_ executing it,            // since we want a "goto" to override this            self.pc = ProgramCounter(new_address as u16);
            let instruction_result =                self.execute_instruction(vm, call_stack, instruction);            match instruction_result {                Ok(ReturnFromMethod(return_value)) => return Ok(return_value),                Ok(ContinueMethodExecution) => { /* continue the loop */ }
                Err(MethodCallFailed::InternalError(err)) => {                    return Err(MethodCallFailed::InternalError(err))                }
                Err(MethodCallFailed::ExceptionThrown(exception)) => {                    let exception_handler = self.find_exception_handler(                        vm,                        call_stack,                        executed_instruction_pc,                        &exception,                    );                    match exception_handler {                        Err(err) => return Err(err),                        Ok(None) => {                            // Bubble exception up to the caller                            return Err(MethodCallFailed::ExceptionThrown(exception));                        }                        Ok(Some(catch_handler_pc)) => {                            // Re-push exception on the stack and continue                            // execution of this method from the catch handler                            self.stack.push(Value::Object(exception.0))?;                            self.pc = catch_handler_pc;                        }                    }                }            }        }    }}