Add BaseException class

Author: windelbouwman

parser/src/ast.rs

@@ -83,6 +83,15 @@ pub enum Statement {
         body: Vec<LocatedStatement>,
         orelse: Option<Vec<LocatedStatement>>,
     },
+    Raise {
+        expression: Option<Expression>,
+    },
+    Try {
+        body: Vec<LocatedStatement>,
+        handlers: Vec<Expression>,
+        orelse: Option<Vec<LocatedStatement>>,
+        finalbody: Option<Vec<LocatedStatement>>,
+    },
     ClassDef {
         name: String,
         body: Vec<LocatedStatement>,

parser/src/python.lalrpop

@@ -123,7 +123,12 @@ FlowStatement: ast::LocatedStatement = {
       node: ast::Statement::Return { value: t},
     }
   },
-  // raise
+  <loc:@L> "raise" <t:Test?> => {
+    ast::LocatedStatement {
+      location: loc,
+      node: ast::Statement::Raise { expression: t },
+    }
+  },
   // yield
 };
 
@@ -552,6 +557,7 @@ extern {
         "not" => lexer::Tok::Not,
         "or" => lexer::Tok::Or,
         "pass" => lexer::Tok::Pass,
+        "raise" => lexer::Tok::Raise,
         "return" => lexer::Tok::Return,
         "while" => lexer::Tok::While,
         "with" => lexer::Tok::With,

vm/src/builtins.rs

@@ -345,6 +345,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     dict.insert(String::from("tuple"), ctx.tuple_type.clone());
     dict.insert(String::from("type"), ctx.type_type.clone());
     dict.insert(String::from("object"), ctx.object.clone());
+    dict.insert(String::from("BaseException"), ctx.base_exception_type.clone());
     let d2 = PyObject::new(PyObjectKind::Dict { elements: dict }, ctx.type_type.clone());
     let scope = PyObject::new(
         PyObjectKind::Scope {

vm/src/compile.rs

@@ -235,6 +235,20 @@ impl Compiler {
                 self.set_label(end_label);
                 self.emit(Instruction::PopBlock);
             }
+            ast::Statement::Raise { expression } => {
+                match expression {
+                    Some(value) => {
+                        self.compile_expression(value);
+                        self.emit(Instruction::Raise { argc: 1 });
+                    }
+                    None => {
+                        unimplemented!();
+                    }
+                }
+            }
+            ast::Statement::Try {..} => {
+                unimplemented!();
+            }
             ast::Statement::FunctionDef { name, args, body } => {
                 // Create bytecode for this function:
                 self.code_object_stack.push(CodeObject::new(args.to_vec()));

vm/src/exceptions.rs

@@ -0,0 +1,40 @@
+
+use std::collections::HashMap;
+use super::pyobject::{PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult};
+use super::vm::VirtualMachine;
+
+fn init(vm: &mut VirtualMachine, _args: PyFuncArgs) -> PyResult {
+    // TODO: Implement objint::str
+    Ok(vm.new_str("todo".to_string()))
+}
+
+pub fn create_base_exception_type(type_type: PyObjectRef, object_type: PyObjectRef) -> PyObjectRef {
+    let mut dict = HashMap::new();
+    dict.insert(
+        "__init__".to_string(),
+        PyObject::new(
+            PyObjectKind::RustFunction { function: init },
+            type_type.clone(),
+        ),
+    );
+    let typ = PyObject::new(
+        PyObjectKind::Class {
+            name: "BaseException".to_string(),
+            dict: PyObject::new(PyObjectKind::Dict { elements: dict }, type_type.clone()),
+            mro: vec![object_type],
+        },
+        type_type.clone(),
+    );
+    typ
+}
+
+/*
+ * TODO: create a whole exception hierarchy somehow?
+pub fn create_exception_zoo(context: &PyContext) {
+    let base_exception_type = PyObjectKind::Class {
+        name: String::from("Exception"),
+        dict: context.new_dict(),
+        mro: vec![object_type],
+    }.into_ref();
+}
+*/

vm/src/lib.rs

@@ -9,6 +9,7 @@ mod builtins;
 pub mod bytecode;
 pub mod compile;
 pub mod eval;
+mod exceptions;
 mod frame;
 mod import;
 mod objbool;

vm/src/pyobject.rs

@@ -1,4 +1,5 @@
 use super::bytecode;
+use super::exceptions;
 use super::objdict;
 use super::objfunction;
 use super::objint;
@@ -54,6 +55,7 @@ pub struct PyContext {
     pub bound_method_type: PyObjectRef,
     pub member_descriptor_type: PyObjectRef,
     pub object: PyObjectRef,
+    pub base_exception_type: PyObjectRef,
 }
 
 /*
@@ -95,21 +97,24 @@ impl PyContext {
             tuple_type: type_type.clone(),
             dict_type: dict_type.clone(),
             none: PyObject::new(PyObjectKind::None, type_type.clone()),
-            object: object_type,
+            object: object_type.clone(),
             function_type: function_type,
             bound_method_type: bound_method_type,
             member_descriptor_type: member_descriptor_type,
-            type_type: type_type,
+            type_type: type_type.clone(),
+            base_exception_type: exceptions::create_base_exception_type(type_type.clone(), object_type.clone()),
         };
         objtype::init(&context);
         objlist::init(&context);
         objobject::init(&context);
         objdict::init(&context);
+        // TODO: create exception hierarchy here?
+        // exceptions::create_zoo(&context);
         context
     }
 
     pub fn new_int(&self, i: i32) -> PyObjectRef {
-        PyObject::new(PyObjectKind::Integer { value: i }, self.type_type.clone())
+        PyObject::new(PyObjectKind::Integer { value: i }, self.int_type.clone())
     }
 
     pub fn new_float(&self, i: f64) -> PyObjectRef {
@@ -127,7 +132,7 @@ impl PyContext {
     pub fn new_tuple(&self, elements: Vec<PyObjectRef>) -> PyObjectRef {
         PyObject::new(
             PyObjectKind::Tuple { elements: elements },
-            self.type_type.clone(),
+            self.tuple_type.clone(),
         )
     }
 

vm/src/vm.rs

@@ -227,8 +227,14 @@ impl VirtualMachine {
                 Some(Err(exception)) => {
                     // unwind block stack on exception and find any handlers.
                     match self.unwind_exception(exception) {
-                        None => {}
-                        Some(exception) => break Err(exception),
+                        None => {
+                        },
+                        Some(exception) => {
+                            let _traceback = self.get_attribute(exception.clone(), &"__traceback__".to_string());
+                            // TODO: append line number to traceback?
+                            // traceback.append();
+                            break Err(exception)
+                        },
                     }
                 }
             }
@@ -760,7 +766,7 @@ impl VirtualMachine {
                     0 | 2 | 3 => panic!("Not implemented!"),
                     _ => panic!("Invalid paramter for RAISE_VARARGS, must be between 0 to 3"),
                 };
-                error!("{:?}", exception);
+                info!("Exception raised: {:?}", exception);
                 Some(Err(exception))
             }