Method dispatch_next

aiscript-vm/src/vm/state.rs:319–1105

Dispatch the next opcode, stop at the given frame count. When dispatch in step() function, the stop_at_frame_count is 0. When dispatch in eval_function(), the stop_at_frame_count is the frame count before to call eval_function(). This is used to exit the frame call after the chunks of that function is finished.

(
        &mut self,
        stop_at_frame_count: usize,
    )

    // When dispatch in eval_function(), the stop_at_frame_count is the frame count before to call eval_function().
    // This is used to exit the frame call after the chunks of that function is finished.
    pub fn dispatch_next(
        &mut self,
        stop_at_frame_count: usize,
    ) -> Result<Option<Value<'gc>>, VmError> {
        // Debug stack info
        #[cfg(feature = "debug")]
        self.print_stack();
        let frame = self.current_frame();
        // Disassemble instruction for debug
        #[cfg(feature = "debug")]
        frame.disassemble_instruction(frame.ip);
        match frame.next_opcode() {
            OpCode::Constant(byte) => {
                let constant = frame.read_constant(byte);
                self.push_stack(constant);
            }
            OpCode::Add => match (self.peek(0), self.peek(1)) {
                (Value::Number(_), Value::Number(_)) => {
                    binary_op!(self, +);
                }
                (Value::String(_), Value::String(_))
                | (Value::IoString(_), Value::IoString(_))
                | (Value::String(_), Value::IoString(_))
                | (Value::IoString(_), Value::String(_)) => {
                    let b = self.pop_stack().as_string()?;
                    let a = self.pop_stack().as_string()?;
                    let s = self.intern(format!("{a}{b}").as_bytes());
                    self.push_stack(s.into());
                }
                _ => {
                    return Err(
                        self.runtime_error("Operands must be two numbers or two strings.".into())
                    );
                }
            },
            OpCode::Subtract => {
                binary_op!(self, -);
            }
            OpCode::Multiply => {
                binary_op!(self, *);
            }
            OpCode::Divide => {
                binary_op!(self, /);
            }
            OpCode::Modulo => {
                binary_op!(self, %);
            }
            OpCode::Power => {
                let b = self
                    .pop_stack()
                    .as_number()
                    .map_err(|_| self.runtime_error(NUMBER_OPERATOR_ERROR.into()))?;
                let a = self
                    .pop_stack()
                    .as_number()
                    .map_err(|_| self.runtime_error(NUMBER_OPERATOR_ERROR.into()))?;

                // Use f64's powf method for power operation