Merge branch 'master' into master

Author: silmeth

src/main.rs

@@ -7,7 +7,6 @@ extern crate log;
 extern crate rustpython_parser;
 extern crate rustpython_vm;
 extern crate rustyline;
-extern crate xdg;
 
 use clap::{App, Arg};
 use rustpython_parser::parser;
@@ -143,6 +142,22 @@ fn shell_exec(vm: &mut VirtualMachine, source: &str, scope: PyObjectRef) -> bool
     true
 }
 
+#[cfg(not(target_family = "unix"))]
+fn get_history_path() -> PathBuf {
+    //Path buffer
+    PathBuf::from(".repl_history.txt")
+}
+
+#[cfg(target_family = "unix")]
+fn get_history_path() -> PathBuf {
+    //work around for windows dependent builds. The xdg crate is unix specific
+    //so access to the BaseDirectories struct breaks builds on python.
+    extern crate xdg;
+
+    let xdg_dirs = xdg::BaseDirectories::with_prefix("rustpython").unwrap();
+    xdg_dirs.place_cache_file("repl_history.txt").unwrap()
+}
+
 fn run_shell(vm: &mut VirtualMachine) -> PyResult {
     println!(
         "Welcome to the magnificent Rust Python {} interpreter",
@@ -155,9 +170,8 @@ fn run_shell(vm: &mut VirtualMachine) -> PyResult {
     let mut input = String::new();
     let mut rl = Editor::<()>::new();
 
-    let xdg_dirs = xdg::BaseDirectories::with_prefix("rustpython").unwrap();
-    let repl_history_path = xdg_dirs.place_cache_file("repl_history.txt").unwrap();
-    let repl_history_path_str = repl_history_path.to_str().unwrap();
+    //retrieve a history_path_str dependent to the os
+    let repl_history_path_str = &get_history_path();
     if rl.load_history(repl_history_path_str).is_err() {
         println!("No previous history.");
     }

tests/snippets/bytearray.py

@@ -0,0 +1,31 @@
+#__getitem__ not implemented yet
+#a = bytearray(b'abc')
+#assert a[0] == b'a'
+#assert a[1] == b'b'
+
+assert len(bytearray([1,2,3])) == 3
+
+assert bytearray(b'1a23').isalnum()
+assert not bytearray(b'1%a23').isalnum()
+
+assert bytearray(b'abc').isalpha()
+assert not bytearray(b'abc1').isalpha()
+
+# travis doesn't like this
+#assert bytearray(b'xyz').isascii()
+#assert not bytearray([128, 157, 32]).isascii()
+
+assert bytearray(b'1234567890').isdigit()
+assert not bytearray(b'12ab').isdigit()
+
+assert bytearray(b'lower').islower()
+assert not bytearray(b'Super Friends').islower()
+
+assert bytearray(b' \n\t').isspace()
+assert not bytearray(b'\td\n').isspace()
+
+assert bytearray(b'UPPER').isupper()
+assert not bytearray(b'tuPpEr').isupper()
+
+assert bytearray(b'Is Title Case').istitle()
+assert not bytearray(b'is Not title casE').istitle()

tests/snippets/numbers.py

@@ -4,9 +4,11 @@
 
 assert int.__doc__ == "int(x=0) -> integer\nint(x, base=10) -> integer\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given.  If x is a number, return x.__int__().  For floating point\nnumbers, this truncates towards zero.\n\nIf x is not a number or if base is given, then x must be a string,\nbytes, or bytearray instance representing an integer literal in the\ngiven base.  The literal can be preceded by '+' or '-' and be surrounded\nby whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\nBase 0 means to interpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4"
 
+
 class A(int):
     pass
 
+
 x = A(7)
 assert x == 7
 assert type(x) is A
@@ -18,3 +20,10 @@ class A(int):
 assert int(0).__invert__() == -1
 assert int(-3).__invert__() == 2
 assert int(4).__invert__() == -5
+
+assert int(0).__rxor__(0) == 0
+assert int(1).__rxor__(0) == 1
+assert int(0).__rxor__(1) == 1
+assert int(1).__rxor__(1) == 0
+assert int(3).__rxor__(-3) == -2
+assert int(3).__rxor__(4) == 7

tests/snippets/tuple.py

@@ -15,3 +15,7 @@
 
 assert y < x, "tuple __lt__ failed"
 assert x > y, "tuple __gt__ failed"
+
+
+b = (1,2,3)
+assert b.index(2) == 1

vm/src/builtins.rs

@@ -238,7 +238,7 @@ fn builtin_eval(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     // TODO: handle optional globals
     // Construct new scope:
     let scope_inner = Scope {
-        locals: locals,
+        locals,
         parent: None,
     };
     let scope = PyObject {
@@ -288,7 +288,7 @@ fn builtin_exec(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
     // Construct new scope:
     let scope_inner = Scope {
-        locals: locals,
+        locals,
         parent: None,
     };
     let scope = PyObject {
@@ -359,7 +359,7 @@ fn builtin_hex(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 fn builtin_id(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(obj, None)]);
 
-    Ok(vm.context().new_int(obj.get_id().to_bigint().unwrap()))
+    Ok(vm.context().new_int(obj.get_id()))
 }
 
 // builtin_input
@@ -553,9 +553,7 @@ fn builtin_ord(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         )));
     }
     match string.chars().next() {
-        Some(character) => Ok(vm
-            .context()
-            .new_int((character as i32).to_bigint().unwrap())),
+        Some(character) => Ok(vm.context().new_int(character as i32)),
         None => Err(vm.new_type_error(
             "ord() could not guess the integer representing this character".to_string(),
         )),
@@ -635,7 +633,7 @@ fn builtin_sum(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let items = vm.extract_elements(iterable)?;
 
     // Start with zero and add at will:
-    let mut sum = vm.ctx.new_int(Zero::zero());
+    let mut sum = vm.ctx.new_int(0);
     for item in items {
         sum = vm._add(sum, item)?;
     }

vm/src/bytecode.rs

@@ -40,12 +40,12 @@ impl CodeObject {
             instructions: Vec::new(),
             label_map: HashMap::new(),
             locations: Vec::new(),
-            arg_names: arg_names,
-            varargs: varargs,
-            kwonlyarg_names: kwonlyarg_names,
-            varkeywords: varkeywords,
-            source_path: source_path,
-            obj_name: obj_name,
+            arg_names,
+            varargs,
+            kwonlyarg_names,
+            varkeywords,
+            source_path,
+            obj_name,
             is_generator: false,
         }
     }

vm/src/compile.rs

@@ -7,7 +7,7 @@
 //!   https://github.com/micropython/micropython/blob/master/py/compile.c
 
 use super::bytecode::{self, CallType, CodeObject, Instruction};
-use super::pyobject::{PyObject, PyObjectPayload, PyResult};
+use super::pyobject::PyResult;
 use super::vm::VirtualMachine;
 use num_complex::Complex64;
 use rustpython_parser::{ast, parser};
@@ -52,10 +52,7 @@ pub fn compile(
 
     let code = compiler.pop_code_object();
     trace!("Compilation completed: {:?}", code);
-    Ok(PyObject::new(
-        PyObjectPayload::Code { code: code },
-        vm.ctx.code_type(),
-    ))
+    Ok(vm.ctx.new_code_object(code))
 }
 
 pub enum Mode {
@@ -432,7 +429,7 @@ impl Compiler {
 
                 self.prepare_decorators(decorator_list)?;
                 self.emit(Instruction::LoadConst {
-                    value: bytecode::Constant::Code { code: code },
+                    value: bytecode::Constant::Code { code },
                 });
                 self.emit(Instruction::LoadConst {
                     value: bytecode::Constant::String {
@@ -441,7 +438,7 @@ impl Compiler {
                 });
 
                 // Turn code object into function object:
-                self.emit(Instruction::MakeFunction { flags: flags });
+                self.emit(Instruction::MakeFunction { flags });
                 self.apply_decorators(decorator_list);
 
                 self.emit(Instruction::StoreName {
@@ -477,7 +474,7 @@ impl Compiler {
 
                 let code = self.pop_code_object();
                 self.emit(Instruction::LoadConst {
-                    value: bytecode::Constant::Code { code: code },
+                    value: bytecode::Constant::Code { code },
                 });
                 self.emit(Instruction::LoadConst {
                     value: bytecode::Constant::String {
@@ -905,23 +902,23 @@ impl Compiler {
                 let size = elements.len();
                 let must_unpack = self.gather_elements(elements)?;
                 self.emit(Instruction::BuildList {
-                    size: size,
+                    size,
                     unpack: must_unpack,
                 });
             }
             ast::Expression::Tuple { elements } => {
                 let size = elements.len();
                 let must_unpack = self.gather_elements(elements)?;
                 self.emit(Instruction::BuildTuple {
-                    size: size,
+                    size,
                     unpack: must_unpack,
                 });
             }
             ast::Expression::Set { elements } => {
                 let size = elements.len();
                 let must_unpack = self.gather_elements(elements)?;
                 self.emit(Instruction::BuildSet {
-                    size: size,
+                    size,
                     unpack: must_unpack,
                 });
             }
@@ -932,7 +929,7 @@ impl Compiler {
                     self.compile_expression(value)?;
                 }
                 self.emit(Instruction::BuildMap {
-                    size: size,
+                    size,
                     unpack: false,
                 });
             }
@@ -941,7 +938,7 @@ impl Compiler {
                 for element in elements {
                     self.compile_expression(element)?;
                 }
-                self.emit(Instruction::BuildSlice { size: size });
+                self.emit(Instruction::BuildSlice { size });
             }
             ast::Expression::Yield { value } => {
                 self.mark_generator();
@@ -1003,13 +1000,13 @@ impl Compiler {
                 self.emit(Instruction::ReturnValue);
                 let code = self.pop_code_object();
                 self.emit(Instruction::LoadConst {
-                    value: bytecode::Constant::Code { code: code },
+                    value: bytecode::Constant::Code { code },
                 });
                 self.emit(Instruction::LoadConst {
                     value: bytecode::Constant::String { value: name },
                 });
                 // Turn code object into function object:
-                self.emit(Instruction::MakeFunction { flags: flags });
+                self.emit(Instruction::MakeFunction { flags });
             }
             ast::Expression::Comprehension { kind, generators } => {
                 self.compile_comprehension(kind, generators)?;
@@ -1286,7 +1283,7 @@ impl Compiler {
 
         // List comprehension code:
         self.emit(Instruction::LoadConst {
-            value: bytecode::Constant::Code { code: code },
+            value: bytecode::Constant::Code { code },
         });
 
         // List comprehension function name:

vm/src/frame.rs

@@ -20,7 +20,6 @@ use super::pyobject::{
     PyResult, TypeProtocol,
 };
 use super::vm::VirtualMachine;
-use num_bigint::ToBigInt;
 use num_traits::ToPrimitive;
 
 #[derive(Clone, Debug)]
@@ -76,7 +75,7 @@ impl Frame {
             blocks: vec![],
             // save the callargs as locals
             // globals: locals.clone(),
-            locals: locals,
+            locals,
             lasti: 0,
         }
     }
@@ -121,7 +120,7 @@ impl Frame {
                     trace!("Adding to traceback: {:?} {:?}", traceback, lineno);
                     let pos = vm.ctx.new_tuple(vec![
                         vm.ctx.new_str(filename.clone()),
-                        vm.ctx.new_int(lineno.get_row().to_bigint().unwrap()),
+                        vm.ctx.new_int(lineno.get_row()),
                         vm.ctx.new_str(run_obj_name.clone()),
                     ]);
                     objlist::list_append(
@@ -440,7 +439,7 @@ impl Frame {
                     bytecode::CallType::Positional(count) => {
                         let args: Vec<PyObjectRef> = self.pop_multiple(*count);
                         PyFuncArgs {
-                            args: args,
+                            args,
                             kwargs: vec![],
                         }
                     }
@@ -1036,15 +1035,13 @@ impl Frame {
 
     fn unwrap_constant(&self, vm: &VirtualMachine, value: &bytecode::Constant) -> PyObjectRef {
         match *value {
-            bytecode::Constant::Integer { ref value } => vm.ctx.new_int(value.to_bigint().unwrap()),
+            bytecode::Constant::Integer { ref value } => vm.ctx.new_int(value.clone()),
             bytecode::Constant::Float { ref value } => vm.ctx.new_float(*value),
             bytecode::Constant::Complex { ref value } => vm.ctx.new_complex(*value),
             bytecode::Constant::String { ref value } => vm.new_str(value.clone()),
             bytecode::Constant::Bytes { ref value } => vm.ctx.new_bytes(value.clone()),
             bytecode::Constant::Boolean { ref value } => vm.new_bool(value.clone()),
-            bytecode::Constant::Code { ref code } => {
-                PyObject::new(PyObjectPayload::Code { code: code.clone() }, vm.get_type())
-            }
+            bytecode::Constant::Code { ref code } => vm.ctx.new_code_object(code.clone()),
             bytecode::Constant::Tuple { ref elements } => vm.ctx.new_tuple(
                 elements
                     .iter()