ByteArray Usage

Author: rmliddle

tests/snippets/os_open.py

@@ -0,0 +1,4 @@
+import os 
+
+assert os.open('README.md') > 0
+

tests/snippets/os_static.py

@@ -0,0 +1,8 @@
+import os 
+
+assert os.O_RDONLY == 0
+assert os.O_WRONLY == 1
+assert os.O_RDWR == 2
+assert os.O_NONBLOCK == 3
+assert os.O_APPEND == 8
+assert os.O_CREAT == 512

vm/src/obj/objbytes.rs

@@ -20,7 +20,6 @@ pub fn init(context: &PyContext) {
     context.set_attr(bytes_type, "__new__", context.new_rustfunc(bytes_new));
     context.set_attr(bytes_type, "__repr__", context.new_rustfunc(bytes_repr));
     context.set_attr(bytes_type, "__len__", context.new_rustfunc(bytes_len));
-
 }
 
 fn bytes_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -70,18 +69,13 @@ fn bytes_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 }
 
 fn bytes_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(
-        vm,
-        args,
-        required = [(a, Some(vm.ctx.bytes_type()))]
-    );
+    arg_check!(vm, args, required = [(a, Some(vm.ctx.bytes_type()))]);
 
     let byte_vec = get_value(a).to_vec();
     let value = byte_vec.len().to_bigint();
     Ok(vm.ctx.new_int(value.unwrap()))
 }
 
-
 fn bytes_hash(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytes_type()))]);
     let data = get_value(zelf);

vm/src/obj/objmemory.rs

@@ -1,27 +1,26 @@
-
 use super::objtype;
 
 use super::super::pyobject::{
-    PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, TypeProtocol
+    PyContext, PyFuncArgs, PyObject, PyObjectKind, PyObjectRef, PyResult, TypeProtocol,
 };
 use super::super::vm::VirtualMachine;
 
-
 pub fn new_memory_view(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(
-        vm,
-        args,
-        required = [(cls, None), (bytes_object, None)]
-    );
+    arg_check!(vm, args, required = [(cls, None), (bytes_object, None)]);
     vm.ctx.set_attr(&cls, "obj", bytes_object.clone());
     Ok(PyObject::new(
-        PyObjectKind::MemoryView { obj: bytes_object.clone() },
-        cls.clone()
+        PyObjectKind::MemoryView {
+            obj: bytes_object.clone(),
+        },
+        cls.clone(),
     ))
-
 }
 
 pub fn init(ctx: &PyContext) {
     let ref memoryview_type = ctx.memoryview_type;
-    ctx.set_attr(&memoryview_type, "__new__", ctx.new_rustfunc(new_memory_view));
+    ctx.set_attr(
+        &memoryview_type,
+        "__new__",
+        ctx.new_rustfunc(new_memory_view),
+    );
 }

vm/src/pyobject.rs

@@ -146,8 +146,7 @@ fn _nothing() -> PyObjectRef {
     PyObject {
         kind: PyObjectKind::None,
         typ: None,
-    }
-    .into_ref()
+    }.into_ref()
 }
 
 pub fn create_type(
@@ -220,7 +219,7 @@ impl PyContext {
         );
         let context = PyContext {
             bool_type: bool_type,
-            memoryview_type : memoryview_type,
+            memoryview_type: memoryview_type,
             bytearray_type: bytearray_type,
             bytes_type: bytes_type,
             code_type: code_type,
@@ -412,7 +411,10 @@ impl PyContext {
     }
 
     pub fn new_bytearray(&self, data: Vec<u8>) -> PyObjectRef {
-        PyObject::new(PyObjectKind::Bytes { value: data }, self.bytearray_type())
+        PyObject::new(
+            PyObjectKind::ByteArray { value: data },
+            self.bytearray_type(),
+        )
     }
 
     pub fn new_bool(&self, b: bool) -> PyObjectRef {
@@ -464,8 +466,7 @@ impl PyContext {
         PyObject {
             kind: PyObjectKind::Scope { scope: scope },
             typ: None,
-        }
-        .into_ref()
+        }.into_ref()
     }
 
     pub fn new_module(&self, name: &str, scope: PyObjectRef) -> PyObjectRef {
@@ -745,6 +746,21 @@ impl DictProtocol for PyObjectRef {
     }
 }
 
+pub trait BufferProtocol {
+    fn readonly(&self) -> bool;
+}
+
+impl BufferProtocol for PyObjectRef {
+    fn readonly(&self) -> bool {
+        match self.borrow().kind {
+            PyObjectKind::Bytes { value: _ } => false,
+            PyObjectKind::ByteArray { value: _ } => true,
+            PyObjectKind::MemoryView { obj: _ } => true,
+            _ => panic!("Bytes-Like type expected not {:?}", self),
+        }
+    }
+}
+
 impl fmt::Debug for PyObject {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "[PyObj {:?}]", self.kind)
@@ -826,6 +842,9 @@ pub enum PyObjectKind {
     Bytes {
         value: Vec<u8>,
     },
+    ByteArray {
+        value: Vec<u8>,
+    },
     Sequence {
         elements: Vec<PyObjectRef>,
     },
@@ -845,7 +864,7 @@ pub enum PyObjectKind {
         step: Option<i32>,
     },
     MemoryView {
-        obj : PyObjectRef
+        obj: PyObjectRef,
     },
     Code {
         code: bytecode::CodeObject,
@@ -897,6 +916,7 @@ impl fmt::Debug for PyObjectKind {
             &PyObjectKind::Float { ref value } => write!(f, "float {}", value),
             &PyObjectKind::Complex { ref value } => write!(f, "complex {}", value),
             &PyObjectKind::Bytes { ref value } => write!(f, "bytes/bytearray {:?}", value),
+            &PyObjectKind::ByteArray { ref value } => write!(f, "bytes/bytearray {:?}", value),
             &PyObjectKind::MemoryView { ref obj } => write!(f, "bytes/bytearray {:?}", obj),
             &PyObjectKind::Sequence { elements: _ } => write!(f, "list or tuple"),
             &PyObjectKind::Dict { elements: _ } => write!(f, "dict"),
@@ -939,8 +959,7 @@ impl PyObject {
             kind: kind,
             typ: Some(typ),
             // dict: HashMap::new(),  // dict,
-        }
-        .into_ref()
+        }.into_ref()
     }
 
     /// Deprecated method, please call `vm.to_pystr`
@@ -951,6 +970,7 @@ impl PyObject {
             PyObjectKind::Float { ref value } => format!("{:?}", value),
             PyObjectKind::Complex { ref value } => format!("{:?}", value),
             PyObjectKind::Bytes { ref value } => format!("b'{:?}'", value),
+            PyObjectKind::ByteArray { ref value } => format!("b'{:?}'", value),
             PyObjectKind::MemoryView { ref obj } => format!("b'{:?}'", obj),
             PyObjectKind::Sequence { ref elements } => format!(
                 "(/[{}]/)",