refactor: 进一步拆分函数执行逻辑以简化主流程

crates/oxide_vm/src/dispatch/arithmetic.rs

@@ -1 +1,21 @@
-// dispatch helper functions extracted from vm.rs
+use crate::coercion;
+use crate::vm::Vm;
+use oxide_types::value::JsValue;
+
+impl Vm {
+    #[inline(always)]
+    pub(crate) fn dispatch_add(&mut self, rd: usize, a: usize, b: usize) {
+        let lhs = self.regs[a];
+        let rhs = self.regs[b];
+        if lhs.is_string() || rhs.is_string() {
+            let ls = coercion::to_string(self.kernel.string_forge().as_ref(), lhs);
+            let rs = coercion::to_string(self.kernel.string_forge().as_ref(), rhs);
+            let concat = format!("{ls}{rs}");
+            self.regs[rd] = self.intern(&concat);
+        } else {
+            let ln = coercion::to_number(lhs, self.kernel.string_forge().as_ref());
+            let rn = coercion::to_number(rhs, self.kernel.string_forge().as_ref());
+            self.regs[rd] = JsValue::float(ln + rn);
+        }
+    }
+}

crates/oxide_vm/src/dispatch/comparison.rs

@@ -1 +1,77 @@
-// dispatch helper functions extracted from vm.rs
+use crate::coercion;
+use crate::vm::Vm;
+use oxide_types::value::JsValue;
+
+impl Vm {
+    #[inline(always)]
+    pub(crate) fn dispatch_eq(&mut self, rd: usize, a: usize, b: usize) {
+        let eq = coercion::abstract_eq(
+            self.regs[a],
+            self.regs[b],
+            self.kernel.string_forge().as_ref(),
+        );
+        self.regs[rd] = JsValue::bool(eq);
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_neq(&mut self, rd: usize, a: usize, b: usize) {
+        let ne = !coercion::abstract_eq(
+            self.regs[a],
+            self.regs[b],
+            self.kernel.string_forge().as_ref(),
+        );
+        self.regs[rd] = JsValue::bool(ne);
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_lt(&mut self, rd: usize, a: usize, b: usize) {
+        let rel = coercion::relational_compare(
+            self.kernel.string_forge().as_ref(),
+            self.regs[a],
+            self.regs[b],
+        );
+        self.regs[rd] = JsValue::bool(rel.unwrap_or(false));
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_gt(&mut self, rd: usize, a: usize, b: usize) {
+        let rel = coercion::relational_compare(
+            self.kernel.string_forge().as_ref(),
+            self.regs[b],
+            self.regs[a],
+        );
+        self.regs[rd] = JsValue::bool(rel.unwrap_or(false));
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_lte(&mut self, rd: usize, a: usize, b: usize) {
+        let rel = coercion::relational_compare(
+            self.kernel.string_forge().as_ref(),
+            self.regs[b],
+            self.regs[a],
+        );
+        self.regs[rd] = JsValue::bool(!rel.unwrap_or(true));
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_gte(&mut self, rd: usize, a: usize, b: usize) {
+        let rel = coercion::relational_compare(
+            self.kernel.string_forge().as_ref(),
+            self.regs[a],
+            self.regs[b],
+        );
+        self.regs[rd] = JsValue::bool(!rel.unwrap_or(true));
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_strict_eq(&mut self, rd: usize, a: usize, b: usize) {
+        let eq = coercion::strict_equality(self.regs[a], self.regs[b]);
+        self.regs[rd] = JsValue::bool(eq);
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_strict_neq(&mut self, rd: usize, a: usize, b: usize) {
+        let ne = !coercion::strict_equality(self.regs[a], self.regs[b]);
+        self.regs[rd] = JsValue::bool(ne);
+    }
+}

crates/oxide_vm/src/dispatch/control_flow.rs

@@ -1 +1,31 @@
-// dispatch helper functions extracted from vm.rs
+use crate::coercion;
+use crate::vm::Vm;
+use oxide_types::value::JsValue;
+
+impl Vm {
+    #[inline(always)]
+    pub(crate) fn dispatch_and(&mut self, rd: usize, a: usize, b: usize) {
+        let val = self.regs[a];
+        if coercion::to_boolean(val, self.kernel.string_forge().as_ref()) {
+            self.regs[rd] = self.regs[b];
+        } else {
+            self.regs[rd] = val;
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_or(&mut self, rd: usize, a: usize, b: usize) {
+        let val = self.regs[a];
+        if coercion::to_boolean(val, self.kernel.string_forge().as_ref()) {
+            self.regs[rd] = val;
+        } else {
+            self.regs[rd] = self.regs[b];
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_not(&mut self, rd: usize, a: usize) {
+        let b = !coercion::to_boolean(self.regs[a], self.kernel.string_forge().as_ref());
+        self.regs[rd] = JsValue::bool(b);
+    }
+}

crates/oxide_vm/src/dispatch/misc.rs

@@ -1 +1,40 @@
-// dispatch helper functions extracted from vm.rs
+use crate::vm::Vm;
+
+impl Vm {
+    #[inline(always)]
+    pub(crate) fn dispatch_load_const(&mut self, rd: usize, instr: u32) -> Result<(), String> {
+        let idx = (instr >> 16) as usize;
+        if idx < self.constants.len() {
+            self.regs[rd] = self.constants[idx];
+            Ok(())
+        } else {
+            Err(format!("constant index {idx} out of bounds"))
+        }
+    }
+
+    #[inline(always)]
+    pub(crate) fn dispatch_typeof(&mut self, rd: usize, a: usize) {
+        let val = self.regs[a];
+        let result = if val.is_undefined() {
+            "undefined"
+        } else if val.is_null() {
+            "object"
+        } else if val.is_bool() {
+            "boolean"
+        } else if val.is_int() || val.is_double() {
+            "number"
+        } else if val.is_string() {
+            "string"
+        } else if val.is_object() {
+            let obj = unsafe { &*val.as_js_object_ptr() };
+            if obj.is_function() {
+                "function"
+            } else {
+                "object"
+            }
+        } else {
+            "undefined"
+        };
+        self.regs[rd] = self.intern(result);
+    }
+}