Add basic exception support.

progval · progval · commit 86a59fe8e033 · 2016-04-20T20:30:14.000+02:00
diff --git a/functional_tests/catch_exception_in_function.py b/functional_tests/catch_exception_in_function.py
@@ -0,0 +1,51 @@
+class Foo(BaseException):
+    pass
+class Bar(BaseException):
+    pass
+
+def raise_foo():
+    raise Foo()
+
+def raise_bar():
+    raise Bar()
+
+try:
+    raise_foo()
+except:
+    print('raised')
+else:
+    print('not raised')
+
+print('----')
+
+try:
+    raise_foo()
+except Foo:
+    print('raised Foo')
+else:
+    print('not raised')
+
+print('----')
+
+try:
+    raise_foo()
+except Foo:
+    print('raised Foo')
+except Bar:
+    print('raised Bar')
+else:
+    print('not raised')
+
+print('----')
+
+try:
+    raise_bar()
+except Foo:
+    print('raised Foo')
+except Bar:
+    print('raised Bar')
+else:
+    print('not raised')
+
+print('----')
+
diff --git a/functional_tests/catch_exceptions.py b/functional_tests/catch_exceptions.py
@@ -0,0 +1,53 @@
+class Foo(BaseException):
+    pass
+class Bar(BaseException):
+    pass
+
+try:
+    raise Foo()
+except:
+    print('raised')
+else:
+    print('not raised')
+
+print('----')
+
+try:
+    pass
+except:
+    print('raised')
+else:
+    print('not raised')
+
+print('----')
+
+try:
+    raise Foo()
+except Foo:
+    print('raised Foo')
+else:
+    print('not raised')
+
+print('----')
+
+try:
+    raise Foo()
+except Foo:
+    print('raised Foo')
+except Bar:
+    print('raised Bar')
+else:
+    print('not raised')
+
+print('----')
+
+try:
+    raise Bar()
+except Foo:
+    print('raised Foo')
+except Bar:
+    print('raised Bar')
+else:
+    print('not raised')
+
+print('----')
diff --git a/pythonlib/builtins.py b/pythonlib/builtins.py
@@ -1,3 +1,6 @@
+BaseException = __primitives__.BaseException
+RuntimeError = __primitives__.RuntimeError
+
 def print(value):
     __primitives__.write_stdout(value)
     __primitives__.write_stdout("\n")
diff --git a/src/objects/mod.rs b/src/objects/mod.rs
@@ -163,6 +163,9 @@ pub struct PrimitiveObjects {
     pub function_type: ObjectRef,
     pub code_type: ObjectRef,
 
+    pub baseexception: ObjectRef,
+    pub runtimeerror: ObjectRef,
+
     pub names_map: HashMap<String, ObjectRef>,
 }
 
@@ -193,6 +196,9 @@ impl PrimitiveObjects {
         let function_type = store.allocate(Object::new_class("function".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
         let code_type = store.allocate(Object::new_class("code".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
 
+        let baseexception = store.allocate(Object::new_class("BaseException".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
+        let runtimeerror = store.allocate(Object::new_class("RuntimeError".to_string(), None, type_ref.clone(), vec![baseexception.clone()]));
+
         let mut map = HashMap::new();
         map.insert("object".to_string(), obj_ref.clone());
         map.insert("tuple".to_string(), type_ref.clone());
@@ -210,6 +216,8 @@ impl PrimitiveObjects {
         map.insert("str".to_string(), str_type.clone());
         map.insert("function".to_string(), function_type.clone());
         map.insert("code".to_string(), code_type.clone());
+        map.insert("BaseException".to_string(), baseexception.clone());
+        map.insert("RuntimeError".to_string(), runtimeerror.clone());
 
         PrimitiveObjects {
             object: obj_ref, type_: type_ref,
@@ -219,6 +227,7 @@ impl PrimitiveObjects {
             set_type: set_type, frozenset_type: frozenset_type,
             bytes_type: bytes_type, str_type: str_type,
             function_type: function_type, code_type: code_type,
+            baseexception: baseexception, runtimeerror: runtimeerror,
             names_map: map,
         }
     }
diff --git a/src/processor/instructions.rs b/src/processor/instructions.rs
@@ -37,21 +37,27 @@ impl CmpOperator {
 #[derive(Debug)]
 pub enum Instruction {
     PopTop,
+    DupTop,
     Nop,
     BinarySubscr,
     LoadBuildClass,
     ReturnValue,
+    PopBlock,
+    EndFinally,
+    PopExcept,
     StoreName(usize),
     LoadConst(usize),
     LoadName(usize),
     LoadAttr(usize),
     SetupLoop(usize),
+    SetupExcept(usize),
     CompareOp(CmpOperator),
     JumpForward(usize),
     PopJumpIfFalse(usize),
     LoadFast(usize),
     LoadGlobal(usize),
     CallFunction(usize, usize), // nb_args, nb_kwargs
+    RaiseVarargs(u16),
     MakeFunction(usize, usize, usize), // nb_default_args, nb_default_kwargs, nb_annot
 }
 
@@ -98,9 +104,13 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
         self.bytestream.next().map(|opcode| {
             match *opcode {
                 1 => Instruction::PopTop,
+                4 => Instruction::DupTop,
                 25 => Instruction::BinarySubscr,
                 71 => Instruction::LoadBuildClass,
                 83 => Instruction::ReturnValue,
+                87 => Instruction::PopBlock,
+                88 => Instruction::EndFinally,
+                89 => Instruction::PopExcept,
                 90 => Instruction::StoreName(self.read_argument() as usize),
                 100 => Instruction::LoadConst(self.read_argument() as usize),
                 101 => Instruction::LoadName(self.read_argument() as usize),
@@ -109,8 +119,10 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
                 110 => Instruction::JumpForward(self.read_argument() as usize + 2), // +2, because JumpForward takes 3 bytes, and the relative address is computed from the next instruction.
                 114 => Instruction::PopJumpIfFalse(self.read_argument() as usize),
                 116 => Instruction::LoadGlobal(self.read_argument() as usize),
-                120 => Instruction::SetupLoop(self.read_argument() as usize),
+                120 => Instruction::SetupLoop(self.read_argument() as usize + 2),
+                121 => Instruction::SetupExcept(self.read_argument() as usize + 2),
                 124 => Instruction::LoadFast(self.read_argument() as usize),
+                130 => Instruction::RaiseVarargs(self.read_argument() as u16),
                 131 => Instruction::CallFunction(self.read_byte() as usize, self.read_byte() as usize),
                 132 => {
                     let arg = self.read_argument();
diff --git a/src/processor/mod.rs b/src/processor/mod.rs
@@ -34,21 +34,21 @@ impl fmt::Display for ProcessorError {
 #[derive(Debug)]
 pub enum PyResult {
     Return(ObjectRef),
-    Raise(ObjectRef),
+    Raise(ObjectRef, ObjectRef), // (exception, exc_type)
 }
 
 
 pub type PyFunction<EP> = fn(&mut Processor<EP>, Vec<ObjectRef>) -> Result<PyResult, ProcessorError>;
 
 #[derive(Debug)]
-struct Loop {
-    begin: usize,
-    end: usize,
+enum Block {
+    Loop(usize, usize), // begin, end
+    TryExcept(usize, usize), // begin, end
 }
 
 struct Stacks {
     var_stack: VectorStack<ObjectRef>,
-    loop_stack: VectorStack<Loop>,
+    block_stack: VectorStack<Block>,
 }
 
 macro_rules! pop_stack {
@@ -57,6 +57,34 @@ macro_rules! pop_stack {
     }
 }
 
+macro_rules! raise {
+    ($stacks: expr, $program_counter: ident, $traceback: expr, $exception: expr, $exc_type: expr, $value: expr) => {{
+        loop {
+            match $stacks.block_stack.pop() {
+                None => { // Root block; raise exception to calling function
+                    return Ok(PyResult::Raise($exception, $exc_type))
+                }
+                Some(Block::TryExcept(begin, end)) => { // Found a try…except block
+                    $stacks.block_stack.push(Block::TryExcept(begin, end)); // Push it back, it will be poped by PopExcept.
+                    $program_counter = end;
+                    let traceback = $traceback;
+                    let exception = $exception;
+                    $stacks.var_stack.push(traceback.clone()); // traceback
+                    $stacks.var_stack.push(exception.clone()); // exception
+                    $stacks.var_stack.push($exc_type); // exception type
+
+                    $stacks.var_stack.push(traceback); // traceback
+                    $stacks.var_stack.push($value); // value
+                    $stacks.var_stack.push(exception); // exception
+                    break
+                }
+                Some(_) => { // Non-try…except block, exit it.
+                }
+            }
+        }
+    }}
+}
+
 pub struct Processor<EP: EnvProxy> {
     pub envproxy: EP,
     pub store: ObjectStore,
@@ -169,7 +197,7 @@ impl<EP: EnvProxy> Processor<EP> {
         let bytecode: Vec<u8> = code.code;
         let instructions: Vec<Instruction> = instructions::InstructionDecoder::new(bytecode.iter()).into_iter().collect();
         let mut program_counter = 0 as usize;
-        let mut stacks = Stacks { var_stack: VectorStack::new(), loop_stack: VectorStack::new() };
+        let mut stacks = Stacks { var_stack: VectorStack::new(), block_stack: VectorStack::new() };
         loop {
             let instruction = try!(instructions.get(program_counter).ok_or(ProcessorError::InvalidProgramCounter));
             program_counter += 1;
@@ -178,6 +206,11 @@ impl<EP: EnvProxy> Processor<EP> {
                     pop_stack!(stacks.var_stack);
                     ()
                 },
+                Instruction::DupTop => {
+                    let val = pop_stack!(stacks.var_stack);
+                    stacks.var_stack.push(val.clone());
+                    stacks.var_stack.push(val);
+                }
                 Instruction::Nop => (),
                 Instruction::BinarySubscr => {
                     let index_ref = pop_stack!(stacks.var_stack);
@@ -199,6 +232,24 @@ impl<EP: EnvProxy> Processor<EP> {
                     stacks.var_stack.push(self.store.allocate(obj));
                 }
                 Instruction::ReturnValue => return Ok(PyResult::Return(pop_stack!(stacks.var_stack))),
+                Instruction::PopBlock => { pop_stack!(stacks.block_stack); },
+                Instruction::EndFinally => {
+                    let status_ref = pop_stack!(stacks.var_stack);
+                    let status = self.store.deref(&status_ref);
+                    match status.content {
+                        ObjectContent::Int(i) => panic!("TODO: finally int status"), // TODO
+                        ObjectContent::OtherObject => {}
+                        _ => panic!("Invalid finally status")
+                    }
+                }
+                Instruction::PopExcept => {
+                    let mut three_last = stacks.var_stack.pop_all_and_get_n_last(3).unwrap(); // TODO: check
+                    let exc_type = three_last.pop();
+                    let exc_value = three_last.pop();
+                    let exc_traceback = three_last.pop();
+                    // TODO: do something with exc_*
+                    pop_stack!(stacks.block_stack);
+                },
                 Instruction::StoreName(i) => {
                     let name = try!(code.names.get(i).ok_or(ProcessorError::InvalidNameIndex)).clone();
                     let obj_ref = pop_stack!(stacks.var_stack);
@@ -218,10 +269,13 @@ impl<EP: EnvProxy> Processor<EP> {
                     stacks.var_stack.push(try!(self.load_attr(&obj, name)))
                 },
                 Instruction::SetupLoop(i) => {
-                    stacks.loop_stack.push(Loop { begin: program_counter, end: program_counter+i })
+                    stacks.block_stack.push(Block::Loop(program_counter, program_counter+i))
+                }
+                Instruction::SetupExcept(i) => {
+                    stacks.block_stack.push(Block::TryExcept(program_counter, program_counter+i))
                 }
                 Instruction::CompareOp(CmpOperator::Eq) => {
-                    // TODO: enhance this
+                    // TODO: enrich this (support __eq__)
                     let obj1 = self.store.deref(&pop_stack!(stacks.var_stack));
                     let obj2 = self.store.deref(&pop_stack!(stacks.var_stack));
                     if obj1.name == obj2.name && obj1.content == obj2.content {
@@ -231,6 +285,17 @@ impl<EP: EnvProxy> Processor<EP> {
                         stacks.var_stack.push(self.primitive_objects.false_obj.clone())
                     };
                 }
+                Instruction::CompareOp(CmpOperator::ExceptionMatch) => {
+                    // TODO: add support for tuples
+                    let pattern_ref = pop_stack!(stacks.var_stack);
+                    let exc_ref = pop_stack!(stacks.var_stack);
+                    let isinstance = self.primitive_functions.get("isinstance").unwrap().clone();
+                    let res = try!(isinstance(self, vec![exc_ref, pattern_ref]));
+                    match res {
+                        PyResult::Return(v) => stacks.var_stack.push(v),
+                        _ => panic!("Unexpected result of isinstance()")
+                    }
+                }
                 Instruction::JumpForward(delta) => {
                     program_counter += delta
                 }
@@ -247,6 +312,23 @@ impl<EP: EnvProxy> Processor<EP> {
                     }
                 }
 
+                Instruction::RaiseVarargs(0) => {
+                    panic!("RaiseVarargs(0) not implemented.")
+                }
+                Instruction::RaiseVarargs(1) => {
+                    let exception = pop_stack!(stacks.var_stack);
+                    let exc_type = exception.clone();
+                    // TODO: add traceback
+                    raise!(stacks, program_counter, self.primitive_objects.none.clone(), exception, exc_type, self.primitive_objects.none.clone());
+                }
+                Instruction::RaiseVarargs(2) => {
+                    panic!("RaiseVarargs(2) not implemented.")
+                }
+                Instruction::RaiseVarargs(_) => {
+                    // Note: the doc lies, the argument can only be ≤ 2
+                    panic!("Bad RaiseVarargs argument") // TODO: Raise an exception instead
+                }
+
                 Instruction::CallFunction(nb_args, nb_kwargs) => {
                     // See “Call constructs” at:
                     // http://security.coverity.com/blog/2014/Nov/understanding-python-bytecode.html
@@ -256,7 +338,10 @@ impl<EP: EnvProxy> Processor<EP> {
                     let ret = try!(self.call_function(namespace, &func, args, kwargs));
                     match ret {
                         PyResult::Return(obj_ref) => stacks.var_stack.push(obj_ref),
-                        PyResult::Raise(obj_ref) => return Ok(PyResult::Raise(obj_ref))
+                        PyResult::Raise(exception, exc_type) => {
+                            // TODO: add frame to traceback
+                            raise!(stacks, program_counter, self.primitive_objects.none.clone(), exception, exc_type, self.primitive_objects.none.clone())
+                        }
                     };
                 },
                 Instruction::MakeFunction(0, 0, 0) => {
diff --git a/src/stack.rs b/src/stack.rs
