Refactor (light): move VM value ops to backend/vm_values.rs; add backend/vm_boxcall.rs with call_box_method_impl and rewire call_unified_method. Update CURRENT_TASK for refactor start.
This commit is contained in:
Moe Charm
141
src/backend/vm_values.rs
Normal file
141
src/backend/vm_values.rs
Normal file
@ -0,0 +1,141 @@
|
||||
/*!
|
||||
* VM Value Operations - arithmetic, logical, and comparison helpers
|
||||
*/
|
||||
|
||||
use crate::mir::{BinaryOp, CompareOp, UnaryOp};
|
||||
use super::vm::{VM, VMError, VMValue};
|
||||
|
||||
impl VM {
|
||||
/// Execute binary operation
|
||||
pub(super) fn execute_binary_op(&self, op: &BinaryOp, left: &VMValue, right: &VMValue) -> Result<VMValue, VMError> {
|
||||
// Fast path: logical AND/OR accept any truthy via as_bool
|
||||
if matches!(*op, BinaryOp::And | BinaryOp::Or) {
|
||||
let l = left.as_bool()?;
|
||||
let r = right.as_bool()?;
|
||||
return Ok(VMValue::Bool(match *op { BinaryOp::And => l && r, BinaryOp::Or => l || r, _ => unreachable!() }));
|
||||
}
|
||||
|
||||
match (left, right) {
|
||||
(VMValue::Integer(l), VMValue::Integer(r)) => {
|
||||
let result = match op {
|
||||
BinaryOp::Add => *l + *r,
|
||||
BinaryOp::Sub => *l - *r,
|
||||
BinaryOp::Mul => *l * *r,
|
||||
BinaryOp::Div => {
|
||||
if *r == 0 { return Err(VMError::DivisionByZero); }
|
||||
*l / *r
|
||||
},
|
||||
_ => return Err(VMError::InvalidInstruction(format!("Unsupported integer operation: {:?}", op))),
|
||||
};
|
||||
Ok(VMValue::Integer(result))
|
||||
},
|
||||
|
||||
(VMValue::String(l), VMValue::Integer(r)) => {
|
||||
match op {
|
||||
BinaryOp::Add => Ok(VMValue::String(format!("{}{}", l, r))),
|
||||
_ => Err(VMError::TypeError("String-integer operations only support addition".to_string())),
|
||||
}
|
||||
},
|
||||
|
||||
(VMValue::String(l), VMValue::Bool(r)) => {
|
||||
match op {
|
||||
BinaryOp::Add => Ok(VMValue::String(format!("{}{}", l, r))),
|
||||
_ => Err(VMError::TypeError("String-bool operations only support addition".to_string())),
|
||||
}
|
||||
},
|
||||
|
||||
(VMValue::String(l), VMValue::String(r)) => {
|
||||
match op { BinaryOp::Add => Ok(VMValue::String(format!("{}{}", l, r))), _ => Err(VMError::TypeError("String operations only support addition".to_string())) }
|
||||
},
|
||||
|
||||
// String + BoxRef concatenation
|
||||
(VMValue::String(l), VMValue::BoxRef(r)) => {
|
||||
match op { BinaryOp::Add => Ok(VMValue::String(format!("{}{}", l, r.to_string_box().value))), _ => Err(VMError::TypeError("String-BoxRef operations only support addition".to_string())) }
|
||||
},
|
||||
|
||||
// BoxRef + String concatenation
|
||||
(VMValue::BoxRef(l), VMValue::String(r)) => {
|
||||
match op { BinaryOp::Add => Ok(VMValue::String(format!("{}{}", l.to_string_box().value, r))), _ => Err(VMError::TypeError("BoxRef-String operations only support addition".to_string())) }
|
||||
},
|
||||
|
||||
// Arithmetic with BoxRef(IntegerBox)
|
||||
(VMValue::BoxRef(li), VMValue::BoxRef(ri)) if li.as_any().downcast_ref::<crate::box_trait::IntegerBox>().is_some() && ri.as_any().downcast_ref::<crate::box_trait::IntegerBox>().is_some() => {
|
||||
let l = li.as_any().downcast_ref::<crate::box_trait::IntegerBox>().unwrap().value;
|
||||
let r = ri.as_any().downcast_ref::<crate::box_trait::IntegerBox>().unwrap().value;
|
||||
let res = match op {
|
||||
BinaryOp::Add => l + r,
|
||||
BinaryOp::Sub => l - r,
|
||||
BinaryOp::Mul => l * r,
|
||||
BinaryOp::Div => { if r == 0 { return Err(VMError::DivisionByZero); } l / r },
|
||||
_ => return Err(VMError::InvalidInstruction(format!("Unsupported integer BoxRef operation: {:?}", op))),
|
||||
};
|
||||
Ok(VMValue::Integer(res))
|
||||
}
|
||||
|
||||
// Mixed Integer forms
|
||||
(VMValue::BoxRef(li), VMValue::Integer(r)) if li.as_any().downcast_ref::<crate::box_trait::IntegerBox>().is_some() => {
|
||||
let l = li.as_any().downcast_ref::<crate::box_trait::IntegerBox>().unwrap().value;
|
||||
let res = match op {
|
||||
BinaryOp::Add => l + *r,
|
||||
BinaryOp::Sub => l - *r,
|
||||
BinaryOp::Mul => l * *r,
|
||||
BinaryOp::Div => { if *r == 0 { return Err(VMError::DivisionByZero); } l / *r },
|
||||
_ => return Err(VMError::InvalidInstruction(format!("Unsupported integer operation: {:?}", op))),
|
||||
};
|
||||
Ok(VMValue::Integer(res))
|
||||
}
|
||||
(VMValue::Integer(l), VMValue::BoxRef(ri)) if ri.as_any().downcast_ref::<crate::box_trait::IntegerBox>().is_some() => {
|
||||
let r = ri.as_any().downcast_ref::<crate::box_trait::IntegerBox>().unwrap().value;
|
||||
let res = match op {
|
||||
BinaryOp::Add => *l + r,
|
||||
BinaryOp::Sub => *l - r,
|
||||
BinaryOp::Mul => *l * r,
|
||||
BinaryOp::Div => { if r == 0 { return Err(VMError::DivisionByZero); } *l / r },
|
||||
_ => return Err(VMError::InvalidInstruction(format!("Unsupported integer operation: {:?}", op))),
|
||||
};
|
||||
Ok(VMValue::Integer(res))
|
||||
}
|
||||
|
||||
_ => Err(VMError::TypeError(format!("Unsupported binary operation: {:?} on {:?} and {:?}", op, left, right))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Execute unary operation
|
||||
pub(super) fn execute_unary_op(&self, op: &UnaryOp, operand: &VMValue) -> Result<VMValue, VMError> {
|
||||
match (op, operand) {
|
||||
(UnaryOp::Neg, VMValue::Integer(i)) => Ok(VMValue::Integer(-i)),
|
||||
(UnaryOp::Not, VMValue::Bool(b)) => Ok(VMValue::Bool(!b)),
|
||||
_ => Err(VMError::TypeError(format!("Unsupported unary operation: {:?} on {:?}", op, operand))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Execute comparison operation
|
||||
pub(super) fn execute_compare_op(&self, op: &CompareOp, left: &VMValue, right: &VMValue) -> Result<bool, VMError> {
|
||||
match (left, right) {
|
||||
// Mixed numeric
|
||||
(VMValue::Integer(l), VMValue::Float(r)) => {
|
||||
let l = *l as f64; let r = *r; Ok(match op { CompareOp::Eq => l == r, CompareOp::Ne => l != r, CompareOp::Lt => l < r, CompareOp::Le => l <= r, CompareOp::Gt => l > r, CompareOp::Ge => l >= r })
|
||||
}
|
||||
(VMValue::Float(l), VMValue::Integer(r)) => {
|
||||
let l = *l; let r = *r as f64; Ok(match op { CompareOp::Eq => l == r, CompareOp::Ne => l != r, CompareOp::Lt => l < r, CompareOp::Le => l <= r, CompareOp::Gt => l > r, CompareOp::Ge => l >= r })
|
||||
}
|
||||
// Bool
|
||||
(VMValue::Bool(l), VMValue::Bool(r)) => {
|
||||
Ok(match op { CompareOp::Eq => l == r, CompareOp::Ne => l != r, _ => return Err(VMError::TypeError(format!("Unsupported boolean comparison: {:?}", op))) })
|
||||
}
|
||||
// Void
|
||||
(VMValue::Void, VMValue::Void) => {
|
||||
Ok(match op { CompareOp::Eq => true, CompareOp::Ne => false, _ => return Err(VMError::TypeError("Cannot order Void".to_string())) })
|
||||
}
|
||||
(VMValue::Void, _) | (_, VMValue::Void) => {
|
||||
Ok(match op { CompareOp::Eq => false, CompareOp::Ne => true, _ => return Err(VMError::TypeError("Cannot order Void".to_string())) })
|
||||
}
|
||||
// Homogeneous
|
||||
(VMValue::Integer(l), VMValue::Integer(r)) => Ok(match op { CompareOp::Eq => l == r, CompareOp::Ne => l != r, CompareOp::Lt => l < r, CompareOp::Le => l <= r, CompareOp::Gt => l > r, CompareOp::Ge => l >= r }),
|
||||
(VMValue::Float(l), VMValue::Float(r)) => Ok(match op { CompareOp::Eq => l == r, CompareOp::Ne => l != r, CompareOp::Lt => l < r, CompareOp::Le => l <= r, CompareOp::Gt => l > r, CompareOp::Ge => l >= r }),
|
||||
(VMValue::String(l), VMValue::String(r)) => Ok(match op { CompareOp::Eq => l == r, CompareOp::Ne => l != r, CompareOp::Lt => l < r, CompareOp::Le => l <= r, CompareOp::Gt => l > r, CompareOp::Ge => l >= r }),
|
||||
_ => Err(VMError::TypeError(format!("Unsupported comparison: {:?} on {:?} and {:?}", op, left, right))),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user