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 <alekratz@gmail.com>

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 {
+    pub(crate) fn not_implemented_un(vm: &mut Vm, _state: FunctionState) -> FunctionResult {
-        let str_value = format!("{}", vm.frame_stack()[0].borrow());
+        let fname = &vm.frame().name;
-        vm.create_str(str_value).into()
+        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())
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////

src/obj.rs

@@ -120,20 +120,20 @@ pub fn init_types(builtins: &mut HashMap<String, ObjP>) {
             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),
+            __add__ => builtins.create_builtin_function("__add__", BaseObjInst::not_implemented_bin, 2),
-            __sub__ => builtins.create_builtin_function("__sub__", BaseObjInst::sub, 2),
+            __sub__ => builtins.create_builtin_function("__sub__", BaseObjInst::not_implemented_bin, 2),
-            __mul__ => builtins.create_builtin_function("__mul__", BaseObjInst::mul, 2),
+            __mul__ => builtins.create_builtin_function("__mul__", BaseObjInst::not_implemented_bin, 2),
-            __div__ => builtins.create_builtin_function("__div__", BaseObjInst::div, 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),
+            __gt__ => builtins.create_builtin_function("__gt__", BaseObjInst::not_implemented_bin, 2),
-            __ge__ => builtins.create_builtin_function("__ge__", BaseObjInst::ge, 2),
+            __ge__ => builtins.create_builtin_function("__ge__", BaseObjInst::not_implemented_bin, 2),
-            __lt__ => builtins.create_builtin_function("__lt__", BaseObjInst::lt, 2),
+            __lt__ => builtins.create_builtin_function("__lt__", BaseObjInst::not_implemented_bin, 2),
-            __le__ => builtins.create_builtin_function("__le__", BaseObjInst::le, 2),
+            __le__ => builtins.create_builtin_function("__le__", BaseObjInst::not_implemented_bin, 2),
-            __pos__ => builtins.create_builtin_function("__pos__", BaseObjInst::pos, 1),
+            __pos__ => builtins.create_builtin_function("__pos__", BaseObjInst::not_implemented_un, 1),
-            __neg__ => builtins.create_builtin_function("__neg__", BaseObjInst::neg, 1),
+            __neg__ => builtins.create_builtin_function("__neg__", BaseObjInst::not_implemented_un, 1),
             __not__ => builtins.create_builtin_function("__not__", BaseObjInst::not, 1),
         },
         Obj { },

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!());