From a5d106bdfddfe66ef93f7d201d1bc83cdaabcc59 Mon Sep 17 00:00:00 2001 From: Alek Ratzloff Date: Tue, 24 Sep 2024 12:46:45 -0700 Subject: [PATCH] Add not_implemented_{un,bin} functions, cleanup unused "not implemented" functions These are specifically functions for the BaseObjInst:: that need some kind of "not implemented" function for re-use. Signed-off-by: Alek Ratzloff --- src/builtins.rs | 84 ++++++++++++++++++------------------------------- src/obj.rs | 20 ++++++------ src/vm.rs | 2 +- 3 files changed, 42 insertions(+), 64 deletions(-) diff --git a/src/builtins.rs b/src/builtins.rs index 811c909..de9060b 100644 --- a/src/builtins.rs +++ b/src/builtins.rs @@ -78,33 +78,23 @@ pub(crate) fn print(vm: &mut Vm, state: FunctionState) -> FunctionResult { } } -// +//////////////////////////////////////////////////////////////////////////////// // Base function implementations -// +//////////////////////////////////////////////////////////////////////////////// impl BaseObjInst { - pub(crate) fn add(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __add__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) - } - - pub(crate) fn sub(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __sub__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) - } - - pub(crate) fn mul(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __mul__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) - } - - pub(crate) fn div(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __div__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) - } - pub(crate) fn and(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __and__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) + let lhs = vm.frame_stack()[0].borrow(); + let rhs = vm.frame_stack()[1].borrow(); + let result = lhs.is_truthy() && rhs.is_truthy(); + vm.create_bool(result).into() } pub(crate) fn or(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __or__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) + let lhs = vm.frame_stack()[0].borrow(); + let rhs = vm.frame_stack()[1].borrow(); + let result = lhs.is_truthy() || rhs.is_truthy(); + vm.create_bool(result).into() } pub(crate) fn ne(vm: &mut Vm, state: FunctionState) -> FunctionResult { @@ -139,36 +129,6 @@ impl BaseObjInst { vm.create_bool(equals).into() } - pub(crate) fn gt(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __gt__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) - } - - pub(crate) fn ge(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __ge__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) - } - - pub(crate) fn lt(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __lt__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) - } - - pub(crate) fn le(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!("Raise some kind of not implemented/not callable error for __le__ function (self: {}, rhs: {})", vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) - } - - pub(crate) fn pos(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!( - "Raise some kind of not implemented/not callable error for __pos__ function (self: {})", - vm.frame_stack()[0].borrow() - ) - } - - pub(crate) fn neg(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - todo!( - "Raise some kind of not implemented/not callable error for __neg__ function (self: {})", - vm.frame_stack()[0].borrow() - ) - } - pub(crate) fn not(vm: &mut Vm, state: FunctionState) -> FunctionResult { match state { FunctionState::Begin => { @@ -189,13 +149,31 @@ impl BaseObjInst { } } + pub(crate) fn to_repr(vm: &mut Vm, _state: FunctionState) -> FunctionResult { + let str_value = format!("{}", vm.frame_stack()[0].borrow()); + vm.create_str(str_value).into() + } + pub(crate) fn to_bool(vm: &mut Vm, _state: FunctionState) -> FunctionResult { vm.create_bool(vm.frame_stack()[0].borrow().is_truthy()) .into() } - pub(crate) fn to_repr(vm: &mut Vm, _state: FunctionState) -> FunctionResult { - let str_value = format!("{}", vm.frame_stack()[0].borrow()); - vm.create_str(str_value).into() + pub(crate) fn not_implemented_un(vm: &mut Vm, _state: FunctionState) -> FunctionResult { + let fname = &vm.frame().name; + todo!( + "Raise some kind of not implemented/not callable error for {} function (self: {})", + fname, + vm.frame_stack()[0].borrow() + ) + } + + pub(crate) fn not_implemented_bin(vm: &mut Vm, _state: FunctionState) -> FunctionResult { + let fname = &vm.frame().name; + todo!("Raise some kind of not implemented/not callable error for {} function (self: {}, rhs: {})", fname, vm.frame_stack()[0].borrow(), vm.frame_stack()[1].borrow()) } } + +//////////////////////////////////////////////////////////////////////////////// +// +//////////////////////////////////////////////////////////////////////////////// diff --git a/src/obj.rs b/src/obj.rs index de8eb3b..7fea000 100644 --- a/src/obj.rs +++ b/src/obj.rs @@ -120,20 +120,20 @@ pub fn init_types(builtins: &mut HashMap) { to_repr => builtins.create_builtin_function("to_repr", BaseObjInst::to_repr, 1), to_bool => builtins.create_builtin_function("to_bool", BaseObjInst::to_bool, 1), // Operators - __add__ => builtins.create_builtin_function("__add__", BaseObjInst::add, 2), - __sub__ => builtins.create_builtin_function("__sub__", BaseObjInst::sub, 2), - __mul__ => builtins.create_builtin_function("__mul__", BaseObjInst::mul, 2), - __div__ => builtins.create_builtin_function("__div__", BaseObjInst::div, 2), + __add__ => builtins.create_builtin_function("__add__", BaseObjInst::not_implemented_bin, 2), + __sub__ => builtins.create_builtin_function("__sub__", BaseObjInst::not_implemented_bin, 2), + __mul__ => builtins.create_builtin_function("__mul__", BaseObjInst::not_implemented_bin, 2), + __div__ => builtins.create_builtin_function("__div__", BaseObjInst::not_implemented_bin, 2), __and__ => builtins.create_builtin_function("__and__", BaseObjInst::and, 2), __or__ => builtins.create_builtin_function("__or__", BaseObjInst::or, 2), __ne__ => builtins.create_builtin_function("__ne__", BaseObjInst::ne, 2), __eq__ => builtins.create_builtin_function("__eq__", BaseObjInst::eq, 2), - __gt__ => builtins.create_builtin_function("__gt__", BaseObjInst::gt, 2), - __ge__ => builtins.create_builtin_function("__ge__", BaseObjInst::ge, 2), - __lt__ => builtins.create_builtin_function("__lt__", BaseObjInst::lt, 2), - __le__ => builtins.create_builtin_function("__le__", BaseObjInst::le, 2), - __pos__ => builtins.create_builtin_function("__pos__", BaseObjInst::pos, 1), - __neg__ => builtins.create_builtin_function("__neg__", BaseObjInst::neg, 1), + __gt__ => builtins.create_builtin_function("__gt__", BaseObjInst::not_implemented_bin, 2), + __ge__ => builtins.create_builtin_function("__ge__", BaseObjInst::not_implemented_bin, 2), + __lt__ => builtins.create_builtin_function("__lt__", BaseObjInst::not_implemented_bin, 2), + __le__ => builtins.create_builtin_function("__le__", BaseObjInst::not_implemented_bin, 2), + __pos__ => builtins.create_builtin_function("__pos__", BaseObjInst::not_implemented_un, 1), + __neg__ => builtins.create_builtin_function("__neg__", BaseObjInst::not_implemented_un, 1), __not__ => builtins.create_builtin_function("__not__", BaseObjInst::not, 1), }, Obj { }, diff --git a/src/vm.rs b/src/vm.rs index 43e9a6c..0f555c9 100644 --- a/src/vm.rs +++ b/src/vm.rs @@ -375,7 +375,7 @@ impl Vm { } Op::Return => { let return_value = self.pop(); - let old_frame = self.frames.pop().unwrap(); + let old_frame = self.pop_frame(); // stack_base is always going to be <= current stack size self.stack .resize_with(old_frame.stack_base, || unreachable!());