Change integer type into bigint

Author: windelbouwman

Cargo.lock

@@ -6,8 +6,9 @@
 assert bin(-(2**24)) == '-0b1' + '0' * 24
 assert bin(-(2**24-1)) == '-0b' + '1' * 24
 
-# TODO: uncomment these tests when arbitrarily sized ints are supported
-# assert bin(2**65) == '0b1' + '0' * 65
-# assert bin(2**65-1) == '0b' + '1' * 65
-# assert bin(-(2**65)) == '-0b1' + '0' * 65
-# assert bin(-(2**65-1)) == '-0b' + '1' * 65
+# TODO: change to 2**65 when we have support for pow in bigint
+a = 2**20 * 2**20 * 2**25
+assert bin(a) == '0b1' + '0' * 65
+assert bin(a-1) == '0b' + '1' * 65
+assert bin(-(a)) == '-0b1' + '0' * 65
+assert bin(-(a-1)) == '-0b' + '1' * 65

tests/snippets/builtin_bin.py

@@ -6,6 +6,8 @@ authors = ["Shing Lyu <[email protected]>"]
 [dependencies]
 bitflags = "1.0.4"
 num-complex = "0.2"
+num-bigint = "0.2"
+num-traits = "0.2"
 log = "0.3"
 rustpython_parser = {path = "../parser"}
 serde = "1.0.66"

vm/Cargo.toml

@@ -14,6 +14,8 @@ use super::pyobject::{
     PyObjectRef, PyResult, Scope, TypeProtocol,
 };
 use super::vm::VirtualMachine;
+use num_bigint::ToBigInt;
+use num_traits::{Signed, ToPrimitive};
 
 fn get_locals(vm: &mut VirtualMachine) -> PyObjectRef {
     let d = vm.new_dict();
@@ -80,9 +82,10 @@ fn builtin_bin(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(number, Some(vm.ctx.int_type()))]);
 
     let n = objint::get_value(number);
-    let s = match n.signum() {
-        -1 => format!("-0b{:b}", n.abs()),
-        _ => format!("0b{:b}", n),
+    let s = if n.is_negative() {
+        format!("-0b{:b}", n.abs())
+    } else {
+        format!("0b{:b}", n)
     };
 
     Ok(vm.new_str(s))
@@ -97,15 +100,7 @@ fn builtin_bin(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 fn builtin_chr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(i, Some(vm.ctx.int_type()))]);
 
-    let code_point_obj = i.borrow();
-
-    let code_point = *match code_point_obj.kind {
-        PyObjectKind::Integer { ref value } => value,
-        ref kind => panic!(
-            "argument checking failure: chr not supported for {:?}",
-            kind
-        ),
-    } as u32;
+    let code_point = objint::get_value(i).to_u32().unwrap();
 
     let txt = match char::from_u32(code_point) {
         Some(value) => value.to_string(),
@@ -261,9 +256,10 @@ fn builtin_hex(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(number, Some(vm.ctx.int_type()))]);
 
     let n = objint::get_value(number);
-    let s = match n.signum() {
-        -1 => format!("-0x{:x}", n.abs()),
-        _ => format!("0x{:x}", n),
+    let s = if n.is_negative() {
+        format!("-0x{:x}", n.abs())
+    } else {
+        format!("0x{:x}", n)
     };
 
     Ok(vm.new_str(s))
@@ -272,7 +268,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() as i32))
+    Ok(vm.context().new_int(obj.get_id().to_bigint().unwrap()))
 }
 
 // builtin_input
@@ -304,8 +300,12 @@ fn builtin_iter(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 fn builtin_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(obj, None)]);
     match obj.borrow().kind {
-        PyObjectKind::Dict { ref elements } => Ok(vm.context().new_int(elements.len() as i32)),
-        PyObjectKind::Tuple { ref elements } => Ok(vm.context().new_int(elements.len() as i32)),
+        PyObjectKind::Dict { ref elements } => {
+            Ok(vm.context().new_int(elements.len().to_bigint().unwrap()))
+        }
+        PyObjectKind::Tuple { ref elements } => {
+            Ok(vm.context().new_int(elements.len().to_bigint().unwrap()))
+        }
         _ => {
             let len_method_name = "__len__".to_string();
             match vm.get_attribute(obj.clone(), &len_method_name) {
@@ -427,7 +427,9 @@ fn builtin_ord(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         ));
     }
     match string.chars().next() {
-        Some(character) => Ok(vm.context().new_int(character as i32)),
+        Some(character) => Ok(vm
+            .context()
+            .new_int((character as i32).to_bigint().unwrap())),
         None => Err(vm.new_type_error(
             "ord() could not guess the integer representing this character".to_string(),
         )),
@@ -486,8 +488,9 @@ fn builtin_range(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(range, Some(vm.ctx.int_type()))]);
     match range.borrow().kind {
         PyObjectKind::Integer { ref value } => {
-            let range_elements: Vec<PyObjectRef> =
-                (0..*value).map(|num| vm.context().new_int(num)).collect();
+            let range_elements: Vec<PyObjectRef> = (0..value.to_i32().unwrap())
+                .map(|num| vm.context().new_int(num.to_bigint().unwrap()))
+                .collect();
             Ok(vm.context().new_list(range_elements))
         }
         _ => panic!("argument checking failure: first argument to range must be an integer"),

vm/src/builtins.rs

@@ -19,6 +19,8 @@ use super::pyobject::{
     PyObjectKind, PyObjectRef, PyResult, ToRust, TypeProtocol,
 };
 use super::vm::VirtualMachine;
+use num_bigint::ToBigInt;
+use num_traits::ToPrimitive;
 
 #[derive(Clone, Debug)]
 enum Block {
@@ -127,7 +129,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() as i32),
+                        vm.ctx.new_int(lineno.get_row().to_bigint().unwrap()),
                         vm.ctx.new_str(run_obj_name.clone()),
                     ]);
                     objlist::list_append(
@@ -283,7 +285,7 @@ impl Frame {
                 let mut out: Vec<Option<i32>> = elements
                     .into_iter()
                     .map(|x| match x.borrow().kind {
-                        PyObjectKind::Integer { value } => Some(value),
+                        PyObjectKind::Integer { ref value } => Some(value.to_i32().unwrap()),
                         PyObjectKind::None => None,
                         _ => panic!("Expect Int or None as BUILD_SLICE arguments, got {:?}", x),
                     })
@@ -929,7 +931,7 @@ impl Frame {
                 // TODO:
                 // self.invoke('__neg__'
                 match a.borrow().kind {
-                    PyObjectKind::Integer { value: ref value1 } => vm.ctx.new_int(-*value1),
+                    PyObjectKind::Integer { value: ref value1 } => vm.ctx.new_int(-value1),
                     PyObjectKind::Float { value: ref value1 } => vm.ctx.new_float(-*value1),
                     _ => panic!("Not impl {:?}", a),
                 }
@@ -1072,7 +1074,7 @@ impl Frame {
 
     fn unwrap_constant(&self, vm: &VirtualMachine, value: &bytecode::Constant) -> PyObjectRef {
         match *value {
-            bytecode::Constant::Integer { ref value } => vm.ctx.new_int(*value),
+            bytecode::Constant::Integer { ref value } => vm.ctx.new_int(value.to_bigint().unwrap()),
             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()),

vm/src/frame.rs

@@ -3,7 +3,9 @@ extern crate bitflags;
 #[macro_use]
 extern crate log;
 // extern crate env_logger;
+extern crate num_bigint;
 extern crate num_complex;
+extern crate num_traits;
 extern crate serde;
 extern crate serde_json;
 

vm/src/lib.rs

@@ -3,10 +3,11 @@ use super::super::pyobject::{
 };
 use super::super::vm::VirtualMachine;
 use super::objtype;
+use num_traits::Zero;
 
 pub fn boolval(vm: &mut VirtualMachine, obj: PyObjectRef) -> Result<bool, PyObjectRef> {
     let result = match obj.borrow().kind {
-        PyObjectKind::Integer { value } => value != 0,
+        PyObjectKind::Integer { ref value } => !value.is_zero(),
         PyObjectKind::Float { value } => value != 0.0,
         PyObjectKind::List { ref elements } => !elements.is_empty(),
         PyObjectKind::Tuple { ref elements } => !elements.is_empty(),
@@ -15,13 +16,12 @@ pub fn boolval(vm: &mut VirtualMachine, obj: PyObjectRef) -> Result<bool, PyObje
         PyObjectKind::None { .. } => false,
         _ => {
             if let Ok(f) = objtype::get_attribute(vm, obj.clone(), &String::from("__bool__")) {
-                match vm.invoke(f, PyFuncArgs::default()) {
-                    Ok(result) => match result.borrow().kind {
-                        PyObjectKind::Integer { value } => value != 0,
-                        _ => return Err(vm.new_type_error(String::from("TypeError"))),
-                    },
-                    Err(err) => return Err(err),
-                }
+                let bool_res = vm.invoke(f, PyFuncArgs::default())?;
+                let v = match bool_res.borrow().kind {
+                    PyObjectKind::Integer { ref value } => !value.is_zero(),
+                    _ => return Err(vm.new_type_error(String::from("TypeError"))),
+                };
+                v
             } else {
                 true
             }
@@ -48,7 +48,7 @@ pub fn not(vm: &mut VirtualMachine, obj: &PyObjectRef) -> PyResult {
 // Retrieve inner int value:
 pub fn get_value(obj: &PyObjectRef) -> bool {
     if let PyObjectKind::Integer { value } = &obj.borrow().kind {
-        *value != 0
+        !value.is_zero()
     } else {
         panic!("Inner error getting inner boolean");
     }

vm/src/obj/objbool.rs

@@ -5,6 +5,7 @@ use super::super::vm::VirtualMachine;
 use super::objint;
 use super::objlist;
 use super::objtype;
+use num_traits::ToPrimitive;
 // Binary data support
 
 // Fill bytes class methods:
@@ -25,11 +26,8 @@ fn bytes_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let val = if objtype::isinstance(arg, &vm.ctx.list_type()) {
         let mut data_bytes = vec![];
         for elem in objlist::get_elements(arg) {
-            let v = match objint::to_int(vm, &elem, 10) {
-                Ok(int_ref) => int_ref,
-                Err(err) => return Err(err),
-            };
-            data_bytes.push(v as u8);
+            let v = objint::to_int(vm, &elem, 10)?;
+            data_bytes.push(v.to_u8().unwrap());
         }
         data_bytes
     } else {

vm/src/obj/objbytes.rs

@@ -5,6 +5,7 @@ use super::super::pyobject::{
 use super::super::vm::VirtualMachine;
 use super::objstr;
 use super::objtype;
+use num_bigint::ToBigInt;
 use std::collections::HashMap;
 
 pub fn _set_item(
@@ -41,7 +42,7 @@ fn dict_new(_vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 fn dict_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(o, Some(vm.ctx.dict_type()))]);
     let elements = get_elements(o);
-    Ok(vm.ctx.new_int(elements.len() as i32))
+    Ok(vm.ctx.new_int(elements.len().to_bigint().unwrap()))
 }
 
 fn dict_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/obj/objdict.rs

@@ -4,6 +4,7 @@ use super::super::pyobject::{
 use super::super::vm::VirtualMachine;
 use super::objint;
 use super::objtype;
+use num_traits::ToPrimitive;
 
 fn float_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(float, Some(vm.ctx.float_type()))]);
@@ -21,7 +22,7 @@ fn float_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let val = if objtype::isinstance(arg, &vm.ctx.float_type()) {
         get_value(arg)
     } else if objtype::isinstance(arg, &vm.ctx.int_type()) {
-        objint::get_value(arg) as f64
+        objint::get_value(arg).to_f64().unwrap()
     } else {
         return Err(vm.new_type_error("Cannot construct int".to_string()));
     };
@@ -42,7 +43,7 @@ pub fn make_float(vm: &mut VirtualMachine, obj: &PyObjectRef) -> Result<f64, PyO
     if objtype::isinstance(obj, &vm.ctx.float_type()) {
         Ok(get_value(obj))
     } else if objtype::isinstance(obj, &vm.ctx.int_type()) {
-        Ok(objint::get_value(obj) as f64)
+        Ok(objint::get_value(obj).to_f64().unwrap())
     } else {
         Err(vm.new_type_error(format!("Cannot cast {:?} to float", obj)))
     }
@@ -63,7 +64,7 @@ fn float_eq(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         let other = get_value(other);
         zelf == other
     } else if objtype::isinstance(other, &vm.ctx.int_type()) {
-        let other = objint::get_value(other) as f64;
+        let other = objint::get_value(other).to_f64().unwrap();
         zelf == other
     } else {
         false
@@ -147,7 +148,9 @@ fn float_add(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     if objtype::isinstance(i2, &vm.ctx.float_type()) {
         Ok(vm.ctx.new_float(v1 + get_value(i2)))
     } else if objtype::isinstance(i2, &vm.ctx.int_type()) {
-        Ok(vm.ctx.new_float(v1 + objint::get_value(i2) as f64))
+        Ok(vm
+            .ctx
+            .new_float(v1 + objint::get_value(i2).to_f64().unwrap()))
     } else {
         Err(vm.new_type_error(format!("Cannot add {:?} and {:?}", i, i2)))
     }
@@ -181,7 +184,7 @@ fn float_floordiv(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     } else if objtype::isinstance(i2, &vm.ctx.int_type()) {
         Ok(vm
             .ctx
-            .new_float((get_value(i) / objint::get_value(i2) as f64).floor()))
+            .new_float((get_value(i) / objint::get_value(i2).to_f64().unwrap()).floor()))
     } else {
         Err(vm.new_type_error(format!("Cannot floordiv {:?} and {:?}", i, i2)))
     }
@@ -197,7 +200,9 @@ fn float_sub(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     if objtype::isinstance(i2, &vm.ctx.float_type()) {
         Ok(vm.ctx.new_float(v1 - get_value(i2)))
     } else if objtype::isinstance(i2, &vm.ctx.int_type()) {
-        Ok(vm.ctx.new_float(v1 - objint::get_value(i2) as f64))
+        Ok(vm
+            .ctx
+            .new_float(v1 - objint::get_value(i2).to_f64().unwrap()))
     } else {
         Err(vm.new_type_error(format!("Cannot add {:?} and {:?}", i, i2)))
     }
@@ -214,7 +219,7 @@ fn float_mod(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     } else if objtype::isinstance(i2, &vm.ctx.int_type()) {
         Ok(vm
             .ctx
-            .new_float(get_value(i) % objint::get_value(i2) as f64))
+            .new_float(get_value(i) % objint::get_value(i2).to_f64().unwrap()))
     } else {
         Err(vm.new_type_error(format!("Cannot mod {:?} and {:?}", i, i2)))
     }
@@ -232,7 +237,7 @@ fn float_pow(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         let result = v1.powf(get_value(i2));
         Ok(vm.ctx.new_float(result))
     } else if objtype::isinstance(i2, &vm.ctx.int_type()) {
-        let result = v1.powf(objint::get_value(i2) as f64);
+        let result = v1.powf(objint::get_value(i2).to_f64().unwrap());
         Ok(vm.ctx.new_float(result))
     } else {
         Err(vm.new_type_error(format!("Cannot add {:?} and {:?}", i, i2)))