Merge branch 'master' into add_check_byte_value

Author: OddCoincidence

tests/snippets/bytearray.py

@@ -37,6 +37,25 @@
 try:
     bytearray([400])
 except ValueError:
+      pass
+else:
+    assert False
+
+b = bytearray(b'test')
+assert len(b) == 4
+b.pop()
+assert len(b) == 3
+
+c = bytearray([123, 255, 111])
+assert len(c) == 3
+c.pop()
+assert len(c) == 2
+c.pop()
+c.pop()
+
+try:
+    c.pop()
+except IndexError:
     pass
 else:
     assert False

tests/snippets/control_flow.py

@@ -1,3 +1,5 @@
+# break from a nested for loop
+
 def foo():
     sum = 0
     for i in range(10):
@@ -8,3 +10,24 @@ def foo():
     return sum
 
 assert foo() == 45
+
+
+# continue statement
+
+def primes(limit):
+    """Finds all the primes from 2 up to a given number using the Sieve of Eratosthenes."""
+    sieve = [False] * (limit + 1)
+    for i in range(2, limit + 1):
+        if sieve[i]:
+            continue
+        yield i
+
+        for j in range(2 * i, limit + 1, i):
+            sieve[j] = True
+
+
+assert list(primes(1)) == []
+assert list(primes(2)) == [2]
+assert list(primes(10)) == [2, 3, 5, 7]
+assert list(primes(13)) == [2, 3, 5, 7, 11, 13]
+

vm/src/frame.rs

@@ -542,7 +542,10 @@ impl Frame {
             bytecode::Instruction::Break => {
                 let block = self.unwind_loop(vm);
                 if let BlockType::Loop { end, .. } = block.typ {
+                    self.pop_block();
                     self.jump(end);
+                } else {
+                    unreachable!()
                 }
                 Ok(None)
             }
@@ -555,7 +558,7 @@ impl Frame {
                 if let BlockType::Loop { start, .. } = block.typ {
                     self.jump(start);
                 } else {
-                    assert!(false);
+                    unreachable!();
                 }
                 Ok(None)
             }
@@ -745,7 +748,7 @@ impl Frame {
 
     fn unwind_loop(&mut self, vm: &mut VirtualMachine) -> Block {
         loop {
-            let block = self.pop_block().expect("not in a loop");
+            let block = self.current_block().cloned().expect("not in a loop");
             match block.typ {
                 BlockType::Loop { .. } => break block,
                 BlockType::TryExcept { .. } => {
@@ -760,6 +763,8 @@ impl Frame {
                     }
                 },
             }
+
+            self.pop_block();
         }
     }
 
@@ -1080,6 +1085,10 @@ impl Frame {
         Some(block)
     }
 
+    fn current_block(&self) -> Option<&Block> {
+        self.blocks.last()
+    }
+
     pub fn push_value(&mut self, obj: PyObjectRef) {
         self.stack.push(obj);
     }

vm/src/obj/objbytearray.rs

@@ -7,6 +7,7 @@ use super::super::pyobject::{
 use super::objint;
 
 use super::super::vm::VirtualMachine;
+use super::objbytes::get_mut_value;
 use super::objbytes::get_value;
 use super::objtype;
 use num_traits::ToPrimitive;
@@ -100,6 +101,7 @@ pub fn init(context: &PyContext) {
         "clear",
         context.new_rustfunc(bytearray_clear),
     );
+    context.set_attr(&bytearray_type, "pop", context.new_rustfunc(bytearray_pop));
 }
 
 fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -282,3 +284,14 @@ fn bytearray_clear(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         _ => panic!("Bytearray has incorrect payload."),
     }
 }
+
+fn bytearray_pop(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(obj, Some(vm.ctx.bytearray_type()))]);
+    let mut value = get_mut_value(obj);
+
+    if let Some(i) = value.pop() {
+        Ok(vm.ctx.new_int(i))
+    } else {
+        Err(vm.new_index_error("pop from empty bytearray".to_string()))
+    }
+}

vm/src/obj/objbytes.rs

@@ -6,8 +6,10 @@ use super::objint;
 use super::objtype;
 use num_traits::ToPrimitive;
 use std::cell::Ref;
+use std::cell::RefMut;
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
+use std::ops::DerefMut;
 
 // Binary data support
 
@@ -183,7 +185,17 @@ pub fn get_value<'a>(obj: &'a PyObjectRef) -> impl Deref<Target = Vec<u8>> + 'a
         if let PyObjectPayload::Bytes { ref value } = py_obj.payload {
             value
         } else {
-            panic!("Inner error getting int {:?}", obj);
+            panic!("Inner error getting bytearray {:?}", obj);
+        }
+    })
+}
+
+pub fn get_mut_value<'a>(obj: &'a PyObjectRef) -> impl DerefMut<Target = Vec<u8>> + 'a {
+    RefMut::map(obj.borrow_mut(), |py_obj| {
+        if let PyObjectPayload::Bytes { ref mut value } = py_obj.payload {
+            value
+        } else {
+            panic!("Inner error getting bytearray {:?}", obj);
         }
     })
 }