Fixing clippy warnings

RustPython · rodrigocam · Aug 7, 2021 · Oct 29, 2020 · Oct 31, 2020 · Oct 31, 2020
commit 8ceffd9f327a5eefda6c929ab7f3758f7e4fd0d9
diff --git a/vm/src/stdlib/ctypes/common.rs b/vm/src/stdlib/ctypes/common.rs
@@ -2,18 +2,21 @@ extern crate lazy_static;
 extern crate libffi;
 extern crate libloading;

-use ::std::{collections::HashMap, mem, os::raw::*};
+use ::std::{collections::HashMap, mem, os::raw::*, ptr};

 use libffi::low::{
    call as ffi_call, ffi_abi_FFI_DEFAULT_ABI as ABI, ffi_cif, ffi_type, prep_cif, CodePtr,
    Error as FFIError,
 };
 use libffi::middle;
 use libloading::Library;
+use num_bigint::BigInt;

 use crate::builtins::PyTypeRef;
 use crate::common::lock::PyRwLock;
-use crate::pyobject::{PyObjectRc, PyObjectRef, PyRef, PyResult, PyValue, StaticType};
+use crate::pyobject::{
+    PyObjectRc, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject,
+};
 use crate::VirtualMachine;

 pub const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfuzZqQP?g";
@@ -82,6 +85,60 @@ fn str_to_type(ty: &str) -> *mut ffi_type {
    )
 }

+fn py_to_ffi(ty: *mut *mut ffi_type, obj: PyObjectRef, vm: &VirtualMachine) -> *mut c_void {
+    match_ffi_type!(
+        unsafe { *ty },
+        c_schar => {
+            let mut r = i8::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+
+        }
+        c_int => {
+            let mut r = i32::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        c_short => {
+            let mut r = i16::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        c_ushort => {
+            let mut r = u16::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        c_uint => {
+            let mut r = u32::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        //@ TODO: Convert c*longlong from BigInt?
+        c_long | c_longlong => {
+            let mut r = i64::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        c_ulong | c_ulonglong => {
+            let mut r = u64::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        f32 => {
+            let mut r = f32::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        f64 | longdouble=> {
+            let mut r = f64::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        c_uchar => {
+            let mut r = u8::try_from_object(vm, obj).unwrap();
+            &mut r as *mut _ as *mut c_void
+        }
+        pointer => {
+            usize::try_from_object(vm, obj).unwrap() as *mut c_void
+        }
+        void => {
+            ptr::null_mut()
+        }
+    )
+}
+
 #[derive(Debug)]
 pub struct Function {
    pointer: *const c_void,
@@ -116,7 +173,7 @@ impl Function {
        arg_ptrs: Vec<PyObjectRef>,
        vm: &VirtualMachine,
    ) -> PyResult<PyObjectRc> {
-        let mut return_type: *mut ffi_type = &mut unsafe { self.return_type.read() };
+        let return_type: *mut ffi_type = &mut unsafe { self.return_type.read() };

        let result = unsafe {
            prep_cif(
@@ -136,14 +193,18 @@ impl Function {
            return Err(vm.new_runtime_error("The ABI is invalid or unsupported".to_string()));
        }

+        let mut argument_pointers: Vec<*mut c_void> = arg_ptrs
+            .iter()
+            .zip(self.arguments.iter_mut())
+            .map(|(o, t)| {
+                let tt: *mut *mut ffi_type = t;
+                py_to_ffi(tt, o.clone(), vm)
+            })
+            .collect();
+
        let cif_ptr = &self.cif as *const _ as *mut _;
        let fun_ptr = CodePtr::from_ptr(self.pointer);
-        let mut args_ptr = self
-            .arguments
-            .iter_mut()
-            .map(|p: &mut *mut ffi_type| p as *mut _ as *mut c_void)
-            .collect()
-            .as_mut_ptr();
+        let args_ptr = argument_pointers.as_mut_ptr();

        let ret_ptr = unsafe {
            match_ffi_type!(
@@ -170,31 +231,25 @@ impl Function {
                }
                c_long => {
                    let r: c_long = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as u64)
+                    vm.new_pyobj(r as i64)
                }
                c_longlong => {
                    let r: c_longlong = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as i64)
-                    // vm.new_pyobj(r as i128)
+                    vm.new_pyobj(BigInt::from(r as i128))
                }
                c_ulong => {
                    let r: c_ulong = ffi_call(cif_ptr, fun_ptr, args_ptr);
                    vm.new_pyobj(r as u64)
                }
                c_ulonglong => {
                    let r: c_ulonglong = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as u64)
-                    // vm.new_pyobj(r as u128)
+                    vm.new_pyobj(BigInt::from(r as u128))
                }
                f32 => {
                    let r: c_float = ffi_call(cif_ptr, fun_ptr, args_ptr);
                    vm.new_pyobj(r as f32)
                }
-                f64 => {
-                    let r: c_double = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as f64)
-                }
-                longdouble => {
+                f64 | longdouble => {
                    let r: c_double = ffi_call(cif_ptr, fun_ptr, args_ptr);
                    vm.new_pyobj(r as f64)
                }
@@ -207,7 +262,6 @@ impl Function {
                    vm.new_pyobj(r as *const _ as usize)
                }
                void => {
-                    let r: c_void = ffi_call(cif_ptr, fun_ptr, args_ptr);
                    vm.ctx.none()
                }
            )
@@ -224,8 +278,7 @@ unsafe impl Sync for Function {}
 #[derive(Debug)]
 pub struct SharedLibrary {
    path_name: String,
-    lib: Library,
-    is_open_g: Box<bool>,
+    lib: Option<Library>,
 }

 impl PyValue for SharedLibrary {
@@ -238,35 +291,36 @@ impl SharedLibrary {
    pub fn new(name: &str) -> Result<SharedLibrary, libloading::Error> {
        Ok(SharedLibrary {
            path_name: name.to_string(),
-            lib: Library::new(name.to_string())?,
-            is_open_g: Box::new(true),
+            lib: Some(Library::new(name.to_string())?),
        })
    }

-    pub fn get_sym(&self, name: &str) -> Result<*mut c_void, libloading::Error> {
+    pub fn get_sym(&self, name: &str) -> Result<*mut c_void, String> {
+        let inner = if let Some(ref inner) = self.lib {
+            inner
+        } else {
+            return Err("The library has been closed".to_string());
+        };
+
        unsafe {
-            self.lib
+            inner
                .get(name.as_bytes())
                .map(|f: libloading::Symbol<*mut c_void>| *f)
+                .map_err(|err| err.to_string())
        }
    }

-    pub fn is_open(&self) -> bool {
-        self.is_open_g.as_ref().clone()
+    pub fn is_closed(&self) -> bool {
+        self.lib.is_none()
    }

-    pub fn close(&self) -> Result<(), libloading::Error> {
-        if let Err(e) = self.lib.close() {
-            Err(e)
-        } else {
-            mem::replace(self.is_open_g.as_mut(), false);
-            Ok(())
-        }
+    pub fn close(&mut self) {
+        drop(self.lib.take());
    }
 }

 pub struct ExternalLibs {
-    pub libraries: HashMap<String, PyRef<SharedLibrary>>,
+    libraries: HashMap<String, PyRef<SharedLibrary>>,
 }

 impl ExternalLibs {
@@ -281,25 +335,24 @@ impl ExternalLibs {
        library_path: &str,
        vm: &VirtualMachine,
    ) -> Result<&PyRef<SharedLibrary>, libloading::Error> {
-        let library = self
-            .libraries
-            .entry(library_path.to_string())
-            .or_insert(SharedLibrary::new(library_path)?.into_ref(vm));
-
-        if !library.is_open() {
-            if let Some(l) = self.libraries.insert(
-                library_path.to_string(),
-                SharedLibrary::new(library_path)?.into_ref(vm),
-            ) {
-                // Ok(self.libraries.get_mut(library_path.to_string()))
-                Ok(&l)
-            } else {
-                // @TODO: What this error should be?
-                Err(libloading::Error::DlOpenUnknown)
+        match self.libraries.get(&library_path.to_string()) {
+            Some(l) => {
+                if l.is_closed() {
+                    self.libraries.insert(
+                        library_path.to_string(),
+                        SharedLibrary::new(library_path)?.into_ref(vm),
+                    );
+                }
            }
-        } else {
-            Ok(library)
-        }
+            _ => {
+                self.libraries.insert(
+                    library_path.to_string(),
+                    SharedLibrary::new(library_path)?.into_ref(vm),
+                );
+            }
+        };
+
+        Ok(self.libraries.get(&library_path.to_string()).unwrap())
    }
 }


diff --git a/vm/src/stdlib/ctypes/dll.rs b/vm/src/stdlib/ctypes/dll.rs
@@ -32,18 +32,15 @@ pub fn dlsym(slib: PyObjectRc, func: PyObjectRc, vm: &VirtualMachine) -> PyResul
    if !vm.isinstance(&func, &vm.ctx.types.str_type)? {
        return Err(vm.new_value_error("second argument (func) must be str".to_string()));
    }
-
-    let func_name = func.downcast::<PyStr>().unwrap().as_ref();
+    let str_ref = func.downcast::<PyStr>().unwrap();
+    let func_name = str_ref.as_ref();

    match slib.downcast::<SharedLibrary>() {
        Ok(lib) => {
-            if !lib.is_open() {
-                Err(vm.new_runtime_error(format!("Library is closed.")))
-            } else if let Ok(ptr) = lib.get_sym(func_name) {
-                Ok(PyInt::from(ptr as *const _ as usize))
-            } else {
-                // @TODO: Change this error message
-                Err(vm.new_runtime_error(format!("Error while opening symbol {}", func_name)))
+            match lib.get_sym(func_name) {
+                Ok(ptr) => Ok(PyInt::from(ptr as *const _ as usize)),
+                Err(e) => Err(vm
+                    .new_runtime_error(format!("Error while opening symbol {}: {}", func_name, e))),
            }
        }
        Err(_) => {
@@ -53,4 +50,15 @@ pub fn dlsym(slib: PyObjectRc, func: PyObjectRc, vm: &VirtualMachine) -> PyResul
    }
 }

-pub fn dlclose() {}
+pub fn dlclose(slib: PyObjectRc, vm: &VirtualMachine) -> PyResult {
+    match slib.downcast::<SharedLibrary>() {
+        Ok(lib) => {
+            lib.close();
+            Ok(vm.ctx.none())
+        }
+        Err(_) => {
+            Err(vm
+                .new_value_error("first argument (slib) is not a valid SharedLibrary".to_string()))
+        }
+    }
+}
diff --git a/vm/src/stdlib/ctypes/function.rs b/vm/src/stdlib/ctypes/function.rs
@@ -17,7 +17,7 @@ use crate::stdlib::ctypes::common::{CDataObject, Function, SharedLibrary, SIMPLE
 use crate::slots::Callable;
 use crate::stdlib::ctypes::dll::dlsym;

-fn map_types_to_res(args: &Vec<PyObjectRc>, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+fn map_types_to_res(args: &[PyObjectRc], vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
    args.iter()
        .enumerate()
        .map(|(idx, inner_obj)| {
@@ -75,14 +75,15 @@ impl PyCFuncPtr {
        {
            let args: Vec<PyObjectRef> = vm.extract_elements(&argtypes).unwrap();

-            let c_args = map_types_to_res(&args, vm);
+            let c_args = map_types_to_res(&args, vm)?;

            self._argtypes_.write().clear();
-            self._argtypes_.write().extend(c_args?.into_iter());
+            self._argtypes_.write().extend(c_args.clone().into_iter());

-            let fn_ptr = self._f.write().as_mut();
+            let mut f_guard = self._f.write();
+            let fn_ptr = f_guard.as_mut();

-            let str_types: Result<Vec<String>, _> = c_args?
+            let str_types: Result<Vec<String>, _> = c_args
                .iter()
                .map(|obj| {
                    if let Ok(attr) = vm.get_attribute(obj.clone(), "_type_") {
@@ -107,17 +108,17 @@ impl PyCFuncPtr {
    #[pyproperty(name = "_restype_", setter)]
    fn set_restype(&self, restype: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
        match vm.isinstance(&restype, CDataObject::static_type()) {
-            Ok(_) => match vm.get_attribute(restype, "_type_") {
+            Ok(_) => match vm.get_attribute(restype.clone(), "_type_") {
                Ok(_type_)
                    if vm.isinstance(&_type_, &vm.ctx.types.str_type)?
                        && _type_.to_string().len() == 1
                        && SIMPLE_TYPE_CHARS.contains(_type_.to_string().as_str()) =>
                {
-                    let dest = self._restype_.write().as_mut();
-                    let src = restype.clone();
-                    mem::replace(dest, src);
+                    let mut r_guard = self._restype_.write();
+                    mem::replace(r_guard.as_mut(), restype.clone());

-                    let fn_ptr = self._f.write().as_mut();
+                    let mut a_guard = self._f.write();
+                    let fn_ptr = a_guard.as_mut();
                    fn_ptr.set_ret(_type_.to_string().as_str());

                    Ok(())
@@ -164,8 +165,7 @@ impl PyCFuncPtr {
        if let Ok(h) = vm.get_attribute(arg.clone(), "_handle") {
            if let Ok(handle) = h.downcast::<SharedLibrary>() {
                let handle_obj = handle.into_object();
-                let ptr_fn = dlsym(handle_obj.clone(), func_name.into_object(), vm)?;
-
+                let ptr_fn = dlsym(handle_obj.clone(), func_name.clone().into_object(), vm)?;
                let fn_ptr = usize::try_from_object(vm, ptr_fn.into_object(vm))? as *mut c_void;

                PyCFuncPtr {
@@ -208,26 +208,6 @@ impl Callable for PyCFuncPtr {
        // Needs to check their types and convert to middle::Arg based on zelf._argtypes_
        let arg_vec = map_types_to_res(&args.args, vm)?;

-        // This is not optimal, but I can't simply store a vector of middle::Type inside PyCFuncPtr
-        let c_args: Result<Vec<String>, ()> = zelf
-            ._argtypes_
-            .read()
-            .iter()
-            .map(|obj| {
-                if let Ok(attr) = vm.get_attribute(obj.clone(), "_type_") {
-                    Ok(attr.to_string())
-                } else {
-                    Err(())
-                }
-            })
-            .collect();
-
-        let ret_type = zelf._restype_.read().as_ref();
-
-        let res = zelf._f.read().call(arg_vec, vm);
-
-        if let Ok(value) = res {
-        } else {
-        }
+        zelf._f.write().as_mut().call(arg_vec, vm)
    }
 }