added booleans

Author: mxgordon

Cargo.toml

@@ -11,5 +11,5 @@ mopa = "0.2.2"
 ahash = "0.8.11"
 
 [profile.release]
-#debug = true
+debug = true
 

flamegraph.svg

@@ -6,4 +6,5 @@ pub mod function_utils;
 pub mod globals;
 pub mod pyfloat;
 pub mod structure;
-pub mod functions;
+pub mod functions;
+pub mod pybool;

src/builtins.rs

@@ -3,16 +3,15 @@ use std::rc::Rc;
 use crate::builtins::object::expect_class;
 use crate::builtins::structure::magic_methods::PyMagicMethod;
 use crate::builtins::structure::pyclass::PyClass;
-use crate::builtins::structure::pyobject::{FuncReturnType, PyImmutableObject, PyInternalFunction, PyMutableObject, PyObject};
+use crate::builtins::structure::pyobject::{FuncReturnType, PyInternalFunction, PyInternalObject, PyMutableObject, PyObject};
 use crate::pyarena::PyArena;
 
 pub fn call_function(func: PyObject, args: &[PyObject], arena: &mut PyArena) -> FuncReturnType {
  match func {
- PyObject::Immutable(inner) => {
- match &*inner {
- PyImmutableObject::InternalSlot(func) => eval_internal_func(func.clone(), args, arena),
- PyImmutableObject::InternalClass(pyclass) => eval_obj_init(pyclass.clone(), args, arena),
- _ => {panic!("Immutable object is not a function")}
+ PyObject::Internal(inner) => {
+ match inner {
+ PyInternalObject::InternalFunction(func) => eval_internal_func(func, args, arena),
+ PyInternalObject::InternalClass(pyclass) => eval_obj_init(pyclass, args, arena)
  }
  }
  PyObject::Mutable(inner) => {
@@ -21,17 +20,16 @@ pub fn call_function(func: PyObject, args: &[PyObject], arena: &mut PyArena) ->
  _ => {panic!("Mutable object is not a function")}
  }
  }
- PyObject::IteratorFlag(_) => {panic!("IteratorFlag is not a function")}
+ other => {panic!("{:?} is not a function", other)}
  }
 }
 
 pub fn call_function_1_arg_min(func: PyObject, first_arg: &PyObject, args: &[PyObject], arena: &mut PyArena) -> FuncReturnType {
  match func {
- PyObject::Immutable(inner) => {
- match &*inner {
- PyImmutableObject::InternalSlot(func) => eval_internal_func_1_arg_min(func.clone(), first_arg, args, arena),
- PyImmutableObject::InternalClass(_pyclass) => panic!("This function should not be used to initialize a class"),
- _ => {panic!("Immutable object is not a function")}
+ PyObject::Internal(inner) => {
+ match inner {
+ PyInternalObject::InternalFunction(func) => eval_internal_func_1_arg_min(func, first_arg, args, arena),
+ PyInternalObject::InternalClass(_pyclass) => panic!("This function should not be used to initialize a class")
  }
  }
  PyObject::Mutable(inner) => {
@@ -40,7 +38,7 @@ pub fn call_function_1_arg_min(func: PyObject, first_arg: &PyObject, args: &[PyO
  _ => {panic!("Mutable object is not a function")}
  }
  }
- PyObject::IteratorFlag(_) => {panic!("IteratorFlag is not a function")}
+ other => {panic!("{:?} is not a function", other)}
  }
 }
 

src/builtins/function_utils.rs

@@ -1,2 +1,3 @@
 pub mod print;
-pub mod math_op;
+pub mod math_op;
+pub mod compare;

src/builtins/functions.rs

@@ -0,0 +1,76 @@
+use crate::builtins::function_utils::call_function_1_arg_min;
+use crate::builtins::structure::magic_methods::PyMagicMethod;
+use crate::builtins::structure::pyobject::{FuncReturnType, PyObject};
+use crate::parser::Comparitor;
+use crate::pyarena::PyArena;
+
+pub fn compare_op(left: &PyObject, right: &PyObject, comp: &Comparitor, arena: &mut PyArena) -> FuncReturnType {
+ match comp {
+ Comparitor::Equal => left_hand_compare_op(&PyMagicMethod::Eq, left, right, arena),
+ Comparitor::NotEqual => left_hand_compare_op(&PyMagicMethod::Ne, left, right, arena),
+ Comparitor::LessThan => left_hand_compare_op(&PyMagicMethod::Lt, left, right, arena),
+ Comparitor::LessThanOrEqual => left_hand_compare_op(&PyMagicMethod::Le, left, right, arena),
+ Comparitor::GreaterThan => left_hand_compare_op(&PyMagicMethod::Gt, left, right, arena),
+ Comparitor::GreaterThanOrEqual => left_hand_compare_op(&PyMagicMethod::Ge, left, right, arena),
+
+ Comparitor::Is => {todo!()}
+ Comparitor::IsNot => {todo!()}
+ Comparitor::In => {todo!()}
+ Comparitor::NotIn => {todo!()}
+ }
+}
+
+fn left_hand_compare_op(op: &PyMagicMethod, left: &PyObject, right: &PyObject, arena: &mut PyArena) -> FuncReturnType {
+ let left_compare_func = left.get_magic_method(op, arena);
+ 
+ if let Some(left_compare_func) = left_compare_func {
+ let left_compare = call_function_1_arg_min(left_compare_func, left, &[right.clone()], arena);
+
+ return match left_compare {
+ Ok(result) => Ok(result),
+ Err(err) => {
+ if err.is_same_type(&arena.exceptions.not_implemented_error) {
+ return right_hand_compare_op(op, left, right, arena)
+ }
+ Err(err)
+ },
+ };
+ }
+ 
+ right_hand_compare_op(op, left, right, arena)
+}
+
+fn right_hand_compare_op(op: &PyMagicMethod, left: &PyObject, right: &PyObject, arena: &mut PyArena) -> FuncReturnType {
+ let right_op = flip_to_right_hand_op(op);
+ let right_compare_func = right.get_magic_method(right_op, arena);
+ 
+ if let Some(right_compare_func) = right_compare_func {
+ let right_compare = call_function_1_arg_min(right_compare_func, right, &[left.clone()], arena);
+ 
+ return match right_compare {
+ Ok(result) => Ok(result),
+ Err(err) => {
+ if err.is_same_type(&arena.exceptions.not_implemented_error) {
+ let message = format!("'{}' not supported between instances of '{}' and '{}'", op, left.clone_class(arena).get_name(), right.clone_class(arena).get_name());
+ return Err(arena.exceptions.type_error.instantiate(message));
+ }
+ Err(err)
+ },
+ };
+ }
+ 
+ let message = format!("'{}' not supported between instances of '{}' and '{}'", op, left.clone_class(arena).get_name(), right.clone_class(arena).get_name());
+ Err(arena.exceptions.type_error.instantiate(message))
+}
+
+fn flip_to_right_hand_op(op: &PyMagicMethod) -> &PyMagicMethod {
+ match op {
+ PyMagicMethod::Eq => {&PyMagicMethod::Eq}
+ PyMagicMethod::Ne => {&PyMagicMethod::Ne}
+ PyMagicMethod::Lt => {&PyMagicMethod::Gt}
+ PyMagicMethod::Le => {&PyMagicMethod::Ge}
+ PyMagicMethod::Gt => {&PyMagicMethod::Lt}
+ PyMagicMethod::Ge => {&PyMagicMethod::Le}
+ e => {panic!("{} is not a handed compare operation", e)}
+ }
+}

src/builtins/functions/compare.rs

@@ -4,13 +4,13 @@ use crate::pyarena::PyArena;
 
 pub fn py_print(arena: &mut PyArena, args: &[PyObject]) -> FuncReturnType {
  let sep = " ";
- let mut strs = Vec::new();
 
- for arg in args {
- strs.push(py_str_tmp(arg, arena)?.expect_immutable().expect_string());
- }
+ let str_fold = args.iter().try_fold(Vec::new(), |mut acc, arg| {
+ acc.push(py_str_tmp(arg, arena)?.expect_immutable().expect_string());
+ Ok(acc)
+ })?;
 
- let result = strs.join(sep);
+ let result = str_fold.join(sep);
 
  println!("{}", result);
 

src/builtins/functions/print.rs

@@ -3,6 +3,7 @@ use std::rc::Rc;
 use ahash::AHashMap;
 use crate::builtins::object::{get_object_class};
 use crate::builtins::functions::print::{py_print};
+use crate::builtins::pybool::get_bool_class;
 use crate::builtins::pyfloat::get_float_class;
 use crate::builtins::pyint::{get_int_class};
 use crate::builtins::range::{get_range_class, get_range_iterator_class};
@@ -13,6 +14,7 @@ use crate::builtins::structure::pyobject::{ManyArgFuncType, PyInternalFunction,
 pub struct Globals {
  pub object_class: Rc<PyClass>,
  pub int_class: Rc<PyClass>,
+ pub bool_class: Rc<PyClass>,
  pub float_class: Rc<PyClass>,
  pub range_class: Rc<PyClass>,
  pub range_iterator_class: Rc<PyClass>,
@@ -22,15 +24,18 @@ pub struct Globals {
 impl Globals {
  pub(crate) fn new() -> Globals {
  let object_class = Rc::new(get_object_class());
- let int_class = Rc::new(get_int_class(object_class.clone()));
  let float_class = Rc::new(get_float_class(object_class.clone()));
+
+ let int_class = Rc::new(get_int_class(object_class.clone()));
+ let bool_class = Rc::new(get_bool_class(int_class.clone()));
 
  let range_class = Rc::new(get_range_class(object_class.clone()));
  let range_iterator_class = Rc::new(get_range_iterator_class(object_class.clone()));
 
  Globals {
  object_class,
  int_class,
+ bool_class,
  float_class,
  range_class,
  range_iterator_class,
@@ -42,6 +47,7 @@ impl Globals {
  vec![
  ("object".to_string(), Cell::new(PyObject::new_internal_class(self.object_class.clone()))),
  ("int".to_string(), Cell::new(PyObject::new_internal_class(self.int_class.clone()))),
+ ("bool".to_string(), Cell::new(PyObject::new_internal_class(self.bool_class.clone()))),
  ("float".to_string(), Cell::new(PyObject::new_internal_class(self.float_class.clone()))),
  ("range".to_string(), Cell::new(PyObject::new_internal_class(self.range_class.clone()))),
  ("print".to_string(), Cell::new(PyObject::new_internal_func(self.print_func.clone()))),

src/builtins/globals.rs

@@ -1,17 +1,18 @@
+#![allow(non_snake_case)]
 use std::rc::Rc;
 use ahash::AHashMap;
 use crate::builtins::function_utils::call_function;
 use crate::builtins::structure::magic_methods::{py_magic_methods_defaults, PyMagicMethod, PyMagicMethods};
 use crate::builtins::structure::pyclass::PyClass;
 use crate::builtins::structure::pyinstance::PyInstance;
-use crate::builtins::structure::pyobject::{InitFuncType, EmptyFuncReturnType, FuncReturnType, NewFuncType, UnaryFuncType, PyObject, PyMutableObject, PyImmutableObject};
+use crate::builtins::structure::pyobject::{InitFuncType, EmptyFuncReturnType, FuncReturnType, NewFuncType, UnaryFuncType, PyObject, PyMutableObject, PyImmutableObject, PyInternalObject};
 use crate::builtins::structure::pyobject::PyInternalFunction::{InitFunc, NewFunc, UnaryFunc};
 use crate::pyarena::PyArena;
 
 
 pub fn expect_class(pyobj: &PyObject) -> Rc<PyClass> {
- match **pyobj.expect_immutable() {
- PyImmutableObject::InternalClass(ref class) => class.clone(),
+ match pyobj.expect_internal() {
+ PyInternalObject::InternalClass(class) => class.clone(),
  _ => panic!("Expected class"),
  }
 }

src/builtins/object.rs

@@ -0,0 +1,70 @@
+#![allow(non_snake_case)]
+use std::rc::Rc;
+use ahash::AHashMap;
+use crate::builtins::function_utils::call_function_1_arg_min;
+use crate::builtins::structure::magic_methods::{py_magic_methods_defaults, PyMagicMethod, PyMagicMethods};
+use crate::builtins::structure::pyclass::PyClass;
+use crate::builtins::structure::pyexception::PyException;
+use crate::builtins::structure::pyobject::{FuncReturnType, NewFuncType, PyImmutableObject, PyObject, UnaryFuncType};
+use crate::builtins::structure::pyobject::PyInternalFunction::{NewFunc, UnaryFunc};
+use crate::pyarena::PyArena;
+
+
+pub fn expect_bool(pyobj: &PyObject, arena: &mut PyArena) -> Result<bool, PyException> {
+ match **pyobj.expect_immutable() {
+ PyImmutableObject::Bool(ref value) => {Ok(*value)}
+ ref value => {
+ let message = format!("'{}' object cannot be interpreted as a boolean", value.get_class(arena).get_name());
+ Err(arena.exceptions.type_error.instantiate(message))
+ },
+ }
+}
+
+
+pub fn bool__new__(arena: &mut PyArena, _pyclass: Rc<PyClass>, pyargs: &[PyObject]) -> FuncReturnType { // error handling
+ let value = pyargs.first().unwrap();
+ let bool_magic_method = value.expect_immutable().get_magic_method(&PyMagicMethod::Bool, arena);
+ let bool_magic_method = bool_magic_method.unwrap_or_else(|| panic!("Object has no __str__ method"));
+ let py_bool_value = call_function_1_arg_min(bool_magic_method, value, &[], arena)?;
+ 
+ let _bool_value = expect_bool(&py_bool_value, arena)?;
+ 
+ Ok(py_bool_value)
+}
+
+
+pub fn bool__repr__(arena: &mut PyArena, pyself: &PyObject) -> FuncReturnType {
+ let value = expect_bool(&pyself, arena)?;
+ Ok(PyObject::new_string(if value { "True".to_string() } else {"False".to_string()}))
+}
+
+pub fn bool__bool__(arena: &mut PyArena, pyself: &PyObject) -> FuncReturnType {
+ let value = expect_bool(&pyself, arena)?;
+ Ok(PyObject::new_bool(value))
+}
+
+pub fn bool__int__(arena: &mut PyArena, pyself: &PyObject) -> FuncReturnType {
+ let value = expect_bool(&pyself, arena)?;
+ Ok(PyObject::new_int(value as i64))
+}
+
+
+
+pub fn get_bool_class(int_class: Rc<PyClass>) -> PyClass {
+ PyClass::Internal {
+ name: "bool".to_string(),
+ super_classes: vec![int_class],
+ attributes: AHashMap::new(),
+ magic_methods: PyMagicMethods {
+ __new__: Some(Rc::new(NewFunc(&(bool__new__ as NewFuncType)))),
+
+ __repr__: Some(Rc::new(UnaryFunc(&(bool__repr__ as UnaryFuncType)))),
+ 
+ __bool__: Some(Rc::new(UnaryFunc(&(bool__bool__ as UnaryFuncType)))),
+ __int__: Some(Rc::new(UnaryFunc(&(bool__int__ as UnaryFuncType)))),
+
+ ..py_magic_methods_defaults()
+ }
+ }.create()
+}
+