Rustfmt all the things ✔️

CHANGELOG.md

@@ -8,11 +8,12 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Removed
 
- * Conversions from tuples to PyDict.
+ * Conversions from tuples to PyDict due to [rust-lang/rust#52050](https://github.com/rust-lang/rust/issues/52050)
 
 ### Changed
 
  * Merged both examples into one
+ * Rustfmt all the things :heavy_check_mark:
 
 ## [0.3.2] - 2018-07-22
 

examples/word-count/src/lib.rs

@@ -21,7 +21,9 @@ struct WordCounter {
 impl WordCounter {
     #[new]
     fn __new__(obj: &PyRawObject, path: String) -> PyResult<()> {
-        obj.init(|_| WordCounter { path: PathBuf::from(path) })
+        obj.init(|_| WordCounter {
+            path: PathBuf::from(path),
+        })
     }
 
     /// Searches for the word, parallelized by rayon
@@ -41,10 +43,7 @@ impl WordCounter {
     fn search_sequential(&self, needle: String) -> PyResult<usize> {
         let contents = fs::read_to_string(&self.path)?;
 
-        let result = contents
+        let result = contents.lines().map(|line| count_line(line, &needle)).sum();
-            .lines()
-            .map(|line| count_line(line, &needle))
-            .sum();
 
         Ok(result)
     }

pyo3-derive-backend/src/args.rs

@@ -179,8 +179,8 @@ pub fn parse_arguments(items: &[syn::NestedMeta]) -> Vec<Argument> {
 mod test {
 
     use args::{parse_arguments, Argument};
-    use syn;
     use proc_macro2::TokenStream;
+    use syn;
 
     fn items(s: TokenStream) -> Vec<syn::NestedMeta> {
         let dummy: syn::ItemFn = parse_quote!{#s fn dummy() {}};

pyo3-derive-backend/src/module.rs

@@ -272,8 +272,7 @@ fn function_c_wrapper(name: &syn::Ident, spec: &method::FnSpec) -> TokenStream {
             } else {
                 syn::Ident::new(&format!("arg{}", item.0), Span::call_site())
             }
-        })
+        }).collect();
-        .collect();
     let cb = quote! {
         ::pyo3::ReturnTypeIntoPyResult::return_type_into_py_result(#name(#(#names),*))
     };

pyo3-derive-backend/src/py_class.rs

@@ -345,10 +345,8 @@ fn impl_descriptors(cls: &syn::Type, descriptors: Vec<(syn::Field, Vec<FnType>)>
                         }
                         _ => unreachable!(),
                     }
-                })
+                }).collect::<Vec<TokenStream>>()
-                .collect::<Vec<TokenStream>>()
+        }).collect();
-        })
-        .collect();
 
     quote! {
         #(#methods)*

pyo3-derive-backend/src/py_method.rs

@@ -139,8 +139,7 @@ pub fn impl_wrap_new(cls: &syn::Type, name: &syn::Ident, spec: &FnSpec) -> Token
             } else {
                 syn::Ident::new(&format!("arg{}", item.0), Span::call_site())
             }
-        })
+        }).collect();
-        .collect();
     let cb = quote! {
         ::pyo3::ReturnTypeIntoPyResult::return_type_into_py_result(#cls::#name(&_obj, #(#names),*))
     };
@@ -235,8 +234,7 @@ pub fn impl_wrap_class(cls: &syn::Type, name: &syn::Ident, spec: &FnSpec) -> Tok
             } else {
                 syn::Ident::new(&format!("arg{}", item.0), Span::call_site())
             }
-        })
+        }).collect();
-        .collect();
     let cb = quote! {
         ::pyo3::ReturnTypeIntoPyResult::return_type_into_py_result(#cls::#name(&_cls, #(#names),*))
     };
@@ -277,8 +275,7 @@ pub fn impl_wrap_static(cls: &syn::Type, name: &syn::Ident, spec: &FnSpec) -> To
             } else {
                 syn::Ident::new(&format!("arg{}", item.0), Span::call_site())
             }
-        })
+        }).collect();
-        .collect();
     let cb = quote! {
         ::pyo3::ReturnTypeIntoPyResult::return_type_into_py_result(#cls::#name(#(#names),*))
     };
@@ -376,8 +373,7 @@ fn impl_call(_cls: &syn::Type, fname: &syn::Ident, spec: &FnSpec) -> TokenStream
             } else {
                 syn::Ident::new(&format!("arg{}", item.0), Span::call_site())
             }
-        })
+        }).collect();
-        .collect();
     quote! {
         ::pyo3::ReturnTypeIntoPyResult::return_type_into_py_result(_slf.#fname(#(#names),*))
     }

pyo3cls/src/lib.rs

@@ -50,7 +50,8 @@ pub fn mod3init(
     input: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
     // Parse the token stream into a syntax tree
-    let mut ast: syn::ItemFn = syn::parse(input).expect("#[pymodinit] must be used on a `fn` block");
+    let mut ast: syn::ItemFn =
+        syn::parse(input).expect("#[pymodinit] must be used on a `fn` block");
 
     let modname: syn::Ident;
     if attr.is_empty() {
@@ -95,7 +96,8 @@ pub fn pyclass(
     input: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
     // Parse the token stream into a syntax tree
-    let mut ast: syn::ItemStruct = syn::parse(input).expect("#[pyclass] must be used on a `struct`");
+    let mut ast: syn::ItemStruct =
+        syn::parse(input).expect("#[pyclass] must be used on a `struct`");
 
     // Parse the macro arguments into a list of expressions
     let args: Vec<syn::Expr> = {

src/argparse.rs

@@ -3,11 +3,11 @@
 // based on Daniel Grunwald's https://github.com/dgrunwald/rust-cpython
 
 //! Python argument parsing
-use ffi;
-use err::PyResult;
-use python::Python;
 use conversion::PyTryFrom;
-use objects::{PyObjectRef, PyTuple, PyDict, PyString, exc};
+use err::PyResult;
+use ffi;
+use objects::{exc, PyDict, PyObjectRef, PyString, PyTuple};
+use python::Python;
 
 #[derive(Debug)]
 /// Description of a python parameter; used for `parse_args()`.
@@ -28,22 +28,26 @@ pub struct ParamDescription<'a> {
 /// * kwargs: Keyword arguments
 /// * output: Output array that receives the arguments.
 ///           Must have same length as `params` and must be initialized to `None`.
-pub fn parse_args<'p>(fname: Option<&str>, params: &[ParamDescription],
+pub fn parse_args<'p>(
-                      args: &'p PyTuple, kwargs: Option<&'p PyDict>,
+    fname: Option<&str>,
-                      accept_args: bool, accept_kwargs: bool,
+    params: &[ParamDescription],
-                      output: &mut[Option<&'p PyObjectRef>]) -> PyResult<()>
+    args: &'p PyTuple,
-{
+    kwargs: Option<&'p PyDict>,
+    accept_args: bool,
+    accept_kwargs: bool,
+    output: &mut [Option<&'p PyObjectRef>],
+) -> PyResult<()> {
     let nargs = args.len();
     let nkeywords = kwargs.map_or(0, |d| d.len());
     if !accept_args && (nargs + nkeywords > params.len()) {
-        return Err(exc::TypeError::new(
+        return Err(exc::TypeError::new(format!(
-            format!("{}{} takes at most {} argument{} ({} given)",
+            "{}{} takes at most {} argument{} ({} given)",
-                    fname.unwrap_or("function"),
+            fname.unwrap_or("function"),
-                    if fname.is_some() { "()" } else { "" },
+            if fname.is_some() { "()" } else { "" },
-                    params.len(),
+            params.len(),
-                    if params.len() == 1 { "s" } else { "" },
+            if params.len() == 1 { "s" } else { "" },
-                    nargs + nkeywords
+            nargs + nkeywords
-            )));
+        )));
     }
     let mut used_keywords = 0;
     // Iterate through the parameters and assign values to output:
@@ -53,25 +57,32 @@ pub fn parse_args<'p>(fname: Option<&str>, params: &[ParamDescription],
                 *out = Some(kwarg);
                 used_keywords += 1;
                 if i < nargs {
-                    return Err(exc::TypeError::new(
+                    return Err(exc::TypeError::new(format!(
-                        format!("Argument given by name ('{}') and position ({})", p.name, i+1)));
+                        "Argument given by name ('{}') and position ({})",
+                        p.name,
+                        i + 1
+                    )));
                 }
-            },
+            }
             None => {
                 if p.kw_only {
                     if !p.is_optional {
-                        return Err(exc::TypeError::new(
+                        return Err(exc::TypeError::new(format!(
-                            format!("Required argument ('{}') is keyword only argument", p.name)));
+                            "Required argument ('{}') is keyword only argument",
+                            p.name
+                        )));
                     }
                     *out = None;
-                }
+                } else if i < nargs {
-                else if i < nargs {
                     *out = Some(args.get_item(i));
                 } else {
                     *out = None;
                     if !p.is_optional {
-                        return Err(exc::TypeError::new(
+                        return Err(exc::TypeError::new(format!(
-                            format!("Required argument ('{}') (pos {}) not found", p.name, i+1)));
+                            "Required argument ('{}') (pos {}) not found",
+                            p.name,
+                            i + 1
+                        )));
                     }
                 }
             }
@@ -83,8 +94,10 @@ pub fn parse_args<'p>(fname: Option<&str>, params: &[ParamDescription],
             let item = <PyTuple as PyTryFrom>::try_from(item)?;
             let key = <PyString as PyTryFrom>::try_from(item.get_item(0))?.to_string()?;
             if !params.iter().any(|p| p.name == key) {
-                return Err(exc::TypeError::new(
+                return Err(exc::TypeError::new(format!(
-                    format!("'{}' is an invalid keyword argument for this function", key)));
+                    "'{}' is an invalid keyword argument for this function",
+                    key
+                )));
             }
         }
     }

src/buffer.rs

@@ -17,16 +17,16 @@
 // DEALINGS IN THE SOFTWARE.
 
 //! `PyBuffer` implementation
-use std::os::raw;
-use std::{mem, slice, cell};
-use std::ffi::CStr;
 use libc;
+use std::ffi::CStr;
+use std::os::raw;
+use std::{cell, mem, slice};
 
-use ffi;
-use exc;
 use err::{self, PyResult};
-use python::{Python, ToPyPointer};
+use exc;
+use ffi;
 use objects::PyObjectRef;
+use python::{Python, ToPyPointer};
 
 /// Allows access to the underlying buffer used by a python object such as `bytes`, `bytearray` or `array.array`.
 #[repr(transparent)]
@@ -43,7 +43,7 @@ pub enum ElementType {
     UnsignedInteger { bytes: usize },
     Bool,
     Float { bytes: usize },
-    Unknown
+    Unknown,
 }
 
 impl ElementType {
@@ -55,7 +55,7 @@ impl ElementType {
             match slice[0] {
                 b'@' => native_element_type_from_type_char(slice[1]),
                 b'=' | b'<' | b'>' | b'!' => standard_element_type_from_type_char(slice[1]),
-                _ => ElementType::Unknown
+                _ => ElementType::Unknown,
             }
         } else {
             ElementType::Unknown
@@ -66,24 +66,50 @@ impl ElementType {
 fn native_element_type_from_type_char(type_char: u8) -> ElementType {
     use self::ElementType::*;
     match type_char {
-        b'c' => UnsignedInteger { bytes: mem::size_of::<raw::c_char>() },
+        b'c' => UnsignedInteger {
-        b'b' => SignedInteger   { bytes: mem::size_of::<raw::c_schar>() },
+            bytes: mem::size_of::<raw::c_char>(),
-        b'B' => UnsignedInteger { bytes: mem::size_of::<raw::c_uchar>() },
+        },
+        b'b' => SignedInteger {
+            bytes: mem::size_of::<raw::c_schar>(),
+        },
+        b'B' => UnsignedInteger {
+            bytes: mem::size_of::<raw::c_uchar>(),
+        },
         b'?' => Bool,
-        b'h' => SignedInteger   { bytes: mem::size_of::<raw::c_short>() },
+        b'h' => SignedInteger {
-        b'H' => UnsignedInteger { bytes: mem::size_of::<raw::c_ushort>() },
+            bytes: mem::size_of::<raw::c_short>(),
-        b'i' => SignedInteger   { bytes: mem::size_of::<raw::c_int>() },
+        },
-        b'I' => UnsignedInteger { bytes: mem::size_of::<raw::c_uint>() },
+        b'H' => UnsignedInteger {
-        b'l' => SignedInteger   { bytes: mem::size_of::<raw::c_long>() },
+            bytes: mem::size_of::<raw::c_ushort>(),
-        b'L' => UnsignedInteger { bytes: mem::size_of::<raw::c_ulong>() },
+        },
-        b'q' => SignedInteger   { bytes: mem::size_of::<raw::c_longlong>() },
+        b'i' => SignedInteger {
-        b'Q' => UnsignedInteger { bytes: mem::size_of::<raw::c_ulonglong>() },
+            bytes: mem::size_of::<raw::c_int>(),
-        b'n' => SignedInteger   { bytes: mem::size_of::<libc::ssize_t>() },
+        },
-        b'N' => UnsignedInteger { bytes: mem::size_of::<libc::size_t>() },
+        b'I' => UnsignedInteger {
+            bytes: mem::size_of::<raw::c_uint>(),
+        },
+        b'l' => SignedInteger {
+            bytes: mem::size_of::<raw::c_long>(),
+        },
+        b'L' => UnsignedInteger {
+            bytes: mem::size_of::<raw::c_ulong>(),
+        },
+        b'q' => SignedInteger {
+            bytes: mem::size_of::<raw::c_longlong>(),
+        },
+        b'Q' => UnsignedInteger {
+            bytes: mem::size_of::<raw::c_ulonglong>(),
+        },
+        b'n' => SignedInteger {
+            bytes: mem::size_of::<libc::ssize_t>(),
+        },
+        b'N' => UnsignedInteger {
+            bytes: mem::size_of::<libc::size_t>(),
+        },
         b'e' => Float { bytes: 2 },
         b'f' => Float { bytes: 4 },
         b'd' => Float { bytes: 8 },
-        _ => Unknown
+        _ => Unknown,
     }
 }
 
@@ -91,18 +117,18 @@ fn standard_element_type_from_type_char(type_char: u8) -> ElementType {
     use self::ElementType::*;
     match type_char {
         b'c' | b'B' => UnsignedInteger { bytes: 1 },
-        b'b' => SignedInteger   { bytes: 1 },
+        b'b' => SignedInteger { bytes: 1 },
         b'?' => Bool,
-        b'h' => SignedInteger   { bytes: 2 },
+        b'h' => SignedInteger { bytes: 2 },
         b'H' => UnsignedInteger { bytes: 2 },
-        b'i' | b'l' => SignedInteger   { bytes: 4 },
+        b'i' | b'l' => SignedInteger { bytes: 4 },
         b'I' | b'L' => UnsignedInteger { bytes: 4 },
-        b'q' => SignedInteger   { bytes: 8 },
+        b'q' => SignedInteger { bytes: 8 },
         b'Q' => UnsignedInteger { bytes: 8 },
         b'e' => Float { bytes: 2 },
         b'f' => Float { bytes: 4 },
         b'd' => Float { bytes: 8 },
-        _ => Unknown
+        _ => Unknown,
     }
 }
 
@@ -110,7 +136,7 @@ fn standard_element_type_from_type_char(type_char: u8) -> ElementType {
 fn is_matching_endian(c: u8) -> bool {
     match c {
         b'@' | b'=' | b'<' => true,
-        _ => false
+        _ => false,
     }
 }
 
@@ -118,7 +144,7 @@ fn is_matching_endian(c: u8) -> bool {
 fn is_matching_endian(c: u8) -> bool {
     match c {
         b'@' | b'=' | b'>' | b'!' => true,
-        _ => false
+        _ => false,
     }
 }
 
@@ -141,7 +167,9 @@ impl PyBuffer {
         unsafe {
             let mut buf = Box::new(mem::zeroed::<ffi::Py_buffer>());
             err::error_on_minusone(
-                py, ffi::PyObject_GetBuffer(obj.as_ptr(), &mut *buf, ffi::PyBUF_FULL_RO))?;
+                py,
+                ffi::PyObject_GetBuffer(obj.as_ptr(), &mut *buf, ffi::PyBUF_FULL_RO),
+            )?;
             validate(&buf);
             Ok(PyBuffer(buf))
         }
@@ -167,7 +195,7 @@ impl PyBuffer {
         unsafe {
             ffi::PyBuffer_GetPointer(
                 &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
-                indices.as_ptr() as *mut usize as *mut ffi::Py_ssize_t
+                indices.as_ptr() as *mut usize as *mut ffi::Py_ssize_t,
             )
         }
     }
@@ -216,9 +244,7 @@ impl PyBuffer {
     /// However, dimensions of length 0 are possible and might need special attention.
     #[inline]
     pub fn shape(&self) -> &[usize] {
-        unsafe {
+        unsafe { slice::from_raw_parts(self.0.shape as *const usize, self.0.ndim as usize) }
-            slice::from_raw_parts(self.0.shape as *const usize, self.0.ndim as usize)
-        }
     }
 
     /// Returns an array that holds, for each dimension, the number of bytes to skip to get to the next element in the dimension.
@@ -227,9 +253,7 @@ impl PyBuffer {
     /// but a consumer MUST be able to handle the case `strides[n] <= 0`.
     #[inline]
     pub fn strides(&self) -> &[isize] {
-        unsafe {
+        unsafe { slice::from_raw_parts(self.0.strides, self.0.ndim as usize) }
-            slice::from_raw_parts(self.0.strides, self.0.ndim as usize)
-        }
     }
 
     /// An array of length ndim.
@@ -243,7 +267,10 @@ impl PyBuffer {
             if self.0.suboffsets.is_null() {
                 None
             } else {
-                Some(slice::from_raw_parts(self.0.suboffsets, self.0.ndim as usize))
+                Some(slice::from_raw_parts(
+                    self.0.suboffsets,
+                    self.0.ndim as usize,
+                ))
             }
         }
     }
@@ -263,7 +290,10 @@ impl PyBuffer {
     pub fn is_c_contiguous(&self) -> bool {
         unsafe {
             // Python 2.7 is not const-correct, so we need the cast to *mut
-            ffi::PyBuffer_IsContiguous(&*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer, b'C' as libc::c_char) != 0
+            ffi::PyBuffer_IsContiguous(
+                &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
+                b'C' as libc::c_char,
+            ) != 0
         }
     }
 
@@ -272,7 +302,10 @@ impl PyBuffer {
     pub fn is_fortran_contiguous(&self) -> bool {
         unsafe {
             // Python 2.7 is not const-correct, so we need the cast to *mut
-            ffi::PyBuffer_IsContiguous(&*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer, b'F' as libc::c_char) != 0
+            ffi::PyBuffer_IsContiguous(
+                &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
+                b'F' as libc::c_char,
+            ) != 0
         }
     }
 
@@ -291,7 +324,12 @@ impl PyBuffer {
             && self.is_c_contiguous()
             && T::is_compatible_format(self.format())
         {
-            unsafe { Some(slice::from_raw_parts(self.0.buf as *mut ReadOnlyCell<T>, self.item_count())) }
+            unsafe {
+                Some(slice::from_raw_parts(
+                    self.0.buf as *mut ReadOnlyCell<T>,
+                    self.item_count(),
+                ))
+            }
         } else {
             None
         }
@@ -314,7 +352,12 @@ impl PyBuffer {
             && self.is_c_contiguous()
             && T::is_compatible_format(self.format())
         {
-            unsafe { Some(slice::from_raw_parts(self.0.buf as *mut cell::Cell<T>, self.item_count())) }
+            unsafe {
+                Some(slice::from_raw_parts(
+                    self.0.buf as *mut cell::Cell<T>,
+                    self.item_count(),
+                ))
+            }
         } else {
             None
         }
@@ -329,13 +372,21 @@ impl PyBuffer {
     ///
     /// The returned slice uses type `Cell<T>` because it's theoretically possible for any call into the Python runtime
     /// to modify the values in the slice.
-    pub fn as_fortran_slice<'a, T: Element>(&'a self, _py: Python<'a>) -> Option<&'a [ReadOnlyCell<T>]> {
+    pub fn as_fortran_slice<'a, T: Element>(
+        &'a self,
+        _py: Python<'a>,
+    ) -> Option<&'a [ReadOnlyCell<T>]> {
         if mem::size_of::<T>() == self.item_size()
             && (self.0.buf as usize) % mem::align_of::<T>() == 0
             && self.is_fortran_contiguous()
             && T::is_compatible_format(self.format())
         {
-            unsafe { Some(slice::from_raw_parts(self.0.buf as *mut ReadOnlyCell<T>, self.item_count())) }
+            unsafe {
+                Some(slice::from_raw_parts(
+                    self.0.buf as *mut ReadOnlyCell<T>,
+                    self.item_count(),
+                ))
+            }
         } else {
             None
         }
@@ -351,14 +402,22 @@ impl PyBuffer {
     ///
     /// The returned slice uses type `Cell<T>` because it's theoretically possible for any call into the Python runtime
     /// to modify the values in the slice.
-    pub fn as_fortran_mut_slice<'a, T: Element>(&'a self, _py: Python<'a>) -> Option<&'a [cell::Cell<T>]> {
+    pub fn as_fortran_mut_slice<'a, T: Element>(
+        &'a self,
+        _py: Python<'a>,
+    ) -> Option<&'a [cell::Cell<T>]> {
         if !self.readonly()
             && mem::size_of::<T>() == self.item_size()
             && (self.0.buf as usize) % mem::align_of::<T>() == 0
             && self.is_fortran_contiguous()
             && T::is_compatible_format(self.format())
         {
-            unsafe { Some(slice::from_raw_parts(self.0.buf as *mut cell::Cell<T>, self.item_count())) }
+            unsafe {
+                Some(slice::from_raw_parts(
+                    self.0.buf as *mut cell::Cell<T>,
+                    self.item_count(),
+                ))
+            }
         } else {
             None
         }
@@ -373,7 +432,7 @@ impl PyBuffer {
     /// To check whether the buffer format is compatible before calling this method,
     /// you can use `<T as buffer::Element>::is_compatible_format(buf.format())`.
     /// Alternatively, `match buffer::ElementType::from_format(buf.format())`.
-    pub fn copy_to_slice<T: Element+Copy>(&self, py: Python, target: &mut [T]) -> PyResult<()> {
+    pub fn copy_to_slice<T: Element + Copy>(&self, py: Python, target: &mut [T]) -> PyResult<()> {
         self.copy_to_slice_impl(py, target, b'C')
     }
 
@@ -386,24 +445,38 @@ impl PyBuffer {
     /// To check whether the buffer format is compatible before calling this method,
     /// you can use `<T as buffer::Element>::is_compatible_format(buf.format())`.
     /// Alternatively, `match buffer::ElementType::from_format(buf.format())`.
-    pub fn copy_to_fortran_slice<T: Element+Copy>(&self, py: Python, target: &mut [T]) -> PyResult<()> {
+    pub fn copy_to_fortran_slice<T: Element + Copy>(
+        &self,
+        py: Python,
+        target: &mut [T],
+    ) -> PyResult<()> {
         self.copy_to_slice_impl(py, target, b'F')
     }
 
-    fn copy_to_slice_impl<T: Element+Copy>(&self, py: Python, target: &mut [T], fort: u8) -> PyResult<()> {
+    fn copy_to_slice_impl<T: Element + Copy>(
+        &self,
+        py: Python,
+        target: &mut [T],
+        fort: u8,
+    ) -> PyResult<()> {
         if mem::size_of_val(target) != self.len_bytes() {
-            return Err(exc::BufferError::new("Slice length does not match buffer length."));
+            return Err(exc::BufferError::new(
+                "Slice length does not match buffer length.",
+            ));
         }
         if !T::is_compatible_format(self.format()) || mem::size_of::<T>() != self.item_size() {
             return incompatible_format_error();
         }
         unsafe {
-            err::error_on_minusone(py, ffi::PyBuffer_ToContiguous(
+            err::error_on_minusone(
-                target.as_ptr() as *mut raw::c_void,
+                py,
-                &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
+                ffi::PyBuffer_ToContiguous(
-                self.0.len,
+                    target.as_ptr() as *mut raw::c_void,
-                fort as libc::c_char
+                    &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
-            ))
+                    self.0.len,
+                    fort as libc::c_char,
+                ),
+            )
         }
     }
 
@@ -411,7 +484,7 @@ impl PyBuffer {
     /// If the buffer is multi-dimensional, the elements are written in C-style order.
     ///
     /// Fails if the buffer format is not compatible with type `T`.
-    pub fn to_vec<T: Element+Copy>(&self, py: Python) -> PyResult<Vec<T>> {
+    pub fn to_vec<T: Element + Copy>(&self, py: Python) -> PyResult<Vec<T>> {
         self.to_vec_impl(py, b'C')
     }
 
@@ -419,11 +492,11 @@ impl PyBuffer {
     /// If the buffer is multi-dimensional, the elements are written in Fortran-style order.
     ///
     /// Fails if the buffer format is not compatible with type `T`.
-    pub fn to_fortran_vec<T: Element+Copy>(&self, py: Python) -> PyResult<Vec<T>> {
+    pub fn to_fortran_vec<T: Element + Copy>(&self, py: Python) -> PyResult<Vec<T>> {
         self.to_vec_impl(py, b'F')
     }
 
-    fn to_vec_impl<T: Element+Copy>(&self, py: Python, fort: u8) -> PyResult<Vec<T>> {
+    fn to_vec_impl<T: Element + Copy>(&self, py: Python, fort: u8) -> PyResult<Vec<T>> {
         if !T::is_compatible_format(self.format()) || mem::size_of::<T>() != self.item_size() {
             incompatible_format_error()?;
             unreachable!();
@@ -433,12 +506,15 @@ impl PyBuffer {
         unsafe {
             // Copy the buffer into the uninitialized space in the vector.
             // Due to T:Copy, we don't need to be concerned with Drop impls.
-            err::error_on_minusone(py, ffi::PyBuffer_ToContiguous(
+            err::error_on_minusone(
-                vec.as_mut_ptr() as *mut raw::c_void,
+                py,
-                &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
+                ffi::PyBuffer_ToContiguous(
-                self.0.len,
+                    vec.as_mut_ptr() as *mut raw::c_void,
-                fort as libc::c_char
+                    &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
-            ))?;
+                    self.0.len,
+                    fort as libc::c_char,
+                ),
+            )?;
             // set vector length to mark the now-initialized space as usable
             vec.set_len(item_count);
         }
@@ -455,7 +531,7 @@ impl PyBuffer {
     /// To check whether the buffer format is compatible before calling this method,
     /// use `<T as buffer::Element>::is_compatible_format(buf.format())`.
     /// Alternatively, `match buffer::ElementType::from_format(buf.format())`.
-    pub fn copy_from_slice<T: Element+Copy>(&self, py: Python, source: &[T]) -> PyResult<()> {
+    pub fn copy_from_slice<T: Element + Copy>(&self, py: Python, source: &[T]) -> PyResult<()> {
         self.copy_from_slice_impl(py, source, b'C')
     }
 
@@ -469,27 +545,41 @@ impl PyBuffer {
     /// To check whether the buffer format is compatible before calling this method,
     /// use `<T as buffer::Element>::is_compatible_format(buf.format())`.
     /// Alternatively, `match buffer::ElementType::from_format(buf.format())`.
-    pub fn copy_from_fortran_slice<T: Element+Copy>(&self, py: Python, source: &[T]) -> PyResult<()> {
+    pub fn copy_from_fortran_slice<T: Element + Copy>(
+        &self,
+        py: Python,
+        source: &[T],
+    ) -> PyResult<()> {
         self.copy_from_slice_impl(py, source, b'F')
     }
 
-    fn copy_from_slice_impl<T: Element+Copy>(&self, py: Python, source: &[T], fort: u8) -> PyResult<()> {
+    fn copy_from_slice_impl<T: Element + Copy>(
+        &self,
+        py: Python,
+        source: &[T],
+        fort: u8,
+    ) -> PyResult<()> {
         if self.readonly() {
             return buffer_readonly_error();
         }
         if mem::size_of_val(source) != self.len_bytes() {
-            return Err(exc::BufferError::new("Slice length does not match buffer length."));
+            return Err(exc::BufferError::new(
+                "Slice length does not match buffer length.",
+            ));
         }
         if !T::is_compatible_format(self.format()) || mem::size_of::<T>() != self.item_size() {
             return incompatible_format_error();
         }
         unsafe {
-            err::error_on_minusone(py, ffi::PyBuffer_FromContiguous(
+            err::error_on_minusone(
-                &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
+                py,
-                source.as_ptr() as *mut raw::c_void,
+                ffi::PyBuffer_FromContiguous(
-                self.0.len,
+                    &*self.0 as *const ffi::Py_buffer as *mut ffi::Py_buffer,
-                fort as libc::c_char
+                    source.as_ptr() as *mut raw::c_void,
-            ))
+                    self.0.len,
+                    fort as libc::c_char,
+                ),
+            )
         }
     }
 
@@ -503,7 +593,9 @@ impl PyBuffer {
 }
 
 fn incompatible_format_error() -> PyResult<()> {
-    Err(exc::BufferError::new("Slice type is incompatible with buffer format."))
+    Err(exc::BufferError::new(
+        "Slice type is incompatible with buffer format.",
+    ))
 }
 
 fn buffer_readonly_error() -> PyResult<()> {
@@ -525,7 +617,7 @@ impl Drop for PyBuffer {
 #[repr(transparent)]
 pub struct ReadOnlyCell<T>(cell::UnsafeCell<T>);
 
-impl <T: Copy> ReadOnlyCell<T> {
+impl<T: Copy> ReadOnlyCell<T> {
     #[inline]
     pub fn get(&self) -> T {
         unsafe { *self.0.get() }
@@ -564,12 +656,11 @@ impl_element!(isize, SignedInteger);
 impl_element!(f32, Float);
 impl_element!(f64, Float);
 
-
 #[cfg(test)]
 mod test {
-    use std;
-    use python::{Python};
     use super::PyBuffer;
+    use python::Python;
+    use std;
 
     #[allow(unused_imports)]
     use objectprotocol::ObjectProtocol;
@@ -577,7 +668,10 @@ mod test {
     #[test]
     fn test_compatible_size() {
         // for the cast in PyBuffer::shape()
-        assert_eq!(std::mem::size_of::<::ffi::Py_ssize_t>(), std::mem::size_of::<usize>());
+        assert_eq!(
+            std::mem::size_of::<::ffi::Py_ssize_t>(),
+            std::mem::size_of::<usize>()
+        );
     }
 
     #[test]
@@ -621,8 +715,11 @@ mod test {
     fn test_array_buffer() {
         let gil = Python::acquire_gil();
         let py = gil.python();
-        let array = py.import("array").unwrap().call_method(
+        let array = py
-            "array", ("f", (1.0, 1.5, 2.0, 2.5)), ::NoArgs).unwrap();
+            .import("array")
+            .unwrap()
+            .call_method("array", ("f", (1.0, 1.5, 2.0, 2.5)), ::NoArgs)
+            .unwrap();
         let buffer = PyBuffer::get(py, array.into()).unwrap();
         assert_eq!(buffer.dimensions(), 1);
         assert_eq!(buffer.item_count(), 4);
@@ -643,7 +740,9 @@ mod test {
         mut_slice[3].set(2.75);
         assert_eq!(slice[3].get(), 2.75);
 
-        buffer.copy_from_slice(py, &[10.0f32, 11.0, 12.0, 13.0]).unwrap();
+        buffer
+            .copy_from_slice(py, &[10.0f32, 11.0, 12.0, 13.0])
+            .unwrap();
         assert_eq!(slice[2].get(), 12.0);
 
         assert_eq!(buffer.to_vec::<f32>(py).unwrap(), [10.0, 11.0, 12.0, 13.0]);

src/callback.rs

@@ -3,14 +3,13 @@
 //! Utilities for a Python callable object that invokes a Rust function.
 
 use std::os::raw::c_int;
-use std::{ptr, isize};
+use std::{isize, ptr};
 
+use conversion::IntoPyObject;
 use err::PyResult;
 use ffi::{self, Py_hash_t};
-use python::{Python, IntoPyPointer};
 use objects::exc::OverflowError;
-use conversion::IntoPyObject;
+use python::{IntoPyPointer, Python};
-
 
 pub trait CallbackConverter<S> {
     type R;
@@ -22,7 +21,8 @@ pub trait CallbackConverter<S> {
 pub struct PyObjectCallbackConverter;
 
 impl<S> CallbackConverter<S> for PyObjectCallbackConverter
-    where S: IntoPyObject
+where
+    S: IntoPyObject,
 {
     type R = *mut ffi::PyObject;
 
@@ -36,7 +36,6 @@ impl<S> CallbackConverter<S> for PyObjectCallbackConverter
     }
 }
 
-
 pub struct BoolCallbackConverter;
 
 impl CallbackConverter<bool> for BoolCallbackConverter {
@@ -73,7 +72,6 @@ impl CallbackConverter<usize> for LenResultConverter {
     }
 }
 
-
 pub struct UnitCallbackConverter;
 
 impl CallbackConverter<()> for UnitCallbackConverter {
@@ -102,7 +100,7 @@ macro_rules! wrapping_cast {
                 self as $to
             }
         }
-    }
+    };
 }
 wrapping_cast!(u8, Py_hash_t);
 wrapping_cast!(u16, Py_hash_t);
@@ -117,8 +115,9 @@ wrapping_cast!(i64, Py_hash_t);
 
 pub struct HashConverter;
 
-impl <T> CallbackConverter<T> for HashConverter
+impl<T> CallbackConverter<T> for HashConverter
-    where T: WrappingCastTo<Py_hash_t>
+where
+    T: WrappingCastTo<Py_hash_t>,
 {
     type R = Py_hash_t;
 
@@ -141,7 +140,8 @@ impl <T> CallbackConverter<T> for HashConverter
 #[inline]
 
 pub unsafe fn cb_convert<C, T>(_c: C, py: Python, value: PyResult<T>) -> C::R
-    where C: CallbackConverter<T>
+where
+    C: CallbackConverter<T>,
 {
     match value {
         Ok(val) => C::convert(val, py),

src/class/async.rs

@@ -8,36 +8,56 @@
 //! [PEP-0492](https://www.python.org/dev/peps/pep-0492/)
 //!
 
-use ffi;
-use err::PyResult;
 use callback::PyObjectCallbackConverter;
-use typeob::PyTypeInfo;
 use class::methods::PyMethodDef;
-
+use err::PyResult;
+use ffi;
+use typeob::PyTypeInfo;
 
 /// Python Async/Await support interface.
 ///
 /// Each method in this trait corresponds to Python async/await implementation.
 #[allow(unused_variables)]
 pub trait PyAsyncProtocol<'p>: PyTypeInfo {
+    fn __await__(&'p self) -> Self::Result
+    where
+        Self: PyAsyncAwaitProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __await__(&'p self)
+    fn __aiter__(&'p self) -> Self::Result
-                 -> Self::Result where Self: PyAsyncAwaitProtocol<'p> { unimplemented!() }
+    where
+        Self: PyAsyncAiterProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __aiter__(&'p self)
+    fn __anext__(&'p mut self) -> Self::Result
-                 -> Self::Result where Self: PyAsyncAiterProtocol<'p> { unimplemented!() }
+    where
+        Self: PyAsyncAnextProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __anext__(&'p mut self)
+    fn __aenter__(&'p mut self) -> Self::Result
-                 -> Self::Result where Self: PyAsyncAnextProtocol<'p> { unimplemented!() }
+    where
+        Self: PyAsyncAenterProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __aenter__(&'p mut self)
+    fn __aexit__(
-                  -> Self::Result where Self: PyAsyncAenterProtocol<'p> { unimplemented!() }
+        &'p mut self,
-
+        exc_type: Option<Self::ExcType>,
-    fn __aexit__(&'p mut self,
+        exc_value: Option<Self::ExcValue>,
-                 exc_type: Option<Self::ExcType>,
+        traceback: Option<Self::Traceback>,
-                 exc_value: Option<Self::ExcValue>,
+    ) -> Self::Result
-                 traceback: Option<Self::Traceback>)
+    where
-                 -> Self::Result where Self: PyAsyncAexitProtocol<'p> { unimplemented!() }
+        Self: PyAsyncAexitProtocol<'p>,
+    {
+        unimplemented!()
+    }
 }
 
 pub trait PyAsyncAwaitProtocol<'p>: PyAsyncProtocol<'p> {
@@ -68,7 +88,6 @@ pub trait PyAsyncAexitProtocol<'p>: PyAsyncProtocol<'p> {
     type Result: Into<PyResult<Self::Success>>;
 }
 
-
 #[cfg(Py_3)]
 #[doc(hidden)]
 pub trait PyAsyncProtocolImpl {
@@ -91,7 +110,10 @@ impl<T> PyAsyncProtocolImpl for T {
 }
 
 #[cfg(Py_3)]
-impl<'p, T> PyAsyncProtocolImpl for T where T: PyAsyncProtocol<'p> {
+impl<'p, T> PyAsyncProtocolImpl for T
+where
+    T: PyAsyncProtocol<'p>,
+{
     #[inline]
     fn tp_as_async() -> Option<ffi::PyAsyncMethods> {
         Some(ffi::PyAsyncMethods {
@@ -116,12 +138,13 @@ impl<'p, T> PyAsyncProtocolImpl for T where T: PyAsyncProtocol<'p> {
     }
 }
 
-
 trait PyAsyncAwaitProtocolImpl {
     fn am_await() -> Option<ffi::unaryfunc>;
 }
 
-impl<'p, T> PyAsyncAwaitProtocolImpl for T where T: PyAsyncProtocol<'p>
+impl<'p, T> PyAsyncAwaitProtocolImpl for T
+where
+    T: PyAsyncProtocol<'p>,
 {
     #[inline]
     default fn am_await() -> Option<ffi::unaryfunc> {
@@ -129,12 +152,18 @@ impl<'p, T> PyAsyncAwaitProtocolImpl for T where T: PyAsyncProtocol<'p>
     }
 }
 
-impl<T> PyAsyncAwaitProtocolImpl for T where T: for<'p> PyAsyncAwaitProtocol<'p>
+impl<T> PyAsyncAwaitProtocolImpl for T
+where
+    T: for<'p> PyAsyncAwaitProtocol<'p>,
 {
     #[inline]
     fn am_await() -> Option<ffi::unaryfunc> {
-        py_unary_func!(PyAsyncAwaitProtocol, T::__await__,
+        py_unary_func!(
-                       <T as PyAsyncAwaitProtocol>::Success, PyObjectCallbackConverter)
+            PyAsyncAwaitProtocol,
+            T::__await__,
+            <T as PyAsyncAwaitProtocol>::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -142,7 +171,9 @@ trait PyAsyncAiterProtocolImpl {
     fn am_aiter() -> Option<ffi::unaryfunc>;
 }
 
-impl<'p, T> PyAsyncAiterProtocolImpl for T where T: PyAsyncProtocol<'p>
+impl<'p, T> PyAsyncAiterProtocolImpl for T
+where
+    T: PyAsyncProtocol<'p>,
 {
     #[inline]
     default fn am_aiter() -> Option<ffi::unaryfunc> {
@@ -150,12 +181,18 @@ impl<'p, T> PyAsyncAiterProtocolImpl for T where T: PyAsyncProtocol<'p>
     }
 }
 
-impl<T> PyAsyncAiterProtocolImpl for T where T: for<'p> PyAsyncAiterProtocol<'p>
+impl<T> PyAsyncAiterProtocolImpl for T
+where
+    T: for<'p> PyAsyncAiterProtocol<'p>,
 {
     #[inline]
     fn am_aiter() -> Option<ffi::unaryfunc> {
-        py_unary_func!(PyAsyncAiterProtocol, T::__aiter__,
+        py_unary_func!(
-                       <T as PyAsyncAiterProtocol>::Success, PyObjectCallbackConverter)
+            PyAsyncAiterProtocol,
+            T::__aiter__,
+            <T as PyAsyncAiterProtocol>::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -163,7 +200,9 @@ trait PyAsyncAnextProtocolImpl {
     fn am_anext() -> Option<ffi::unaryfunc>;
 }
 
-impl<'p, T> PyAsyncAnextProtocolImpl for T where T: PyAsyncProtocol<'p>
+impl<'p, T> PyAsyncAnextProtocolImpl for T
+where
+    T: PyAsyncProtocol<'p>,
 {
     #[inline]
     default fn am_anext() -> Option<ffi::unaryfunc> {
@@ -171,20 +210,20 @@ impl<'p, T> PyAsyncAnextProtocolImpl for T where T: PyAsyncProtocol<'p>
     }
 }
 
-
 #[cfg(Py_3)]
 mod anext {
-    use std::ptr;
+    use super::{PyAsyncAnextProtocol, PyAsyncAnextProtocolImpl};
-    use ffi;
     use callback::CallbackConverter;
     use conversion::IntoPyObject;
-    use python::{Python, IntoPyPointer};
+    use ffi;
-    use super::{PyAsyncAnextProtocolImpl, PyAsyncAnextProtocol};
+    use python::{IntoPyPointer, Python};
+    use std::ptr;
 
     pub struct IterANextResultConverter;
 
-    impl <T> CallbackConverter<Option<T>> for IterANextResultConverter
+    impl<T> CallbackConverter<Option<T>> for IterANextResultConverter
-        where T: IntoPyObject
+    where
+        T: IntoPyObject,
     {
         type R = *mut ffi::PyObject;
 
@@ -194,7 +233,7 @@ mod anext {
                 None => unsafe {
                     ffi::PyErr_SetNone(ffi::PyExc_StopAsyncIteration);
                     ptr::null_mut()
-                }
+                },
             }
         }
 
@@ -204,12 +243,18 @@ mod anext {
         }
     }
 
-    impl<T> PyAsyncAnextProtocolImpl for T where T: for<'p> PyAsyncAnextProtocol<'p>
+    impl<T> PyAsyncAnextProtocolImpl for T
+    where
+        T: for<'p> PyAsyncAnextProtocol<'p>,
     {
         #[inline]
         fn am_anext() -> Option<ffi::unaryfunc> {
-            py_unary_func!(PyAsyncAnextProtocol, T::__anext__,
+            py_unary_func!(
-                           Option<T::Success>, IterANextResultConverter)
+                PyAsyncAnextProtocol,
+                T::__anext__,
+                Option<T::Success>,
+                IterANextResultConverter
+            )
         }
     }
 }
@@ -218,7 +263,9 @@ trait PyAsyncAenterProtocolImpl {
     fn __aenter__() -> Option<PyMethodDef>;
 }
 
-impl<'p, T> PyAsyncAenterProtocolImpl for T where T: PyAsyncProtocol<'p>
+impl<'p, T> PyAsyncAenterProtocolImpl for T
+where
+    T: PyAsyncProtocol<'p>,
 {
     #[inline]
     default fn __aenter__() -> Option<PyMethodDef> {
@@ -230,7 +277,9 @@ trait PyAsyncAexitProtocolImpl {
     fn __aexit__() -> Option<PyMethodDef>;
 }
 
-impl<'p, T> PyAsyncAexitProtocolImpl for T where T: PyAsyncProtocol<'p>
+impl<'p, T> PyAsyncAexitProtocolImpl for T
+where
+    T: PyAsyncProtocol<'p>,
 {
     #[inline]
     default fn __aexit__() -> Option<PyMethodDef> {

src/class/basic.rs

@@ -8,58 +8,99 @@
 use std;
 use std::os::raw::c_int;
 
-use ::CompareOp;
+use callback::{BoolCallbackConverter, HashConverter, PyObjectCallbackConverter};
-use ffi;
-use err::{PyErr, PyResult};
-use python::{Python, IntoPyPointer};
-use objects::{exc, PyObjectRef};
-use typeob::PyTypeInfo;
-use conversion::{FromPyObject, IntoPyObject};
-use objectprotocol::ObjectProtocol;
-use callback::{PyObjectCallbackConverter, HashConverter, BoolCallbackConverter};
 use class::methods::PyMethodDef;
-
+use conversion::{FromPyObject, IntoPyObject};
+use err::{PyErr, PyResult};
+use ffi;
+use objectprotocol::ObjectProtocol;
+use objects::{exc, PyObjectRef};
+use python::{IntoPyPointer, Python};
+use typeob::PyTypeInfo;
+use CompareOp;
 
 /// Basic python class customization
 #[allow(unused_variables)]
 pub trait PyObjectProtocol<'p>: PyTypeInfo {
+    fn __getattr__(&'p self, name: Self::Name) -> Self::Result
+    where
+        Self: PyObjectGetAttrProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __getattr__(&'p self, name: Self::Name)
+    fn __setattr__(&'p mut self, name: Self::Name, value: Self::Value) -> Self::Result
-                   -> Self::Result where Self: PyObjectGetAttrProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectSetAttrProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __setattr__(&'p mut self, name: Self::Name, value: Self::Value)
+    fn __delattr__(&'p mut self, name: Self::Name) -> Self::Result
-                   -> Self::Result where Self: PyObjectSetAttrProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectDelAttrProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __delattr__(&'p mut self, name: Self::Name)
+    fn __str__(&'p self) -> Self::Result
-                   -> Self::Result where Self: PyObjectDelAttrProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectStrProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __str__(&'p self)
+    fn __repr__(&'p self) -> Self::Result
-               -> Self::Result where Self: PyObjectStrProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectReprProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __repr__(&'p self)
+    fn __format__(&'p self, format_spec: Self::Format) -> Self::Result
-                -> Self::Result where Self: PyObjectReprProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectFormatProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __format__(&'p self, format_spec: Self::Format)
+    fn __hash__(&'p self) -> Self::Result
-                  -> Self::Result where Self: PyObjectFormatProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectHashProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __hash__(&'p self)
+    fn __bool__(&'p self) -> Self::Result
-                -> Self::Result where Self: PyObjectHashProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectBoolProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __bool__(&'p self)
+    fn __bytes__(&'p self) -> Self::Result
-                -> Self::Result where Self: PyObjectBoolProtocol<'p> {unimplemented!()}
+    where
-
+        Self: PyObjectBytesProtocol<'p>,
-    fn __bytes__(&'p self)
+    {
-                 -> Self::Result where Self: PyObjectBytesProtocol<'p> {unimplemented!()}
+        unimplemented!()
+    }
 
     /// This method is used by Python2 only.
-    fn __unicode__(&'p self)
+    fn __unicode__(&'p self) -> Self::Result
-                   -> Self::Result where Self: PyObjectUnicodeProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectUnicodeProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __richcmp__(&'p self, other: Self::Other, op: CompareOp)
+    fn __richcmp__(&'p self, other: Self::Other, op: CompareOp) -> Self::Result
-                   -> Self::Result where Self: PyObjectRichcmpProtocol<'p> {unimplemented!()}
+    where
+        Self: PyObjectRichcmpProtocol<'p>,
+    {
+        unimplemented!()
+    }
 }
 
-
 pub trait PyObjectGetAttrProtocol<'p>: PyObjectProtocol<'p> {
     type Name: FromPyObject<'p>;
     type Success: IntoPyObject;
@@ -107,7 +148,6 @@ pub trait PyObjectRichcmpProtocol<'p>: PyObjectProtocol<'p> {
     type Result: Into<PyResult<Self::Success>>;
 }
 
-
 #[doc(hidden)]
 pub trait PyObjectProtocolImpl {
     fn methods() -> Vec<PyMethodDef>;
@@ -119,14 +159,16 @@ impl<T> PyObjectProtocolImpl for T {
     default fn methods() -> Vec<PyMethodDef> {
         Vec::new()
     }
-    default fn tp_as_object(_type_object: &mut ffi::PyTypeObject) {
+    default fn tp_as_object(_type_object: &mut ffi::PyTypeObject) {}
-    }
     default fn nb_bool_fn() -> Option<ffi::inquiry> {
         None
     }
 }
 
-impl<'p, T> PyObjectProtocolImpl for T where T: PyObjectProtocol<'p> {
+impl<'p, T> PyObjectProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
+{
     #[inline]
     fn methods() -> Vec<PyMethodDef> {
         let mut methods = Vec::new();
@@ -163,35 +205,46 @@ impl<'p, T> PyObjectProtocolImpl for T where T: PyObjectProtocol<'p> {
 trait PyObjectGetAttrProtocolImpl {
     fn tp_getattro() -> Option<ffi::binaryfunc>;
 }
-impl<'p, T> PyObjectGetAttrProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectGetAttrProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn tp_getattro() -> Option<ffi::binaryfunc> {
         None
     }
 }
-impl<T> PyObjectGetAttrProtocolImpl for T where T: for<'p> PyObjectGetAttrProtocol<'p>
+impl<T> PyObjectGetAttrProtocolImpl for T
+where
+    T: for<'p> PyObjectGetAttrProtocol<'p>,
 {
     #[inline]
     fn tp_getattro() -> Option<ffi::binaryfunc> {
-        py_binary_func!(PyObjectGetAttrProtocol,
+        py_binary_func!(
-                        T::__getattr__, T::Success, PyObjectCallbackConverter)
+            PyObjectGetAttrProtocol,
+            T::__getattr__,
+            T::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
-
 trait PyObjectSetAttrProtocolImpl {
     fn tp_setattro() -> Option<ffi::setattrofunc>;
 }
 
-impl<'p, T> PyObjectSetAttrProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectSetAttrProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn tp_setattro() -> Option<ffi::setattrofunc> {
         None
     }
 }
-impl<T> PyObjectSetAttrProtocolImpl for T where T: for<'p> PyObjectSetAttrProtocol<'p>
+impl<T> PyObjectSetAttrProtocolImpl for T
+where
+    T: for<'p> PyObjectSetAttrProtocol<'p>,
 {
     #[inline]
     fn tp_setattro() -> Option<ffi::setattrofunc> {
@@ -199,18 +252,21 @@ impl<T> PyObjectSetAttrProtocolImpl for T where T: for<'p> PyObjectSetAttrProtoc
     }
 }
 
-
 trait PyObjectDelAttrProtocolImpl {
     fn tp_delattro() -> Option<ffi::setattrofunc>;
 }
-impl<'p, T> PyObjectDelAttrProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectDelAttrProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn tp_delattro() -> Option<ffi::setattrofunc> {
         None
     }
 }
-impl<T> PyObjectDelAttrProtocolImpl for T where T: for<'p> PyObjectDelAttrProtocol<'p>
+impl<T> PyObjectDelAttrProtocolImpl for T
+where
+    T: for<'p> PyObjectDelAttrProtocol<'p>,
 {
     #[inline]
     default fn tp_delattro() -> Option<ffi::setattrofunc> {
@@ -218,51 +274,70 @@ impl<T> PyObjectDelAttrProtocolImpl for T where T: for<'p> PyObjectDelAttrProtoc
     }
 }
 impl<T> PyObjectDelAttrProtocolImpl for T
-    where T: for<'p> PyObjectSetAttrProtocol<'p> + for<'p> PyObjectDelAttrProtocol<'p>
+where
+    T: for<'p> PyObjectSetAttrProtocol<'p> + for<'p> PyObjectDelAttrProtocol<'p>,
 {
     #[inline]
     fn tp_delattro() -> Option<ffi::setattrofunc> {
-        py_func_set_del!(PyObjectSetAttrProtocol, PyObjectDelAttrProtocol,
+        py_func_set_del!(
-                         T::__setattr__/__delattr__)
+            PyObjectSetAttrProtocol,
+            PyObjectDelAttrProtocol,
+            T::__setattr__ / __delattr__
+        )
     }
 }
 
-
 trait PyObjectStrProtocolImpl {
     fn tp_str() -> Option<ffi::unaryfunc>;
 }
-impl<'p, T> PyObjectStrProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectStrProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn tp_str() -> Option<ffi::unaryfunc> {
         None
     }
 }
-impl<T> PyObjectStrProtocolImpl for T where T: for<'p> PyObjectStrProtocol<'p>
+impl<T> PyObjectStrProtocolImpl for T
+where
+    T: for<'p> PyObjectStrProtocol<'p>,
 {
     #[inline]
     fn tp_str() -> Option<ffi::unaryfunc> {
-        py_unary_func!(PyObjectStrProtocol, T::__str__,
+        py_unary_func!(
-                       <T as PyObjectStrProtocol>::Success, PyObjectCallbackConverter)
+            PyObjectStrProtocol,
+            T::__str__,
+            <T as PyObjectStrProtocol>::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
 trait PyObjectReprProtocolImpl {
     fn tp_repr() -> Option<ffi::unaryfunc>;
 }
-impl<'p, T> PyObjectReprProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectReprProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn tp_repr() -> Option<ffi::unaryfunc> {
         None
     }
 }
-impl<T> PyObjectReprProtocolImpl for T where T: for<'p> PyObjectReprProtocol<'p>
+impl<T> PyObjectReprProtocolImpl for T
+where
+    T: for<'p> PyObjectReprProtocol<'p>,
 {
     #[inline]
     fn tp_repr() -> Option<ffi::unaryfunc> {
-        py_unary_func!(PyObjectReprProtocol,
+        py_unary_func!(
-                       T::__repr__, T::Success, PyObjectCallbackConverter)
+            PyObjectReprProtocol,
+            T::__repr__,
+            T::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -270,7 +345,9 @@ impl<T> PyObjectReprProtocolImpl for T where T: for<'p> PyObjectReprProtocol<'p>
 pub trait PyObjectFormatProtocolImpl {
     fn __format__() -> Option<PyMethodDef>;
 }
-impl<'p, T> PyObjectFormatProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectFormatProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn __format__() -> Option<PyMethodDef> {
@@ -282,7 +359,9 @@ impl<'p, T> PyObjectFormatProtocolImpl for T where T: PyObjectProtocol<'p>
 pub trait PyObjectBytesProtocolImpl {
     fn __bytes__() -> Option<PyMethodDef>;
 }
-impl<'p, T> PyObjectBytesProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectBytesProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn __bytes__() -> Option<PyMethodDef> {
@@ -294,7 +373,9 @@ impl<'p, T> PyObjectBytesProtocolImpl for T where T: PyObjectProtocol<'p>
 pub trait PyObjectUnicodeProtocolImpl {
     fn __unicode__() -> Option<PyMethodDef>;
 }
-impl<'p, T> PyObjectUnicodeProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectUnicodeProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn __unicode__() -> Option<PyMethodDef> {
@@ -305,7 +386,9 @@ impl<'p, T> PyObjectUnicodeProtocolImpl for T where T: PyObjectProtocol<'p>
 trait PyObjectHashProtocolImpl {
     fn tp_hash() -> Option<ffi::hashfunc>;
 }
-impl<'p, T> PyObjectHashProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectHashProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn tp_hash() -> Option<ffi::hashfunc> {
@@ -313,36 +396,55 @@ impl<'p, T> PyObjectHashProtocolImpl for T where T: PyObjectProtocol<'p>
     }
 }
 impl<T> PyObjectHashProtocolImpl for T
-    where T: for<'p> PyObjectHashProtocol<'p>
+where
+    T: for<'p> PyObjectHashProtocol<'p>,
 {
     #[inline]
     fn tp_hash() -> Option<ffi::hashfunc> {
-        py_unary_func!(PyObjectHashProtocol, T::__hash__, isize, HashConverter, ffi::Py_hash_t)
+        py_unary_func!(
+            PyObjectHashProtocol,
+            T::__hash__,
+            isize,
+            HashConverter,
+            ffi::Py_hash_t
+        )
     }
 }
 
 trait PyObjectBoolProtocolImpl {
     fn nb_bool() -> Option<ffi::inquiry>;
 }
-impl<'p, T> PyObjectBoolProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectBoolProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn nb_bool() -> Option<ffi::inquiry> {
         None
     }
 }
-impl<T> PyObjectBoolProtocolImpl for T where T: for<'p> PyObjectBoolProtocol<'p>
+impl<T> PyObjectBoolProtocolImpl for T
+where
+    T: for<'p> PyObjectBoolProtocol<'p>,
 {
     #[inline]
     fn nb_bool() -> Option<ffi::inquiry> {
-        py_unary_func!(PyObjectBoolProtocol, T::__bool__, bool, BoolCallbackConverter, c_int)
+        py_unary_func!(
+            PyObjectBoolProtocol,
+            T::__bool__,
+            bool,
+            BoolCallbackConverter,
+            c_int
+        )
     }
 }
 
 trait PyObjectRichcmpProtocolImpl {
     fn tp_richcompare() -> Option<ffi::richcmpfunc>;
 }
-impl<'p, T> PyObjectRichcmpProtocolImpl for T where T: PyObjectProtocol<'p>
+impl<'p, T> PyObjectRichcmpProtocolImpl for T
+where
+    T: PyObjectProtocol<'p>,
 {
     #[inline]
     default fn tp_richcompare() -> Option<ffi::richcmpfunc> {
@@ -350,14 +452,18 @@ impl<'p, T> PyObjectRichcmpProtocolImpl for T where T: PyObjectProtocol<'p>
     }
 }
 impl<T> PyObjectRichcmpProtocolImpl for T
-    where T: for<'p> PyObjectRichcmpProtocol<'p>
+where
+    T: for<'p> PyObjectRichcmpProtocol<'p>,
 {
     #[inline]
     fn tp_richcompare() -> Option<ffi::richcmpfunc> {
-        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     arg: *mut ffi::PyObject,
+            slf: *mut ffi::PyObject,
-                                     op: c_int) -> *mut ffi::PyObject
+            arg: *mut ffi::PyObject,
-            where T: for<'p> PyObjectRichcmpProtocol<'p>
+            op: c_int,
+        ) -> *mut ffi::PyObject
+        where
+            T: for<'p> PyObjectRichcmpProtocol<'p>,
         {
             let _pool = ::GILPool::new();
             let py = Python::assume_gil_acquired();
@@ -366,16 +472,13 @@ impl<T> PyObjectRichcmpProtocolImpl for T
 
             let res = match extract_op(op) {
                 Ok(op) => match arg.extract() {
-                    Ok(arg) =>
+                    Ok(arg) => slf.__richcmp__(arg, op).into(),
-                        slf.__richcmp__(arg, op).into(),
                     Err(e) => Err(e),
                 },
-                Err(e) => Err(e)
+                Err(e) => Err(e),
             };
             match res {
-                Ok(val) => {
+                Ok(val) => val.into_object(py).into_ptr(),
-                    val.into_object(py).into_ptr()
-                }
                 Err(e) => {
                     e.restore(py);
                     std::ptr::null_mut()
@@ -386,7 +489,6 @@ impl<T> PyObjectRichcmpProtocolImpl for T
     }
 }
 
-
 fn extract_op(op: c_int) -> PyResult<CompareOp> {
     match op {
         ffi::Py_LT => Ok(CompareOp::Lt),
@@ -396,6 +498,7 @@ fn extract_op(op: c_int) -> PyResult<CompareOp> {
         ffi::Py_GT => Ok(CompareOp::Gt),
         ffi::Py_GE => Ok(CompareOp::Ge),
         _ => Err(PyErr::new::<exc::ValueError, _>(
-            "tp_richcompare called with invalid comparison operator"))
+            "tp_richcompare called with invalid comparison operator",
+        )),
     }
 }

src/class/buffer.rs

@@ -6,25 +6,30 @@
 //! c-api
 use std::os::raw::c_int;
 
-use ffi;
-use err::PyResult;
-use typeob::PyTypeInfo;
 use callback::UnitCallbackConverter;
-
+use err::PyResult;
+use ffi;
+use typeob::PyTypeInfo;
 
 /// Buffer protocol interface
 ///
 /// For more information check [buffer protocol](https://docs.python.org/3/c-api/buffer.html)
 /// c-api
 #[allow(unused_variables)]
-pub trait PyBufferProtocol<'p> : PyTypeInfo
+pub trait PyBufferProtocol<'p>: PyTypeInfo {
-{
+    fn bf_getbuffer(&'p self, view: *mut ffi::Py_buffer, flags: c_int) -> Self::Result
-    fn bf_getbuffer(&'p self,
+    where
-                    view: *mut ffi::Py_buffer, flags: c_int) -> Self::Result
+        Self: PyBufferGetBufferProtocol<'p>,
-        where Self: PyBufferGetBufferProtocol<'p> { unimplemented!() }
+    {
+        unimplemented!()
+    }
 
     fn bf_releasebuffer(&'p self, view: *mut ffi::Py_buffer) -> Self::Result
-        where Self: PyBufferReleaseBufferProtocol<'p> { unimplemented!() }
+    where
+        Self: PyBufferReleaseBufferProtocol<'p>,
+    {
+        unimplemented!()
+    }
 }
 
 pub trait PyBufferGetBufferProtocol<'p>: PyBufferProtocol<'p> {
@@ -35,25 +40,28 @@ pub trait PyBufferReleaseBufferProtocol<'p>: PyBufferProtocol<'p> {
     type Result: Into<PyResult<()>>;
 }
 
-
 #[doc(hidden)]
 pub trait PyBufferProtocolImpl {
     fn tp_as_buffer() -> Option<ffi::PyBufferProcs>;
 }
 
 impl<T> PyBufferProtocolImpl for T {
-    default fn tp_as_buffer() -> Option<ffi::PyBufferProcs> { None }
+    default fn tp_as_buffer() -> Option<ffi::PyBufferProcs> {
+        None
+    }
 }
 
-impl<'p, T> PyBufferProtocolImpl for T where T: PyBufferProtocol<'p>
+impl<'p, T> PyBufferProtocolImpl for T
+where
+    T: PyBufferProtocol<'p>,
 {
     #[inline]
 
     fn tp_as_buffer() -> Option<ffi::PyBufferProcs> {
-        Some(ffi::PyBufferProcs{
+        Some(ffi::PyBufferProcs {
             bf_getbuffer: Self::cb_bf_getbuffer(),
             bf_releasebuffer: None,
-            .. ffi::PyBufferProcs_INIT
+            ..ffi::PyBufferProcs_INIT
         })
     }
 }
@@ -62,7 +70,9 @@ trait PyBufferGetBufferProtocolImpl {
     fn cb_bf_getbuffer() -> Option<ffi::getbufferproc>;
 }
 
-impl<'p, T> PyBufferGetBufferProtocolImpl for T where T: PyBufferProtocol<'p>
+impl<'p, T> PyBufferGetBufferProtocolImpl for T
+where
+    T: PyBufferProtocol<'p>,
 {
     #[inline]
     default fn cb_bf_getbuffer() -> Option<ffi::getbufferproc> {
@@ -71,14 +81,18 @@ impl<'p, T> PyBufferGetBufferProtocolImpl for T where T: PyBufferProtocol<'p>
 }
 
 impl<T> PyBufferGetBufferProtocolImpl for T
-    where T: for<'p> PyBufferGetBufferProtocol<'p>
+where
+    T: for<'p> PyBufferGetBufferProtocol<'p>,
 {
     #[inline]
     fn cb_bf_getbuffer() -> Option<ffi::getbufferproc> {
-        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     arg1: *mut ffi::Py_buffer,
+            slf: *mut ffi::PyObject,
-                                     arg2: c_int) -> c_int
+            arg1: *mut ffi::Py_buffer,
-            where T: for<'p> PyBufferGetBufferProtocol<'p>
+            arg2: c_int,
+        ) -> c_int
+        where
+            T: for<'p> PyBufferGetBufferProtocol<'p>,
         {
             let _pool = ::GILPool::new();
             let py = ::Python::assume_gil_acquired();

src/class/context.rs

@@ -4,23 +4,31 @@
 //! Trait and support implementation for context manager api
 //!
 
+use class::methods::PyMethodDef;
 use err::PyResult;
 use typeob::PyTypeInfo;
-use class::methods::PyMethodDef;
-
 
 /// Context manager interface
 #[allow(unused_variables)]
 pub trait PyContextProtocol<'p>: PyTypeInfo {
+    fn __enter__(&'p mut self) -> Self::Result
+    where
+        Self: PyContextEnterProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __enter__(&'p mut self)
+    fn __exit__(
-                 -> Self::Result where Self: PyContextEnterProtocol<'p> {unimplemented!()}
+        &'p mut self,
-
+        exc_type: Option<Self::ExcType>,
-    fn __exit__(&'p mut self,
+        exc_value: Option<Self::ExcValue>,
-                exc_type: Option<Self::ExcType>,
+        traceback: Option<Self::Traceback>,
-                exc_value: Option<Self::ExcValue>,
+    ) -> Self::Result
-                traceback: Option<Self::Traceback>)
+    where
-                -> Self::Result where Self: PyContextExitProtocol<'p> { unimplemented!() }
+        Self: PyContextExitProtocol<'p>,
+    {
+        unimplemented!()
+    }
 }
 
 pub trait PyContextEnterProtocol<'p>: PyContextProtocol<'p> {
@@ -48,7 +56,10 @@ impl<T> PyContextProtocolImpl for T {
     }
 }
 
-impl<'p, T> PyContextProtocolImpl for T where T: PyContextProtocol<'p> {
+impl<'p, T> PyContextProtocolImpl for T
+where
+    T: PyContextProtocol<'p>,
+{
     #[inline]
     fn methods() -> Vec<PyMethodDef> {
         let mut methods = Vec::new();
@@ -69,7 +80,9 @@ pub trait PyContextEnterProtocolImpl {
     fn __enter__() -> Option<PyMethodDef>;
 }
 
-impl<'p, T> PyContextEnterProtocolImpl for T where T: PyContextProtocol<'p>
+impl<'p, T> PyContextEnterProtocolImpl for T
+where
+    T: PyContextProtocol<'p>,
 {
     #[inline]
     default fn __enter__() -> Option<PyMethodDef> {
@@ -82,7 +95,9 @@ pub trait PyContextExitProtocolImpl {
     fn __exit__() -> Option<PyMethodDef>;
 }
 
-impl<'p, T> PyContextExitProtocolImpl for T where T: PyContextProtocol<'p>
+impl<'p, T> PyContextExitProtocolImpl for T
+where
+    T: PyContextProtocol<'p>,
 {
     #[inline]
     default fn __exit__() -> Option<PyMethodDef> {

src/class/descr.rs

@@ -7,30 +7,44 @@
 
 use std::os::raw::c_int;
 
-use ffi;
-use err::PyResult;
-use objects::{PyType, PyObjectRef};
 use callback::{PyObjectCallbackConverter, UnitCallbackConverter};
-use typeob::PyTypeInfo;
 use class::methods::PyMethodDef;
-use conversion::{IntoPyObject, FromPyObject};
+use conversion::{FromPyObject, IntoPyObject};
-
+use err::PyResult;
+use ffi;
+use objects::{PyObjectRef, PyType};
+use typeob::PyTypeInfo;
 
 /// Descriptor interface
 #[allow(unused_variables)]
 pub trait PyDescrProtocol<'p>: PyTypeInfo {
+    fn __get__(&'p self, instance: &'p PyObjectRef, owner: Option<&'p PyType>) -> Self::Result
+    where
+        Self: PyDescrGetProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __get__(&'p self, instance: &'p PyObjectRef, owner: Option<&'p PyType>)
+    fn __set__(&'p self, instance: &'p PyObjectRef, value: &'p PyObjectRef) -> Self::Result
-               -> Self::Result where Self: PyDescrGetProtocol<'p> { unimplemented!() }
+    where
+        Self: PyDescrSetProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __set__(&'p self, instance: &'p PyObjectRef, value: &'p PyObjectRef)
+    fn __delete__(&'p self, instance: &'p PyObjectRef) -> Self::Result
-               -> Self::Result where Self: PyDescrSetProtocol<'p> { unimplemented!() }
+    where
+        Self: PyDescrDeleteProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __delete__(&'p self, instance: &'p PyObjectRef)
+    fn __set_name__(&'p self, instance: &'p PyObjectRef) -> Self::Result
-                  -> Self::Result where Self: PyDescrDeleteProtocol<'p> { unimplemented!() }
+    where
-
+        Self: PyDescrSetNameProtocol<'p>,
-    fn __set_name__(&'p self, instance: &'p PyObjectRef)
+    {
-                    -> Self::Result where Self: PyDescrSetNameProtocol<'p> { unimplemented!() }
+        unimplemented!()
+    }
 }
 
 pub trait PyDescrGetProtocol<'p>: PyDescrProtocol<'p> {
@@ -56,40 +70,63 @@ pub trait PyDescrSetNameProtocol<'p>: PyDescrProtocol<'p> {
     type Result: Into<PyResult<()>>;
 }
 
-
 trait PyDescrGetProtocolImpl {
     fn tp_descr_get() -> Option<ffi::descrgetfunc>;
 }
-impl<'p, T> PyDescrGetProtocolImpl for T where T: PyDescrProtocol<'p> {
+impl<'p, T> PyDescrGetProtocolImpl for T
+where
+    T: PyDescrProtocol<'p>,
+{
     default fn tp_descr_get() -> Option<ffi::descrgetfunc> {
         None
     }
 }
-impl<T> PyDescrGetProtocolImpl for T where T: for<'p> PyDescrGetProtocol<'p>
+impl<T> PyDescrGetProtocolImpl for T
+where
+    T: for<'p> PyDescrGetProtocol<'p>,
 {
     fn tp_descr_get() -> Option<ffi::descrgetfunc> {
-        py_ternary_func!(PyDescrGetProtocol, T::__get__, T::Success, PyObjectCallbackConverter)
+        py_ternary_func!(
+            PyDescrGetProtocol,
+            T::__get__,
+            T::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 trait PyDescrSetProtocolImpl {
     fn tp_descr_set() -> Option<ffi::descrsetfunc>;
 }
-impl<'p, T> PyDescrSetProtocolImpl for T where T: PyDescrProtocol<'p> {
+impl<'p, T> PyDescrSetProtocolImpl for T
+where
+    T: PyDescrProtocol<'p>,
+{
     default fn tp_descr_set() -> Option<ffi::descrsetfunc> {
         None
     }
 }
-impl<T> PyDescrSetProtocolImpl for T where T: for<'p> PyDescrSetProtocol<'p>
+impl<T> PyDescrSetProtocolImpl for T
+where
+    T: for<'p> PyDescrSetProtocol<'p>,
 {
     fn tp_descr_set() -> Option<ffi::descrsetfunc> {
-        py_ternary_func!(PyDescrSetProtocol, T::__set__, (), UnitCallbackConverter, c_int)
+        py_ternary_func!(
+            PyDescrSetProtocol,
+            T::__set__,
+            (),
+            UnitCallbackConverter,
+            c_int
+        )
     }
 }
 
 trait PyDescrDelProtocolImpl {
     fn __del__() -> Option<PyMethodDef>;
 }
-impl<'p, T> PyDescrDelProtocolImpl for T where T: PyDescrProtocol<'p> {
+impl<'p, T> PyDescrDelProtocolImpl for T
+where
+    T: PyDescrProtocol<'p>,
+{
     default fn __del__() -> Option<PyMethodDef> {
         None
     }
@@ -98,7 +135,10 @@ impl<'p, T> PyDescrDelProtocolImpl for T where T: PyDescrProtocol<'p> {
 trait PyDescrSetNameProtocolImpl {
     fn __set_name__() -> Option<PyMethodDef>;
 }
-impl<'p, T> PyDescrSetNameProtocolImpl for T where T: PyDescrProtocol<'p> {
+impl<'p, T> PyDescrSetNameProtocolImpl for T
+where
+    T: PyDescrProtocol<'p>,
+{
     default fn __set_name__() -> Option<PyMethodDef> {
         None
     }
@@ -114,11 +154,13 @@ impl<T> PyDescrProtocolImpl for T {
     default fn methods() -> Vec<PyMethodDef> {
         Vec::new()
     }
-    default fn tp_as_descr(_type_object: &mut ffi::PyTypeObject) {
+    default fn tp_as_descr(_type_object: &mut ffi::PyTypeObject) {}
-    }
 }
 
-impl<'p, T> PyDescrProtocolImpl for T where T: PyDescrProtocol<'p> {
+impl<'p, T> PyDescrProtocolImpl for T
+where
+    T: PyDescrProtocol<'p>,
+{
     fn methods() -> Vec<PyMethodDef> {
         Vec::new()
     }

src/class/gc.rs

@@ -14,13 +14,14 @@ pub struct PyTraverseError(c_int);
 
 /// GC support
 #[allow(unused_variables)]
-pub trait PyGCProtocol<'p> : PyTypeInfo {
+pub trait PyGCProtocol<'p>: PyTypeInfo {
-
+    fn __traverse__(&'p self, visit: PyVisit) -> Result<(), PyTraverseError> {
-    fn __traverse__(&'p self, visit: PyVisit)
+        unimplemented!()
-                    -> Result<(), PyTraverseError> { unimplemented!() }
+    }
-
-    fn __clear__(&'p mut self) { unimplemented!() }
 
+    fn __clear__(&'p mut self) {
+        unimplemented!()
+    }
 }
 
 pub trait PyGCTraverseProtocol<'p>: PyGCProtocol<'p> {}
@@ -35,7 +36,9 @@ impl<'p, T> PyGCProtocolImpl for T {
     default fn update_type_object(_type_object: &mut ffi::PyTypeObject) {}
 }
 
-impl<'p, T> PyGCProtocolImpl for T where T: PyGCProtocol<'p>
+impl<'p, T> PyGCProtocolImpl for T
+where
+    T: PyGCProtocol<'p>,
 {
     fn update_type_object(type_object: &mut ffi::PyTypeObject) {
         type_object.tp_traverse = Self::tp_traverse();
@@ -50,12 +53,13 @@ pub struct PyVisit<'p> {
     /// VisitProc contains a Python instance to ensure that
     /// 1) it is cannot be moved out of the traverse() call
     /// 2) it cannot be sent to other threads
-    _py: Python<'p>
+    _py: Python<'p>,
 }
 
-impl <'p> PyVisit<'p> {
+impl<'p> PyVisit<'p> {
     pub fn call<T>(&self, obj: &T) -> Result<(), PyTraverseError>
-        where T: ToPyPointer
+    where
+        T: ToPyPointer,
     {
         let r = unsafe { (self.visit)(obj.as_ptr(), self.arg) };
         if r == 0 {
@@ -70,7 +74,9 @@ trait PyGCTraverseProtocolImpl {
     fn tp_traverse() -> Option<ffi::traverseproc>;
 }
 
-impl<'p, T> PyGCTraverseProtocolImpl for T where T: PyGCProtocol<'p>
+impl<'p, T> PyGCTraverseProtocolImpl for T
+where
+    T: PyGCProtocol<'p>,
 {
     #[inline]
     default fn tp_traverse() -> Option<ffi::traverseproc> {
@@ -79,23 +85,32 @@ impl<'p, T> PyGCTraverseProtocolImpl for T where T: PyGCProtocol<'p>
 }
 
 #[doc(hidden)]
-impl<T> PyGCTraverseProtocolImpl for T where T: for<'p> PyGCTraverseProtocol<'p>
+impl<T> PyGCTraverseProtocolImpl for T
+where
+    T: for<'p> PyGCTraverseProtocol<'p>,
 {
     #[inline]
     fn tp_traverse() -> Option<ffi::traverseproc> {
-        unsafe extern "C" fn tp_traverse<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn tp_traverse<T>(
-                                            visit: ffi::visitproc,
+            slf: *mut ffi::PyObject,
-                                            arg: *mut c_void) -> c_int
+            visit: ffi::visitproc,
-            where T: for<'p> PyGCTraverseProtocol<'p>
+            arg: *mut c_void,
+        ) -> c_int
+        where
+            T: for<'p> PyGCTraverseProtocol<'p>,
         {
             let _pool = ::GILPool::new();
             let py = Python::assume_gil_acquired();
             let slf = py.mut_from_borrowed_ptr::<T>(slf);
 
-            let visit = PyVisit { visit, arg, _py: py };
+            let visit = PyVisit {
+                visit,
+                arg,
+                _py: py,
+            };
             match slf.__traverse__(visit) {
                 Ok(()) => 0,
-                Err(PyTraverseError(code)) => code
+                Err(PyTraverseError(code)) => code,
             }
         }
 
@@ -103,12 +118,13 @@ impl<T> PyGCTraverseProtocolImpl for T where T: for<'p> PyGCTraverseProtocol<'p>
     }
 }
 
-
 trait PyGCClearProtocolImpl {
     fn tp_clear() -> Option<ffi::inquiry>;
 }
 
-impl<'p, T> PyGCClearProtocolImpl for T where T: PyGCProtocol<'p>
+impl<'p, T> PyGCClearProtocolImpl for T
+where
+    T: PyGCProtocol<'p>,
 {
     #[inline]
     default fn tp_clear() -> Option<ffi::inquiry> {
@@ -116,12 +132,15 @@ impl<'p, T> PyGCClearProtocolImpl for T where T: PyGCProtocol<'p>
     }
 }
 
-impl<T> PyGCClearProtocolImpl for T where T: for<'p> PyGCClearProtocol<'p>
+impl<T> PyGCClearProtocolImpl for T
+where
+    T: for<'p> PyGCClearProtocol<'p>,
 {
     #[inline]
     fn tp_clear() -> Option<ffi::inquiry> {
         unsafe extern "C" fn tp_clear<T>(slf: *mut ffi::PyObject) -> c_int
-            where T: for<'p> PyGCClearProtocol<'p>
+        where
+            T: for<'p> PyGCClearProtocol<'p>,
         {
             let _pool = ::GILPool::new();
             let py = Python::assume_gil_acquired();

src/class/iter.rs

@@ -4,26 +4,32 @@
 
 use std::ptr;
 
-use ffi;
-use err::PyResult;
-use python::{Python, IntoPyPointer};
-use typeob::PyTypeInfo;
-use conversion::IntoPyObject;
 use callback::{CallbackConverter, PyObjectCallbackConverter};
-
+use conversion::IntoPyObject;
+use err::PyResult;
+use ffi;
+use python::{IntoPyPointer, Python};
+use typeob::PyTypeInfo;
 
 /// Python Iterator Interface.
 ///
 /// more information
 /// `https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_iter`
 #[allow(unused_variables)]
-pub trait PyIterProtocol<'p> : PyTypeInfo {
+pub trait PyIterProtocol<'p>: PyTypeInfo {
-    fn __iter__(&'p mut self)
+    fn __iter__(&'p mut self) -> Self::Result
-                -> Self::Result where Self: PyIterIterProtocol<'p> { unimplemented!() }
+    where
-
+        Self: PyIterIterProtocol<'p>,
-    fn __next__(&'p mut self)
+    {
-                -> Self::Result where Self: PyIterNextProtocol<'p> { unimplemented!() }
+        unimplemented!()
+    }
 
+    fn __next__(&'p mut self) -> Self::Result
+    where
+        Self: PyIterNextProtocol<'p>,
+    {
+        unimplemented!()
+    }
 }
 
 pub trait PyIterIterProtocol<'p>: PyIterProtocol<'p> {
@@ -36,7 +42,6 @@ pub trait PyIterNextProtocol<'p>: PyIterProtocol<'p> {
     type Result: Into<PyResult<Option<Self::Success>>>;
 }
 
-
 #[doc(hidden)]
 pub trait PyIterProtocolImpl {
     fn tp_as_iter(typeob: &mut ffi::PyTypeObject);
@@ -47,7 +52,10 @@ impl<T> PyIterProtocolImpl for T {
     default fn tp_as_iter(_: &mut ffi::PyTypeObject) {}
 }
 
-impl<'p, T> PyIterProtocolImpl for T where T: PyIterProtocol<'p> {
+impl<'p, T> PyIterProtocolImpl for T
+where
+    T: PyIterProtocol<'p>,
+{
     #[inline]
     fn tp_as_iter(typeob: &mut ffi::PyTypeObject) {
         typeob.tp_iter = Self::tp_iter();
@@ -59,7 +67,9 @@ trait PyIterIterProtocolImpl {
     fn tp_iter() -> Option<ffi::getiterfunc>;
 }
 
-impl<'p, T> PyIterIterProtocolImpl for T where T: PyIterProtocol<'p>
+impl<'p, T> PyIterIterProtocolImpl for T
+where
+    T: PyIterProtocol<'p>,
 {
     #[inline]
     default fn tp_iter() -> Option<ffi::getiterfunc> {
@@ -67,11 +77,18 @@ impl<'p, T> PyIterIterProtocolImpl for T where T: PyIterProtocol<'p>
     }
 }
 
-impl<T> PyIterIterProtocolImpl for T where T: for<'p> PyIterIterProtocol<'p>
+impl<T> PyIterIterProtocolImpl for T
+where
+    T: for<'p> PyIterIterProtocol<'p>,
 {
     #[inline]
     fn tp_iter() -> Option<ffi::getiterfunc> {
-        py_unary_func!(PyIterIterProtocol, T::__iter__, T::Success, PyObjectCallbackConverter)
+        py_unary_func!(
+            PyIterIterProtocol,
+            T::__iter__,
+            T::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -80,7 +97,8 @@ trait PyIterNextProtocolImpl {
 }
 
 impl<'p, T> PyIterNextProtocolImpl for T
-    where T: PyIterProtocol<'p>
+where
+    T: PyIterProtocol<'p>,
 {
     #[inline]
     default fn tp_iternext() -> Option<ffi::iternextfunc> {
@@ -88,20 +106,26 @@ impl<'p, T> PyIterNextProtocolImpl for T
     }
 }
 
-impl<T> PyIterNextProtocolImpl for T where T: for<'p> PyIterNextProtocol<'p>
+impl<T> PyIterNextProtocolImpl for T
+where
+    T: for<'p> PyIterNextProtocol<'p>,
 {
     #[inline]
     fn tp_iternext() -> Option<ffi::iternextfunc> {
-        py_unary_func!(PyIterNextProtocol, T::__next__,
+        py_unary_func!(
-                       Option<T::Success>, IterNextConverter)
+            PyIterNextProtocol,
+            T::__next__,
+            Option<T::Success>,
+            IterNextConverter
+        )
     }
 }
 
-
 struct IterNextConverter;
 
-impl <T> CallbackConverter<Option<T>> for IterNextConverter
+impl<T> CallbackConverter<Option<T>> for IterNextConverter
-    where T: IntoPyObject
+where
+    T: IntoPyObject,
 {
     type R = *mut ffi::PyObject;
 
@@ -111,7 +135,7 @@ impl <T> CallbackConverter<Option<T>> for IterNextConverter
             None => unsafe {
                 ffi::PyErr_SetNone(ffi::PyExc_StopIteration);
                 ptr::null_mut()
-            }
+            },
         }
     }
 

src/class/macros.rs

@@ -4,11 +4,18 @@
 #[doc(hidden)]
 macro_rules! py_unary_func {
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr) => {
-        py_unary_func!($trait, $class::$f, $res_type, $conv, *mut $crate::ffi::PyObject);
+        py_unary_func!(
+            $trait,
+            $class::$f,
+            $res_type,
+            $conv,
+            *mut $crate::ffi::PyObject
+        );
     };
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr, $ret_type:ty) => {{
         unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject) -> $ret_type
-            where T: for<'p> $trait<'p>
+        where
+            T: for<'p> $trait<'p>,
         {
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
@@ -17,16 +24,16 @@ macro_rules! py_unary_func {
             $crate::callback::cb_convert($conv, py, res)
         }
         Some(wrap::<$class>)
-    }}
+    }};
 }
 
 #[macro_export]
 #[doc(hidden)]
-    macro_rules! py_unary_func_self {
+macro_rules! py_unary_func_self {
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:ty) => {{
-        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject)
+        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject) -> *mut $crate::ffi::PyObject
-                                     -> *mut $crate::ffi::PyObject
+        where
-            where T: for<'p> $trait<'p>
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
             let _pool = $crate::GILPool::new();
@@ -36,17 +43,16 @@ macro_rules! py_unary_func {
             $crate::callback::cb_convert($conv, py, res)
         }
         Some(wrap::<$class>)
-    }}
+    }};
 }
 
-
 #[macro_export]
 #[doc(hidden)]
 macro_rules! py_len_func {
     ($trait:ident, $class:ident :: $f:ident, $conv:expr) => {{
-        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject)
+        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject) -> $crate::ffi::Py_ssize_t
-                                     -> $crate::ffi::Py_ssize_t
+        where
-            where T: for<'p> $trait<'p>
+            T: for<'p> $trait<'p>,
         {
             let _pool = $crate::GILPool::new();
             let py = Python::assume_gil_acquired();
@@ -56,20 +62,26 @@ macro_rules! py_len_func {
             $crate::callback::cb_convert($conv, py, result)
         }
         Some(wrap::<$class>)
-    }}
+    }};
 }
 
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_binary_func{
+macro_rules! py_binary_func {
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr) => {
-        py_binary_func!($trait, $class::$f, $res_type, $conv, *mut $crate::ffi::PyObject)
+        py_binary_func!(
+            $trait,
+            $class::$f,
+            $res_type,
+            $conv,
+            *mut $crate::ffi::PyObject
+        )
     };
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr, $return:ty) => {{
         #[allow(unused_mut)]
-        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject, arg: *mut ffi::PyObject) -> $return
-                                     arg: *mut ffi::PyObject) -> $return
+        where
-            where T: for<'p> $trait<'p>
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
             let _pool = $crate::GILPool::new();
@@ -84,17 +96,20 @@ macro_rules! py_binary_func{
             $crate::callback::cb_convert($conv, py, result)
         }
         Some(wrap::<$class>)
-    }}
+    }};
 }
 
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_binary_num_func{
+macro_rules! py_binary_num_func {
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr) => {{
         #[allow(unused_mut)]
-        unsafe extern "C" fn wrap<T>(lhs: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     rhs: *mut ffi::PyObject) -> *mut $crate::ffi::PyObject
+            lhs: *mut ffi::PyObject,
-            where T: for<'p> $trait<'p>
+            rhs: *mut ffi::PyObject,
+        ) -> *mut $crate::ffi::PyObject
+        where
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
             let _pool = $crate::GILPool::new();
@@ -112,17 +127,20 @@ macro_rules! py_binary_num_func{
             $crate::callback::cb_convert($conv, py, result)
         }
         Some(wrap::<$class>)
-    }}
+    }};
 }
 
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_binary_self_func{
+macro_rules! py_binary_self_func {
     ($trait:ident, $class:ident :: $f:ident) => {{
         #[allow(unused_mut)]
-        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     arg: *mut ffi::PyObject) -> *mut $crate::ffi::PyObject
+            slf: *mut ffi::PyObject,
-            where T: for<'p> $trait<'p>
+            arg: *mut ffi::PyObject,
+        ) -> *mut $crate::ffi::PyObject
+        where
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
 
@@ -147,18 +165,20 @@ macro_rules! py_binary_self_func{
             }
         }
         Some(wrap::<$class>)
-    }}
+    }};
 }
 
-
 #[macro_export]
 #[doc(hidden)]
 macro_rules! py_ssizearg_func {
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr) => {{
         #[allow(unused_mut)]
-        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     arg: $crate::ffi::Py_ssize_t) -> *mut $crate::ffi::PyObject
+            slf: *mut ffi::PyObject,
-            where T: for<'p> $trait<'p>
+            arg: $crate::ffi::Py_ssize_t,
+        ) -> *mut $crate::ffi::PyObject
+        where
+            T: for<'p> $trait<'p>,
         {
             let _pool = $crate::GILPool::new();
             let py = $crate::Python::assume_gil_acquired();
@@ -167,20 +187,29 @@ macro_rules! py_ssizearg_func {
             $crate::callback::cb_convert($conv, py, result)
         }
         Some(wrap::<$class>)
-    }}
+    }};
 }
 
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_ternary_func{
+macro_rules! py_ternary_func {
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr) => {
-        py_ternary_func!($trait, $class::$f, $res_type, $conv, *mut $crate::ffi::PyObject);
+        py_ternary_func!(
+            $trait,
+            $class::$f,
+            $res_type,
+            $conv,
+            *mut $crate::ffi::PyObject
+        );
     };
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr, $return_type:ty) => {{
-        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     arg1: *mut $crate::ffi::PyObject,
+            slf: *mut $crate::ffi::PyObject,
-                                     arg2: *mut $crate::ffi::PyObject) -> $return_type
+            arg1: *mut $crate::ffi::PyObject,
-            where T: for<'p> $trait<'p>
+            arg2: *mut $crate::ffi::PyObject,
+        ) -> $return_type
+        where
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
 
@@ -193,25 +222,28 @@ macro_rules! py_ternary_func{
             let result = match arg1.extract() {
                 Ok(arg1) => match arg2.extract() {
                     Ok(arg2) => slf.$f(arg1, arg2).into(),
-                    Err(e) => Err(e.into())
+                    Err(e) => Err(e.into()),
                 },
                 Err(e) => Err(e.into()),
             };
             $crate::callback::cb_convert($conv, py, result)
         }
 
-         Some(wrap::<T>)
+        Some(wrap::<T>)
-    }}
+    }};
 }
 
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_ternary_num_func{
+macro_rules! py_ternary_num_func {
     ($trait:ident, $class:ident :: $f:ident, $res_type:ty, $conv:expr) => {{
-        unsafe extern "C" fn wrap<T>(arg1: *mut $crate::ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     arg2: *mut $crate::ffi::PyObject,
+            arg1: *mut $crate::ffi::PyObject,
-                                     arg3: *mut $crate::ffi::PyObject) -> *mut $crate::ffi::PyObject
+            arg2: *mut $crate::ffi::PyObject,
-            where T: for<'p> $trait<'p>
+            arg3: *mut $crate::ffi::PyObject,
+        ) -> *mut $crate::ffi::PyObject
+        where
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
 
@@ -225,28 +257,30 @@ macro_rules! py_ternary_num_func{
                 Ok(arg1) => match arg2.extract() {
                     Ok(arg2) => match arg3.extract() {
                         Ok(arg3) => $class::$f(arg1, arg2, arg3).into(),
-                        Err(e) => Err(e.into())
+                        Err(e) => Err(e.into()),
                     },
-                    Err(e) => Err(e.into())
+                    Err(e) => Err(e.into()),
                 },
                 Err(e) => Err(e.into()),
             };
             $crate::callback::cb_convert($conv, py, result)
         }
 
-         Some(wrap::<T>)
+        Some(wrap::<T>)
-    }}
+    }};
 }
 
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_ternary_self_func{
+macro_rules! py_ternary_self_func {
     ($trait:ident, $class:ident :: $f:ident) => {{
-        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     arg1: *mut $crate::ffi::PyObject,
+            slf: *mut $crate::ffi::PyObject,
-                                     arg2: *mut $crate::ffi::PyObject)
+            arg1: *mut $crate::ffi::PyObject,
-                                     -> *mut $crate::ffi::PyObject
+            arg2: *mut $crate::ffi::PyObject,
-            where T: for<'p> $trait<'p>
+        ) -> *mut $crate::ffi::PyObject
+        where
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
 
@@ -259,7 +293,7 @@ macro_rules! py_ternary_self_func{
             let result = match arg1.extract() {
                 Ok(arg1) => match arg2.extract() {
                     Ok(arg2) => slf1.$f(arg1, arg2).into(),
-                    Err(e) => Err(e.into())
+                    Err(e) => Err(e.into()),
                 },
                 Err(e) => Err(e.into()),
             };
@@ -273,18 +307,20 @@ macro_rules! py_ternary_self_func{
             }
         }
         Some(wrap::<T>)
-    }}
+    }};
 }
 
-
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_func_set{
+macro_rules! py_func_set {
     ($trait:ident, $class:ident :: $f:ident) => {{
-        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     name: *mut $crate::ffi::PyObject,
+            slf: *mut $crate::ffi::PyObject,
-                                     value: *mut $crate::ffi::PyObject) -> $crate::c_int
+            name: *mut $crate::ffi::PyObject,
-            where T: for<'p> $trait<'p>
+            value: *mut $crate::ffi::PyObject,
+        ) -> $crate::c_int
+        where
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
 
@@ -293,8 +329,10 @@ macro_rules! py_func_set{
             let slf = py.mut_from_borrowed_ptr::<T>(slf);
 
             if value.is_null() {
-                let e = $crate::PyErr::new::<exc::NotImplementedError, _>(
+                let e = $crate::PyErr::new::<exc::NotImplementedError, _>(format!(
-                    format!("Subscript deletion not supported by {:?}", stringify!(T)));
+                    "Subscript deletion not supported by {:?}",
+                    stringify!(T)
+                ));
                 e.restore(py);
                 -1
             } else {
@@ -302,15 +340,13 @@ macro_rules! py_func_set{
                 let value = py.from_borrowed_ptr::<$crate::PyObjectRef>(value);
                 let result = match name.extract() {
                     Ok(name) => match value.extract() {
-                        Ok(value) =>
+                        Ok(value) => slf.$f(name, value).into(),
-                            slf.$f(name, value).into(),
                         Err(e) => Err(e.into()),
                     },
                     Err(e) => Err(e.into()),
                 };
                 match result {
-                    Ok(_) =>
+                    Ok(_) => 0,
-                        0,
                     Err(e) => {
                         e.restore(py);
                         -1
@@ -319,20 +355,22 @@ macro_rules! py_func_set{
             }
         }
 
-         Some(wrap::<T>)
+        Some(wrap::<T>)
-    }}
+    }};
 }
 
-
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_func_del{
+macro_rules! py_func_del {
     ($trait:ident, $class:ident :: $f:ident) => {{
         #[allow(unused_mut)]
-        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     name: *mut $crate::ffi::PyObject,
+            slf: *mut $crate::ffi::PyObject,
-                                     value: *mut $crate::ffi::PyObject) -> $crate::c_int
+            name: *mut $crate::ffi::PyObject,
-            where T: for<'p> $trait<'p>
+            value: *mut $crate::ffi::PyObject,
+        ) -> $crate::c_int
+        where
+            T: for<'p> $trait<'p>,
         {
             use $crate::ObjectProtocol;
 
@@ -355,26 +393,30 @@ macro_rules! py_func_del{
                     }
                 }
             } else {
-                let e = PyErr::new::<exc::NotImplementedError, _>(
+                let e = PyErr::new::<exc::NotImplementedError, _>(format!(
-                    format!("Subscript assignment not supported by {:?}", stringify!(T)));
+                    "Subscript assignment not supported by {:?}",
+                    stringify!(T)
+                ));
                 e.restore(py);
                 -1
             }
         }
 
-         Some(wrap::<T>)
+        Some(wrap::<T>)
-    }}
+    }};
 }
 
-
 #[macro_export]
 #[doc(hidden)]
-macro_rules! py_func_set_del{
+macro_rules! py_func_set_del {
     ($trait:ident, $trait2:ident, $class:ident :: $f:ident/$f2:ident) => {{
-        unsafe extern "C" fn wrap<T>(slf: *mut $crate::ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     name: *mut $crate::ffi::PyObject,
+            slf: *mut $crate::ffi::PyObject,
-                                     value: *mut $crate::ffi::PyObject) -> $crate::c_int
+            name: *mut $crate::ffi::PyObject,
-            where T: for<'p> $trait<'p> + for<'p> $trait2<'p>
+            value: *mut $crate::ffi::PyObject,
+        ) -> $crate::c_int
+        where
+            T: for<'p> $trait<'p> + for<'p> $trait2<'p>,
         {
             use $crate::ObjectProtocol;
 
@@ -399,9 +441,7 @@ macro_rules! py_func_set_del{
                 let value = py.from_borrowed_ptr::<$crate::PyObjectRef>(value);
                 let result = match name.extract() {
                     Ok(name) => match value.extract() {
-                        Ok(value) => {
+                        Ok(value) => slf.$f(name, value).into(),
-                            slf.$f(name, value).into()
-                        },
                         Err(e) => Err(e.into()),
                     },
                     Err(e) => Err(e.into()),
@@ -416,5 +456,5 @@ macro_rules! py_func_set_del{
             }
         }
         Some(wrap::<T>)
-    }}
+    }};
 }

src/class/mapping.rs

@@ -3,44 +3,68 @@
 //! Python Mapping Interface
 //! Trait and support implementation for implementing mapping support
 
-use ffi;
+use callback::{LenResultConverter, PyObjectCallbackConverter};
-use err::{PyErr, PyResult};
-use python::Python;
-use objects::exc;
-use callback::{PyObjectCallbackConverter, LenResultConverter};
-use conversion::{IntoPyObject, FromPyObject};
-use typeob::PyTypeInfo;
 use class::methods::PyMethodDef;
-
+use conversion::{FromPyObject, IntoPyObject};
+use err::{PyErr, PyResult};
+use ffi;
+use objects::exc;
+use python::Python;
+use typeob::PyTypeInfo;
 
 /// Mapping interface
 #[allow(unused_variables)]
 pub trait PyMappingProtocol<'p>: PyTypeInfo {
+    fn __len__(&'p self) -> Self::Result
+    where
+        Self: PyMappingLenProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __len__(&'p self)
+    fn __getitem__(&'p self, key: Self::Key) -> Self::Result
-               -> Self::Result where Self: PyMappingLenProtocol<'p> {unimplemented!()}
+    where
+        Self: PyMappingGetItemProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __getitem__(&'p self, key: Self::Key)
+    fn __setitem__(&'p mut self, key: Self::Key, value: Self::Value) -> Self::Result
-                   -> Self::Result where Self: PyMappingGetItemProtocol<'p> {unimplemented!()}
+    where
+        Self: PyMappingSetItemProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __setitem__(&'p mut self, key: Self::Key, value: Self::Value)
+    fn __delitem__(&'p mut self, key: Self::Key) -> Self::Result
-                   -> Self::Result where Self: PyMappingSetItemProtocol<'p> {unimplemented!()}
+    where
+        Self: PyMappingDelItemProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __delitem__(&'p mut self, key: Self::Key)
+    fn __iter__(&'p self, py: Python<'p>) -> Self::Result
-                   -> Self::Result where Self: PyMappingDelItemProtocol<'p> {unimplemented!()}
+    where
+        Self: PyMappingIterProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
-    fn __iter__(&'p self, py: Python<'p>)
+    fn __contains__(&'p self, value: Self::Value) -> Self::Result
-                -> Self::Result where Self: PyMappingIterProtocol<'p> {unimplemented!()}
+    where
-
+        Self: PyMappingContainsProtocol<'p>,
-    fn __contains__(&'p self, value: Self::Value)
+    {
-                    -> Self::Result where Self: PyMappingContainsProtocol<'p> {unimplemented!()}
+        unimplemented!()
-
+    }
-    fn __reversed__(&'p self)
-                    -> Self::Result where Self: PyMappingReversedProtocol<'p> {unimplemented!()}
 
+    fn __reversed__(&'p self) -> Self::Result
+    where
+        Self: PyMappingReversedProtocol<'p>,
+    {
+        unimplemented!()
+    }
 }
 
-
 // The following are a bunch of marker traits used to detect
 // the existance of a slotted method.
 
@@ -97,7 +121,10 @@ impl<T> PyMappingProtocolImpl for T {
     }
 }
 
-impl<'p, T> PyMappingProtocolImpl for T where T: PyMappingProtocol<'p> {
+impl<'p, T> PyMappingProtocolImpl for T
+where
+    T: PyMappingProtocol<'p>,
+{
     #[inline]
     fn tp_as_mapping() -> Option<ffi::PyMappingMethods> {
         let f = if let Some(df) = Self::mp_del_subscript() {
@@ -135,7 +162,9 @@ trait PyMappingLenProtocolImpl {
     fn mp_length() -> Option<ffi::lenfunc>;
 }
 
-impl<'p, T> PyMappingLenProtocolImpl for T where T: PyMappingProtocol<'p>
+impl<'p, T> PyMappingLenProtocolImpl for T
+where
+    T: PyMappingProtocol<'p>,
 {
     #[inline]
     default fn mp_length() -> Option<ffi::lenfunc> {
@@ -143,7 +172,9 @@ impl<'p, T> PyMappingLenProtocolImpl for T where T: PyMappingProtocol<'p>
     }
 }
 
-impl<T> PyMappingLenProtocolImpl for T where T: for<'p> PyMappingLenProtocol<'p>
+impl<T> PyMappingLenProtocolImpl for T
+where
+    T: for<'p> PyMappingLenProtocol<'p>,
 {
     #[inline]
     fn mp_length() -> Option<ffi::lenfunc> {
@@ -155,7 +186,9 @@ trait PyMappingGetItemProtocolImpl {
     fn mp_subscript() -> Option<ffi::binaryfunc>;
 }
 
-impl<'p, T> PyMappingGetItemProtocolImpl for T where T: PyMappingProtocol<'p>
+impl<'p, T> PyMappingGetItemProtocolImpl for T
+where
+    T: PyMappingProtocol<'p>,
 {
     #[inline]
     default fn mp_subscript() -> Option<ffi::binaryfunc> {
@@ -163,12 +196,18 @@ impl<'p, T> PyMappingGetItemProtocolImpl for T where T: PyMappingProtocol<'p>
     }
 }
 
-impl<T> PyMappingGetItemProtocolImpl for T where T: for<'p> PyMappingGetItemProtocol<'p>
+impl<T> PyMappingGetItemProtocolImpl for T
+where
+    T: for<'p> PyMappingGetItemProtocol<'p>,
 {
     #[inline]
     fn mp_subscript() -> Option<ffi::binaryfunc> {
-        py_binary_func!(PyMappingGetItemProtocol,
+        py_binary_func!(
-                        T::__getitem__, T::Success, PyObjectCallbackConverter)
+            PyMappingGetItemProtocol,
+            T::__getitem__,
+            T::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -176,7 +215,9 @@ trait PyMappingSetItemProtocolImpl {
     fn mp_ass_subscript() -> Option<ffi::objobjargproc>;
 }
 
-impl<'p, T> PyMappingSetItemProtocolImpl for T where T: PyMappingProtocol<'p>
+impl<'p, T> PyMappingSetItemProtocolImpl for T
+where
+    T: PyMappingProtocol<'p>,
 {
     #[inline]
     default fn mp_ass_subscript() -> Option<ffi::objobjargproc> {
@@ -184,7 +225,9 @@ impl<'p, T> PyMappingSetItemProtocolImpl for T where T: PyMappingProtocol<'p>
     }
 }
 
-impl<T> PyMappingSetItemProtocolImpl for T where T: for<'p> PyMappingSetItemProtocol<'p>
+impl<T> PyMappingSetItemProtocolImpl for T
+where
+    T: for<'p> PyMappingSetItemProtocol<'p>,
 {
     #[inline]
     fn mp_ass_subscript() -> Option<ffi::objobjargproc> {
@@ -192,12 +235,13 @@ impl<T> PyMappingSetItemProtocolImpl for T where T: for<'p> PyMappingSetItemProt
     }
 }
 
-
 trait PyMappingDelItemProtocolImpl {
     fn mp_del_subscript() -> Option<ffi::objobjargproc>;
 }
 
-impl<'p, T> PyMappingDelItemProtocolImpl for T where T: PyMappingProtocol<'p>
+impl<'p, T> PyMappingDelItemProtocolImpl for T
+where
+    T: PyMappingProtocol<'p>,
 {
     #[inline]
     default fn mp_del_subscript() -> Option<ffi::objobjargproc> {
@@ -205,7 +249,9 @@ impl<'p, T> PyMappingDelItemProtocolImpl for T where T: PyMappingProtocol<'p>
     }
 }
 
-impl<T> PyMappingDelItemProtocolImpl for T where T: for<'p> PyMappingDelItemProtocol<'p>
+impl<T> PyMappingDelItemProtocolImpl for T
+where
+    T: for<'p> PyMappingDelItemProtocol<'p>,
 {
     #[inline]
     default fn mp_del_subscript() -> Option<ffi::objobjargproc> {
@@ -213,24 +259,28 @@ impl<T> PyMappingDelItemProtocolImpl for T where T: for<'p> PyMappingDelItemProt
     }
 }
 
-
 impl<T> PyMappingDelItemProtocolImpl for T
-    where T: for<'p> PyMappingSetItemProtocol<'p> + for<'p> PyMappingDelItemProtocol<'p>
+where
+    T: for<'p> PyMappingSetItemProtocol<'p> + for<'p> PyMappingDelItemProtocol<'p>,
 {
     #[inline]
     fn mp_del_subscript() -> Option<ffi::objobjargproc> {
-        py_func_set_del!(PyMappingSetItemProtocol, PyMappingDelItemProtocol,
+        py_func_set_del!(
-                         T::__setitem__/__delitem__)
+            PyMappingSetItemProtocol,
+            PyMappingDelItemProtocol,
+            T::__setitem__ / __delitem__
+        )
     }
 }
 
-
 #[doc(hidden)]
 pub trait PyMappingContainsProtocolImpl {
     fn __contains__() -> Option<PyMethodDef>;
 }
 
-impl<'p, T> PyMappingContainsProtocolImpl for T where T: PyMappingProtocol<'p>
+impl<'p, T> PyMappingContainsProtocolImpl for T
+where
+    T: PyMappingProtocol<'p>,
 {
     #[inline]
     default fn __contains__() -> Option<PyMethodDef> {
@@ -243,7 +293,9 @@ pub trait PyMappingReversedProtocolImpl {
     fn __reversed__() -> Option<PyMethodDef>;
 }
 
-impl<'p, T> PyMappingReversedProtocolImpl for T where T: PyMappingProtocol<'p>
+impl<'p, T> PyMappingReversedProtocolImpl for T
+where
+    T: PyMappingProtocol<'p>,
 {
     #[inline]
     default fn __reversed__() -> Option<PyMethodDef> {
@@ -256,7 +308,9 @@ pub trait PyMappingIterProtocolImpl {
     fn __iter__() -> Option<PyMethodDef>;
 }
 
-impl<'p, T> PyMappingIterProtocolImpl for T where T: PyMappingProtocol<'p>
+impl<'p, T> PyMappingIterProtocolImpl for T
+where
+    T: PyMappingProtocol<'p>,
 {
     #[inline]
     default fn __iter__() -> Option<PyMethodDef> {

src/class/methods.rs

@@ -67,34 +67,29 @@ unsafe impl Sync for PyGetterDef {}
 unsafe impl Sync for PySetterDef {}
 unsafe impl Sync for ffi::PyGetSetDef {}
 
-
 impl PyMethodDef {
-
     /// Convert `PyMethodDef` to Python method definition struct `ffi::PyMethodDef`
     pub fn as_method_def(&self) -> ffi::PyMethodDef {
         let meth = match self.ml_meth {
             PyMethodType::PyCFunction(meth) => meth,
-            PyMethodType::PyCFunctionWithKeywords(meth) =>
+            PyMethodType::PyCFunctionWithKeywords(meth) => unsafe {
-                unsafe {
+                std::mem::transmute::<ffi::PyCFunctionWithKeywords, ffi::PyCFunction>(meth)
-                    std::mem::transmute::<ffi::PyCFunctionWithKeywords, ffi::PyCFunction>(meth)
+            },
-                },
+            PyMethodType::PyNoArgsFunction(meth) => unsafe {
-            PyMethodType::PyNoArgsFunction(meth) =>
+                std::mem::transmute::<ffi::PyNoArgsFunction, ffi::PyCFunction>(meth)
-                unsafe {
+            },
-                    std::mem::transmute::<ffi::PyNoArgsFunction, ffi::PyCFunction>(meth)
+            PyMethodType::PyNewFunc(meth) => unsafe {
-                },
+                std::mem::transmute::<ffi::newfunc, ffi::PyCFunction>(meth)
-            PyMethodType::PyNewFunc(meth) =>
+            },
-                unsafe {
+            PyMethodType::PyInitFunc(meth) => unsafe {
-                    std::mem::transmute::<ffi::newfunc, ffi::PyCFunction>(meth)
+                std::mem::transmute::<ffi::initproc, ffi::PyCFunction>(meth)
-                },
+            },
-            PyMethodType::PyInitFunc(meth) =>
-                unsafe {
-                    std::mem::transmute::<ffi::initproc, ffi::PyCFunction>(meth)
-                },
         };
 
         ffi::PyMethodDef {
-            ml_name: CString::new(self.ml_name).expect(
+            ml_name: CString::new(self.ml_name)
-                "Method name must not contain NULL byte").into_raw(),
+                .expect("Method name must not contain NULL byte")
+                .into_raw(),
             ml_meth: Some(meth),
             ml_flags: self.ml_flags,
             ml_doc: self.ml_doc.as_ptr() as *const _,
@@ -106,8 +101,9 @@ impl PyGetterDef {
     /// Copy descriptor information to `ffi::PyGetSetDef`
     pub fn copy_to(&self, dst: &mut ffi::PyGetSetDef) {
         if dst.name.is_null() {
-            dst.name = CString::new(self.name).expect(
+            dst.name = CString::new(self.name)
-                "Method name must not contain NULL byte").into_raw();
+                .expect("Method name must not contain NULL byte")
+                .into_raw();
         }
         dst.get = Some(self.meth);
     }
@@ -117,8 +113,9 @@ impl PySetterDef {
     /// Copy descriptor information to `ffi::PyGetSetDef`
     pub fn copy_to(&self, dst: &mut ffi::PyGetSetDef) {
         if dst.name.is_null() {
-            dst.name = CString::new(self.name).expect(
+            dst.name = CString::new(self.name)
-                "Method name must not contain NULL byte").into_raw();
+                .expect("Method name must not contain NULL byte")
+                .into_raw();
         }
         dst.set = Some(self.meth);
     }

src/class/mod.rs

@@ -2,33 +2,33 @@
 
 //! Python object protocols
 
-#[macro_use] mod macros;
+#[macro_use]
+mod macros;
 
 pub mod async;
 pub mod basic;
 pub mod buffer;
 pub mod context;
 pub mod descr;
+pub mod gc;
+pub mod iter;
 pub mod mapping;
 pub mod methods;
 pub mod number;
-pub mod iter;
-pub mod gc;
 pub mod sequence;
 
-pub use self::basic::PyObjectProtocol;
 pub use self::async::PyAsyncProtocol;
-pub use self::iter::PyIterProtocol;
+pub use self::basic::PyObjectProtocol;
 pub use self::buffer::PyBufferProtocol;
 pub use self::context::PyContextProtocol;
 pub use self::descr::PyDescrProtocol;
-pub use self::number::PyNumberProtocol;
+pub use self::iter::PyIterProtocol;
 pub use self::mapping::PyMappingProtocol;
+pub use self::number::PyNumberProtocol;
 pub use self::sequence::PySequenceProtocol;
 
-pub use self::gc::{PyVisit, PyGCProtocol, PyTraverseError};
+pub use self::gc::{PyGCProtocol, PyTraverseError, PyVisit};
-pub use self::methods::{PyMethodDef, PyMethodDefType, PyMethodType,
+pub use self::methods::{PyGetterDef, PyMethodDef, PyMethodDefType, PyMethodType, PySetterDef};
-                        PyGetterDef, PySetterDef};
 
 use ffi;
 
@@ -40,5 +40,5 @@ pub enum CompareOp {
     Eq = ffi::Py_EQ as isize,
     Ne = ffi::Py_NE as isize,
     Gt = ffi::Py_GT as isize,
-    Ge = ffi::Py_GE as isize
+    Ge = ffi::Py_GE as isize,
 }

src/class/sequence.rs

@@ -5,46 +5,80 @@
 
 use std::os::raw::c_int;
 
-use ffi;
+use callback::{BoolCallbackConverter, LenResultConverter, PyObjectCallbackConverter};
-use python::Python;
+use conversion::{FromPyObject, IntoPyObject};
 use err::{PyErr, PyResult};
-use objects::{exc, PyObjectRef};
+use ffi;
 use objectprotocol::ObjectProtocol;
-use callback::{PyObjectCallbackConverter, LenResultConverter, BoolCallbackConverter};
+use objects::{exc, PyObjectRef};
+use python::Python;
 use typeob::PyTypeInfo;
-use conversion::{IntoPyObject, FromPyObject};
-
 
 /// Sequece interface
 #[allow(unused_variables)]
-pub trait PySequenceProtocol<'p>: PyTypeInfo + Sized
+pub trait PySequenceProtocol<'p>: PyTypeInfo + Sized {
-{
     fn __len__(&'p self) -> Self::Result
-        where Self: PySequenceLenProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceLenProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
     fn __getitem__(&'p self, key: isize) -> Self::Result
-        where Self: PySequenceGetItemProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceGetItemProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
     fn __setitem__(&'p mut self, key: isize, value: Self::Value) -> Self::Result
-        where Self: PySequenceSetItemProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceSetItemProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
     fn __delitem__(&'p mut self, key: isize) -> Self::Result
-        where Self: PySequenceDelItemProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceDelItemProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
     fn __contains__(&'p self, item: Self::Item) -> Self::Result
-        where Self: PySequenceContainsProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceContainsProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
     fn __concat__(&'p self, other: Self::Other) -> Self::Result
-        where Self: PySequenceConcatProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceConcatProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
     fn __repeat__(&'p self, count: isize) -> Self::Result
-        where Self: PySequenceRepeatProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceRepeatProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
     fn __inplace_concat__(&'p mut self, other: Self::Other) -> Self::Result
-        where Self: PySequenceInplaceConcatProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceInplaceConcatProtocol<'p>,
+    {
+        unimplemented!()
+    }
 
     fn __inplace_repeat__(&'p mut self, count: isize) -> Self::Result
-        where Self: PySequenceInplaceRepeatProtocol<'p> { unimplemented!() }
+    where
+        Self: PySequenceInplaceRepeatProtocol<'p>,
+    {
+        unimplemented!()
+    }
 }
 
 // The following are a bunch of marker traits used to detect
@@ -105,7 +139,10 @@ impl<T> PySequenceProtocolImpl for T {
     }
 }
 
-impl<'p, T> PySequenceProtocolImpl for T where T: PySequenceProtocol<'p> {
+impl<'p, T> PySequenceProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
+{
     #[cfg(Py_3)]
     #[inline]
     fn tp_as_sequence() -> Option<ffi::PySequenceMethods> {
@@ -156,7 +193,9 @@ trait PySequenceLenProtocolImpl {
     fn sq_length() -> Option<ffi::lenfunc>;
 }
 
-impl<'p, T> PySequenceLenProtocolImpl for T where T: PySequenceProtocol<'p>
+impl<'p, T> PySequenceLenProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_length() -> Option<ffi::lenfunc> {
@@ -164,7 +203,9 @@ impl<'p, T> PySequenceLenProtocolImpl for T where T: PySequenceProtocol<'p>
     }
 }
 
-impl<T> PySequenceLenProtocolImpl for T where T: for<'p> PySequenceLenProtocol<'p>
+impl<T> PySequenceLenProtocolImpl for T
+where
+    T: for<'p> PySequenceLenProtocol<'p>,
 {
     #[inline]
     fn sq_length() -> Option<ffi::lenfunc> {
@@ -176,7 +217,9 @@ trait PySequenceGetItemProtocolImpl {
     fn sq_item() -> Option<ffi::ssizeargfunc>;
 }
 
-impl<'p, T> PySequenceGetItemProtocolImpl for T where T: PySequenceProtocol<'p>
+impl<'p, T> PySequenceGetItemProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_item() -> Option<ffi::ssizeargfunc> {
@@ -185,12 +228,17 @@ impl<'p, T> PySequenceGetItemProtocolImpl for T where T: PySequenceProtocol<'p>
 }
 
 impl<T> PySequenceGetItemProtocolImpl for T
-    where T: for<'p> PySequenceGetItemProtocol<'p>
+where
+    T: for<'p> PySequenceGetItemProtocol<'p>,
 {
     #[inline]
     fn sq_item() -> Option<ffi::ssizeargfunc> {
         py_ssizearg_func!(
-            PySequenceGetItemProtocol, T::__getitem__, T::Success, PyObjectCallbackConverter)
+            PySequenceGetItemProtocol,
+            T::__getitem__,
+            T::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -198,7 +246,9 @@ trait PySequenceSetItemProtocolImpl {
     fn sq_ass_item() -> Option<ffi::ssizeobjargproc>;
 }
 
-impl<'p, T> PySequenceSetItemProtocolImpl for T where T: PySequenceProtocol<'p>
+impl<'p, T> PySequenceSetItemProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_ass_item() -> Option<ffi::ssizeobjargproc> {
@@ -207,30 +257,34 @@ impl<'p, T> PySequenceSetItemProtocolImpl for T where T: PySequenceProtocol<'p>
 }
 
 impl<T> PySequenceSetItemProtocolImpl for T
-    where T: for<'p> PySequenceSetItemProtocol<'p>
+where
+    T: for<'p> PySequenceSetItemProtocol<'p>,
 {
     #[inline]
     fn sq_ass_item() -> Option<ffi::ssizeobjargproc> {
-        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     key: ffi::Py_ssize_t,
+            slf: *mut ffi::PyObject,
-                                     value: *mut ffi::PyObject) -> c_int
+            key: ffi::Py_ssize_t,
-            where T: for<'p> PySequenceSetItemProtocol<'p>
+            value: *mut ffi::PyObject,
+        ) -> c_int
+        where
+            T: for<'p> PySequenceSetItemProtocol<'p>,
         {
             let _pool = ::GILPool::new();
             let py = Python::assume_gil_acquired();
             let slf = py.mut_from_borrowed_ptr::<T>(slf);
 
             if value.is_null() {
-                let e = PyErr::new::<exc::NotImplementedError, _>(
+                let e = PyErr::new::<exc::NotImplementedError, _>(format!(
-                    format!("Item deletion not supported by {:?}", stringify!(T)));
+                    "Item deletion not supported by {:?}",
+                    stringify!(T)
+                ));
                 e.restore(py);
                 -1
             } else {
                 let value = py.from_borrowed_ptr::<PyObjectRef>(value);
                 let result = match value.extract() {
-                    Ok(value) => {
+                    Ok(value) => slf.__setitem__(key as isize, value).into(),
-                        slf.__setitem__(key as isize, value).into()
-                    },
                     Err(e) => Err(e),
                 };
                 match result {
@@ -249,7 +303,9 @@ impl<T> PySequenceSetItemProtocolImpl for T
 trait PySequenceDelItemProtocolImpl {
     fn sq_del_item() -> Option<ffi::ssizeobjargproc>;
 }
-impl<'p, T> PySequenceDelItemProtocolImpl for T where T: PySequenceProtocol<'p>
+impl<'p, T> PySequenceDelItemProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_del_item() -> Option<ffi::ssizeobjargproc> {
@@ -258,14 +314,18 @@ impl<'p, T> PySequenceDelItemProtocolImpl for T where T: PySequenceProtocol<'p>
 }
 
 impl<T> PySequenceDelItemProtocolImpl for T
-    where T: for<'p> PySequenceDelItemProtocol<'p>
+where
+    T: for<'p> PySequenceDelItemProtocol<'p>,
 {
     #[inline]
     default fn sq_del_item() -> Option<ffi::ssizeobjargproc> {
-        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     key: ffi::Py_ssize_t,
+            slf: *mut ffi::PyObject,
-                                     value: *mut ffi::PyObject) -> c_int
+            key: ffi::Py_ssize_t,
-            where T: for<'p> PySequenceDelItemProtocol<'p>
+            value: *mut ffi::PyObject,
+        ) -> c_int
+        where
+            T: for<'p> PySequenceDelItemProtocol<'p>,
         {
             let _pool = ::GILPool::new();
             let py = Python::assume_gil_acquired();
@@ -281,8 +341,10 @@ impl<T> PySequenceDelItemProtocolImpl for T
                     }
                 }
             } else {
-                let e = PyErr::new::<exc::NotImplementedError, _>(
+                let e = PyErr::new::<exc::NotImplementedError, _>(format!(
-                    format!("Item assignment not supported by {:?}", stringify!(T)));
+                    "Item assignment not supported by {:?}",
+                    stringify!(T)
+                ));
                 e.restore(py);
                 -1
             }
@@ -292,15 +354,18 @@ impl<T> PySequenceDelItemProtocolImpl for T
 }
 
 impl<T> PySequenceDelItemProtocolImpl for T
-    where T: for<'p> PySequenceSetItemProtocol<'p> + for<'p> PySequenceDelItemProtocol<'p>
+where
+    T: for<'p> PySequenceSetItemProtocol<'p> + for<'p> PySequenceDelItemProtocol<'p>,
 {
     #[inline]
     fn sq_del_item() -> Option<ffi::ssizeobjargproc> {
-        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject,
+        unsafe extern "C" fn wrap<T>(
-                                     key: ffi::Py_ssize_t,
+            slf: *mut ffi::PyObject,
-                                     value: *mut ffi::PyObject) -> c_int
+            key: ffi::Py_ssize_t,
-            where T: for<'p> PySequenceSetItemProtocol<'p> +
+            value: *mut ffi::PyObject,
-               for<'p> PySequenceDelItemProtocol<'p>
+        ) -> c_int
+        where
+            T: for<'p> PySequenceSetItemProtocol<'p> + for<'p> PySequenceDelItemProtocol<'p>,
         {
             let _pool = ::GILPool::new();
             let py = Python::assume_gil_acquired();
@@ -318,9 +383,7 @@ impl<T> PySequenceDelItemProtocolImpl for T
             } else {
                 let value = py.from_borrowed_ptr::<PyObjectRef>(value);
                 let result = match value.extract() {
-                    Ok(value) => {
+                    Ok(value) => slf.__setitem__(key as isize, value).into(),
-                        slf.__setitem__(key as isize, value).into()
-                    },
                     Err(e) => Err(e),
                 };
                 match result {
@@ -336,12 +399,13 @@ impl<T> PySequenceDelItemProtocolImpl for T
     }
 }
 
-
 trait PySequenceContainsProtocolImpl {
     fn sq_contains() -> Option<ffi::objobjproc>;
 }
 
-impl<'p, T> PySequenceContainsProtocolImpl for T where T: PySequenceProtocol<'p>
+impl<'p, T> PySequenceContainsProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_contains() -> Option<ffi::objobjproc> {
@@ -350,12 +414,18 @@ impl<'p, T> PySequenceContainsProtocolImpl for T where T: PySequenceProtocol<'p>
 }
 
 impl<T> PySequenceContainsProtocolImpl for T
-    where T: for<'p> PySequenceContainsProtocol<'p>
+where
+    T: for<'p> PySequenceContainsProtocol<'p>,
 {
     #[inline]
     fn sq_contains() -> Option<ffi::objobjproc> {
-        py_binary_func!(PySequenceContainsProtocol,
+        py_binary_func!(
-                        T::__contains__, bool, BoolCallbackConverter, c_int)
+            PySequenceContainsProtocol,
+            T::__contains__,
+            bool,
+            BoolCallbackConverter,
+            c_int
+        )
     }
 }
 
@@ -363,7 +433,9 @@ trait PySequenceConcatProtocolImpl {
     fn sq_concat() -> Option<ffi::binaryfunc>;
 }
 
-impl<'p, T> PySequenceConcatProtocolImpl for T where T: PySequenceProtocol<'p>
+impl<'p, T> PySequenceConcatProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_concat() -> Option<ffi::binaryfunc> {
@@ -372,12 +444,17 @@ impl<'p, T> PySequenceConcatProtocolImpl for T where T: PySequenceProtocol<'p>
 }
 
 impl<T> PySequenceConcatProtocolImpl for T
-    where T: for<'p> PySequenceConcatProtocol<'p>
+where
+    T: for<'p> PySequenceConcatProtocol<'p>,
 {
     #[inline]
     fn sq_concat() -> Option<ffi::binaryfunc> {
-        py_binary_func!(PySequenceConcatProtocol,
+        py_binary_func!(
-                        T::__concat__, T::Success, PyObjectCallbackConverter)
+            PySequenceConcatProtocol,
+            T::__concat__,
+            T::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -386,7 +463,8 @@ trait PySequenceRepeatProtocolImpl {
 }
 
 impl<'p, T> PySequenceRepeatProtocolImpl for T
-    where T: PySequenceProtocol<'p>
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_repeat() -> Option<ffi::ssizeargfunc> {
@@ -394,12 +472,18 @@ impl<'p, T> PySequenceRepeatProtocolImpl for T
     }
 }
 
-impl<T> PySequenceRepeatProtocolImpl for T where T: for<'p> PySequenceRepeatProtocol<'p>
+impl<T> PySequenceRepeatProtocolImpl for T
+where
+    T: for<'p> PySequenceRepeatProtocol<'p>,
 {
     #[inline]
     fn sq_repeat() -> Option<ffi::ssizeargfunc> {
         py_ssizearg_func!(
-            PySequenceRepeatProtocol, T::__repeat__, T::Success, PyObjectCallbackConverter)
+            PySequenceRepeatProtocol,
+            T::__repeat__,
+            T::Success,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -407,7 +491,9 @@ trait PySequenceInplaceConcatProtocolImpl {
     fn sq_inplace_concat() -> Option<ffi::binaryfunc>;
 }
 
-impl<'p, T> PySequenceInplaceConcatProtocolImpl for T where T: PySequenceProtocol<'p>
+impl<'p, T> PySequenceInplaceConcatProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_inplace_concat() -> Option<ffi::binaryfunc> {
@@ -416,12 +502,17 @@ impl<'p, T> PySequenceInplaceConcatProtocolImpl for T where T: PySequenceProtoco
 }
 
 impl<T> PySequenceInplaceConcatProtocolImpl for T
-    where T: for<'p> PySequenceInplaceConcatProtocol<'p>
+where
+    T: for<'p> PySequenceInplaceConcatProtocol<'p>,
 {
     #[inline]
     fn sq_inplace_concat() -> Option<ffi::binaryfunc> {
-        py_binary_func!(PySequenceInplaceConcatProtocol,
+        py_binary_func!(
-                        T::__inplace_concat__, T, PyObjectCallbackConverter)
+            PySequenceInplaceConcatProtocol,
+            T::__inplace_concat__,
+            T,
+            PyObjectCallbackConverter
+        )
     }
 }
 
@@ -429,7 +520,9 @@ trait PySequenceInplaceRepeatProtocolImpl {
     fn sq_inplace_repeat() -> Option<ffi::ssizeargfunc>;
 }
 
-impl<'p, T> PySequenceInplaceRepeatProtocolImpl for T where T: PySequenceProtocol<'p>
+impl<'p, T> PySequenceInplaceRepeatProtocolImpl for T
+where
+    T: PySequenceProtocol<'p>,
 {
     #[inline]
     default fn sq_inplace_repeat() -> Option<ffi::ssizeargfunc> {
@@ -438,11 +531,16 @@ impl<'p, T> PySequenceInplaceRepeatProtocolImpl for T where T: PySequenceProtoco
 }
 
 impl<T> PySequenceInplaceRepeatProtocolImpl for T
-    where T: for<'p> PySequenceInplaceRepeatProtocol<'p>
+where
+    T: for<'p> PySequenceInplaceRepeatProtocol<'p>,
 {
     #[inline]
     fn sq_inplace_repeat() -> Option<ffi::ssizeargfunc> {
-        py_ssizearg_func!(PySequenceInplaceRepeatProtocol,
+        py_ssizearg_func!(
-                          T::__inplace_repeat__, T, PyObjectCallbackConverter)
+            PySequenceInplaceRepeatProtocol,
+            T::__inplace_repeat__,
+            T,
+            PyObjectCallbackConverter
+        )
     }
 }

src/conversion.rs

@@ -2,38 +2,39 @@
 
 //! This module contains some conversion traits
 
+use err::{PyDowncastError, PyResult};
 use ffi;
-use err::{PyResult, PyDowncastError};
+use instance::Py;
-use python::{Python, ToPyPointer, IntoPyPointer};
 use object::PyObject;
 use objects::{PyObjectRef, PyTuple};
+use python::{IntoPyPointer, Python, ToPyPointer};
 use typeob::PyTypeInfo;
-use instance::Py;
-
 
 /// Conversion trait that allows various objects to be converted into `PyObject`
 pub trait ToPyObject {
-
     /// Converts self into a Python object.
     fn to_object(&self, py: Python) -> PyObject;
-
 }
 
 pub trait ToBorrowedObject: ToPyObject {
-
     /// Converts self into a Python object and calls the specified closure
     /// on the native FFI pointer underlying the Python object.
     ///
     /// May be more efficient than `to_object` because it does not need
     /// to touch any reference counts when the input object already is a Python object.
     fn with_borrowed_ptr<F, R>(&self, py: Python, f: F) -> R
-        where F: FnOnce(*mut ffi::PyObject) -> R;
+    where
+        F: FnOnce(*mut ffi::PyObject) -> R;
 }
 
-impl<T> ToBorrowedObject for T where T: ToPyObject {
+impl<T> ToBorrowedObject for T
+where
+    T: ToPyObject,
+{
     #[inline]
     default fn with_borrowed_ptr<F, R>(&self, py: Python, f: F) -> R
-        where F: FnOnce(*mut ffi::PyObject) -> R
+    where
+        F: FnOnce(*mut ffi::PyObject) -> R,
     {
         let ptr = self.to_object(py).into_ptr();
         let result = f(ptr);
@@ -45,18 +46,14 @@ impl<T> ToBorrowedObject for T where T: ToPyObject {
 /// Conversion trait that allows various objects to be converted into `PyObject`
 /// by consuming original object.
 pub trait IntoPyObject {
-
     /// Converts self into a Python object. (Consumes self)
     fn into_object(self, py: Python) -> PyObject;
 }
 
-
 /// Conversion trait that allows various objects to be converted into `PyTuple` object.
 pub trait IntoPyTuple {
-
     /// Converts self into a PyTuple object.
     fn into_tuple(self, py: Python) -> Py<PyTuple>;
-
 }
 
 /// `FromPyObject` is implemented by various types that can be extracted from
@@ -79,15 +76,17 @@ pub trait IntoPyTuple {
 ///
 /// In cases where the result does not depend on the `'prepared` lifetime,
 /// the inherent method `PyObject::extract()` can be used.
-pub trait FromPyObject<'source> : Sized {
+pub trait FromPyObject<'source>: Sized {
     /// Extracts `Self` from the source `PyObject`.
     fn extract(ob: &'source PyObjectRef) -> PyResult<Self>;
 }
 
 /// Identity conversion: allows using existing `PyObject` instances where
 /// `T: ToPyObject` is expected.
-impl <'a, T: ?Sized> ToPyObject for &'a T where T: ToPyObject {
+impl<'a, T: ?Sized> ToPyObject for &'a T
-
+where
+    T: ToPyObject,
+{
     #[inline]
     fn to_object(&self, py: Python) -> PyObject {
         <T as ToPyObject>::to_object(*self, py)
@@ -96,8 +95,10 @@ impl <'a, T: ?Sized> ToPyObject for &'a T where T: ToPyObject {
 
 /// `Option::Some<T>` is converted like `T`.
 /// `Option::None` is converted to Python `None`.
-impl <T> ToPyObject for Option<T> where T: ToPyObject {
+impl<T> ToPyObject for Option<T>
-
+where
+    T: ToPyObject,
+{
     fn to_object(&self, py: Python) -> PyObject {
         match *self {
             Some(ref val) => val.to_object(py),
@@ -106,8 +107,10 @@ impl <T> ToPyObject for Option<T> where T: ToPyObject {
     }
 }
 
-impl<T> IntoPyObject for Option<T> where T: IntoPyObject {
+impl<T> IntoPyObject for Option<T>
-
+where
+    T: IntoPyObject,
+{
     fn into_object(self, py: Python) -> PyObject {
         match self {
             Some(val) => val.into_object(py),
@@ -129,7 +132,9 @@ impl IntoPyObject for () {
     }
 }
 
-impl<'a, T> IntoPyObject for &'a T where T: ToPyPointer
+impl<'a, T> IntoPyObject for &'a T
+where
+    T: ToPyPointer,
 {
     #[inline]
     fn into_object(self, py: Python) -> PyObject {
@@ -137,7 +142,10 @@ impl<'a, T> IntoPyObject for &'a T where T: ToPyPointer
     }
 }
 
-impl<'a, T> IntoPyObject for &'a mut T where T: ToPyPointer {
+impl<'a, T> IntoPyObject for &'a mut T
+where
+    T: ToPyPointer,
+{
     #[inline]
     fn into_object(self, py: Python) -> PyObject {
         unsafe { PyObject::from_borrowed_ptr(py, self.as_ptr()) }
@@ -146,7 +154,8 @@ impl<'a, T> IntoPyObject for &'a mut T where T: ToPyPointer {
 
 /// Extract reference to instance from `PyObject`
 impl<'a, T> FromPyObject<'a> for &'a T
-    where T: PyTypeInfo
+where
+    T: PyTypeInfo,
 {
     #[inline]
     default fn extract(ob: &'a PyObjectRef) -> PyResult<&'a T> {
@@ -156,7 +165,8 @@ impl<'a, T> FromPyObject<'a> for &'a T
 
 /// Extract mutable reference to instance from `PyObject`
 impl<'a, T> FromPyObject<'a> for &'a mut T
-    where T: PyTypeInfo
+where
+    T: PyTypeInfo,
 {
     #[inline]
     default fn extract(ob: &'a PyObjectRef) -> PyResult<&'a mut T> {
@@ -164,7 +174,9 @@ impl<'a, T> FromPyObject<'a> for &'a mut T
     }
 }
 
-impl<'a, T> FromPyObject<'a> for Option<T> where T: FromPyObject<'a>
+impl<'a, T> FromPyObject<'a> for Option<T>
+where
+    T: FromPyObject<'a>,
 {
     fn extract(obj: &'a PyObjectRef) -> PyResult<Self> {
         if obj.as_ptr() == unsafe { ffi::Py_None() } {
@@ -172,7 +184,7 @@ impl<'a, T> FromPyObject<'a> for Option<T> where T: FromPyObject<'a>
         } else {
             match T::extract(obj) {
                 Ok(v) => Ok(Some(v)),
-                Err(e) => Err(e)
+                Err(e) => Err(e),
             }
         }
     }
@@ -217,8 +229,10 @@ pub trait PyTryFrom: Sized {
 }
 
 // TryFrom implies TryInto
-impl<U> PyTryInto<U> for PyObjectRef where U: PyTryFrom {
+impl<U> PyTryInto<U> for PyObjectRef
-
+where
+    U: PyTryFrom,
+{
     type Error = U::Error;
 
     fn try_into(&self) -> Result<&U, U::Error> {
@@ -235,9 +249,10 @@ impl<U> PyTryInto<U> for PyObjectRef where U: PyTryFrom {
     }
 }
 
-
+impl<T> PyTryFrom for T
-impl<T> PyTryFrom for T where T: PyTypeInfo {
+where
-
+    T: PyTypeInfo,
+{
     type Error = PyDowncastError;
 
     fn try_from(value: &PyObjectRef) -> Result<&T, Self::Error> {
@@ -301,7 +316,6 @@ impl<T> PyTryFrom for T where T: PyTypeInfo {
     }
 }
 
-
 /// This trait wraps a T: IntoPyObject into PyResult<T> while PyResult<T> remains PyResult<T>.
 ///
 /// This is necessaty because proc macros run before typechecking and can't decide

src/err.rs

@@ -1,18 +1,18 @@
 // Copyright (c) 2017-present PyO3 Project and Contributors
-use std;
-use std::io;
-use std::ffi::CString;
-use std::os::raw::c_char;
-use std::error::Error;
 use libc;
+use std;
+use std::error::Error;
+use std::ffi::CString;
+use std::io;
+use std::os::raw::c_char;
 
+use conversion::{IntoPyObject, ToBorrowedObject, ToPyObject};
 use ffi;
-use python::{ToPyPointer, IntoPyPointer, Python};
-use object::PyObject;
-use objects::{PyObjectRef, PyType, exc};
 use instance::Py;
+use object::PyObject;
+use objects::{exc, PyObjectRef, PyType};
+use python::{IntoPyPointer, Python, ToPyPointer};
 use typeob::PyTypeObject;
-use conversion::{ToPyObject, IntoPyObject, ToBorrowedObject};
 
 /// Defines a new exception type.
 ///
@@ -78,8 +78,11 @@ macro_rules! py_exception {
                         let py = gil.python();
 
                         TYPE_OBJECT = $crate::PyErr::new_type(
-                            py, concat!(stringify!($module), ".", stringify!($name)),
+                            py,
-                            Some(py.get_type::<$base>()), None);
+                            concat!(stringify!($module), ".", stringify!($name)),
+                            Some(py.get_type::<$base>()),
+                            None,
+                        );
                     }
                     TYPE_OBJECT
                 }
@@ -96,14 +99,15 @@ macro_rules! py_exception {
             fn type_object() -> $crate::Py<$crate::PyType> {
                 unsafe {
                     $crate::Py::from_borrowed_ptr(
-                        $name::type_object() as *const _ as *mut $crate::ffi::PyObject)
+                        $name::type_object() as *const _ as *mut $crate::ffi::PyObject
+                    )
                 }
             }
         }
     };
     ($module: ident, $name: ident) => {
         py_exception!($module, $name, $crate::exc::Exception);
-    }
+    };
 }
 
 /// Represents a `PyErr` value
@@ -156,7 +160,9 @@ impl PyErr {
     /// Example:
     ///  `return Err(PyErr::new::<exc::TypeError, _>("Error message"));`
     pub fn new<T, V>(value: V) -> PyErr
-        where T: PyTypeObject, V: ToPyObject + 'static
+    where
+        T: PyTypeObject,
+        V: ToPyObject + 'static,
     {
         let ty = T::type_object();
         assert_ne!(unsafe { ffi::PyExceptionClass_Check(ty.as_ptr()) }, 0);
@@ -173,7 +179,8 @@ impl PyErr {
     /// like `exc::RuntimeError`.
     /// `args` is the a tuple of arguments to pass to the exception constructor.
     pub fn from_type<A>(exc: Py<PyType>, args: A) -> PyErr
-        where A: ToPyObject + 'static
+    where
+        A: ToPyObject + 'static,
     {
         PyErr {
             ptype: exc,
@@ -184,7 +191,8 @@ impl PyErr {
 
     /// Creates a new PyErr of type `T`.
     pub fn from_value<T>(value: PyErrValue) -> PyErr
-        where T: PyTypeObject
+    where
+        T: PyTypeObject,
     {
         let ty = T::type_object();
         assert_ne!(unsafe { ffi::PyExceptionClass_Check(ty.as_ptr()) }, 0);
@@ -207,7 +215,7 @@ impl PyErr {
 
         if unsafe { ffi::PyExceptionInstance_Check(ptr) } != 0 {
             PyErr {
-                ptype: unsafe { Py::from_borrowed_ptr( ffi::PyExceptionInstance_Class(ptr)) },
+                ptype: unsafe { Py::from_borrowed_ptr(ffi::PyExceptionInstance_Class(ptr)) },
                 pvalue: PyErrValue::Value(obj.into()),
                 ptraceback: None,
             }
@@ -220,8 +228,7 @@ impl PyErr {
         } else {
             PyErr {
                 ptype: exc::TypeError::type_object(),
-                pvalue: PyErrValue::ToObject(
+                pvalue: PyErrValue::ToObject(Box::new("exceptions must derive from BaseException")),
-                    Box::new("exceptions must derive from BaseException")),
                 ptraceback: None,
             }
         }
@@ -238,9 +245,9 @@ impl PyErr {
     /// If no error is set, returns a `SystemError`.
     pub fn fetch(_: Python) -> PyErr {
         unsafe {
-            let mut ptype      : *mut ffi::PyObject = std::ptr::null_mut();
+            let mut ptype: *mut ffi::PyObject = std::ptr::null_mut();
-            let mut pvalue     : *mut ffi::PyObject = std::ptr::null_mut();
+            let mut pvalue: *mut ffi::PyObject = std::ptr::null_mut();
-            let mut ptraceback : *mut ffi::PyObject = std::ptr::null_mut();
+            let mut ptraceback: *mut ffi::PyObject = std::ptr::null_mut();
             ffi::PyErr_Fetch(&mut ptype, &mut pvalue, &mut ptraceback);
             PyErr::new_from_ffi_tuple(ptype, pvalue, ptraceback)
         }
@@ -251,12 +258,15 @@ impl PyErr {
     ///
     /// `base` can be an existing exception type to subclass, or a tuple of classes
     /// `dict` specifies an optional dictionary of class variables and methods
-    pub fn new_type<'p>(_: Python<'p>, name: &str, base: Option<&PyType>, dict: Option<PyObject>)
+    pub fn new_type<'p>(
-                        -> *mut ffi::PyTypeObject
+        _: Python<'p>,
-    {
+        name: &str,
+        base: Option<&PyType>,
+        dict: Option<PyObject>,
+    ) -> *mut ffi::PyTypeObject {
         let base: *mut ffi::PyObject = match base {
             None => std::ptr::null_mut(),
-            Some(obj) => obj.as_ptr()
+            Some(obj) => obj.as_ptr(),
         };
 
         let dict: *mut ffi::PyObject = match dict {
@@ -265,16 +275,18 @@ impl PyErr {
         };
 
         unsafe {
-            let null_terminated_name = CString::new(name)
+            let null_terminated_name =
-                .expect("Failed to initialize nul terminated exception name");
+                CString::new(name).expect("Failed to initialize nul terminated exception name");
-            ffi::PyErr_NewException(
+            ffi::PyErr_NewException(null_terminated_name.as_ptr() as *mut c_char, base, dict)
-                null_terminated_name.as_ptr() as *mut c_char, base, dict) as *mut ffi::PyTypeObject
+                as *mut ffi::PyTypeObject
         }
     }
 
-    unsafe fn new_from_ffi_tuple(ptype: *mut ffi::PyObject,
+    unsafe fn new_from_ffi_tuple(
-                                 pvalue: *mut ffi::PyObject,
+        ptype: *mut ffi::PyObject,
-                                 ptraceback: *mut ffi::PyObject) -> PyErr {
+        pvalue: *mut ffi::PyObject,
+        ptraceback: *mut ffi::PyObject,
+    ) -> PyErr {
         // Note: must not panic to ensure all owned pointers get acquired correctly,
         // and because we mustn't panic in normalize().
 
@@ -315,7 +327,8 @@ impl PyErr {
     /// If `exc` is a class object, this also returns `true` when `self` is an instance of a subclass.
     /// If `exc` is a tuple, all exceptions in the tuple (and recursively in subtuples) are searched for a match.
     pub fn matches<T>(&self, py: Python, exc: T) -> bool
-        where T: ToBorrowedObject
+    where
+        T: ToBorrowedObject,
     {
         exc.with_borrowed_ptr(py, |exc| unsafe {
             ffi::PyErr_GivenExceptionMatches(self.ptype.as_ptr(), exc) != 0
@@ -324,11 +337,11 @@ impl PyErr {
 
     /// Return true if the current exception is instance of `T`
     pub fn is_instance<T>(&self, _py: Python) -> bool
-        where T: PyTypeObject
+    where
+        T: PyTypeObject,
     {
         unsafe {
-            ffi::PyErr_GivenExceptionMatches(
+            ffi::PyErr_GivenExceptionMatches(self.ptype.as_ptr(), T::type_object().as_ptr()) != 0
-                self.ptype.as_ptr(), T::type_object().as_ptr()) != 0
         }
     }
 
@@ -346,7 +359,11 @@ impl PyErr {
     /// Helper function for normalizing the error by deconstructing and reconstructing the PyErr.
     /// Must not panic for safety in normalize()
     fn into_normalized(self, py: Python) -> PyErr {
-        let PyErr { ptype, pvalue, ptraceback } = self;
+        let PyErr {
+            ptype,
+            pvalue,
+            ptraceback,
+        } = self;
 
         let mut pvalue = match pvalue {
             PyErrValue::None => std::ptr::null_mut(),
@@ -378,7 +395,11 @@ impl PyErr {
     /// This is the opposite of `PyErr::fetch()`.
     #[inline]
     pub fn restore(self, py: Python) {
-        let PyErr { ptype, pvalue, ptraceback } = self;
+        let PyErr {
+            ptype,
+            pvalue,
+            ptraceback,
+        } = self;
 
         let pvalue = match pvalue {
             PyErrValue::None => std::ptr::null_mut(),
@@ -386,18 +407,27 @@ impl PyErr {
             PyErrValue::ToArgs(ob) => ob.arguments(py).into_ptr(),
             PyErrValue::ToObject(ob) => ob.to_object(py).into_ptr(),
         };
-        unsafe {
+        unsafe { ffi::PyErr_Restore(ptype.into_ptr(), pvalue, ptraceback.into_ptr()) }
-            ffi::PyErr_Restore(ptype.into_ptr(), pvalue, ptraceback.into_ptr())
-        }
     }
 
     /// Issue a warning message.
     /// May return a PyErr if warnings-as-errors is enabled.
-    pub fn warn(py: Python, category: &PyObjectRef, message: &str, stacklevel: i32) -> PyResult<()> {
+    pub fn warn(
+        py: Python,
+        category: &PyObjectRef,
+        message: &str,
+        stacklevel: i32,
+    ) -> PyResult<()> {
         let message = CString::new(message)?;
         unsafe {
-            error_on_minusone(py, ffi::PyErr_WarnEx(
+            error_on_minusone(
-                category.as_ptr(), message.as_ptr(), stacklevel as ffi::Py_ssize_t))
+                py,
+                ffi::PyErr_WarnEx(
+                    category.as_ptr(),
+                    message.as_ptr(),
+                    stacklevel as ffi::Py_ssize_t,
+                ),
+            )
         }
     }
 
@@ -409,7 +439,11 @@ impl PyErr {
             PyErrValue::ToObject(ref ob) => PyErrValue::Value(ob.to_object(py)),
         };
 
-        let t = if let Some(ref val) = self.ptraceback { Some(val.clone_ref(py))} else { None };
+        let t = if let Some(ref val) = self.ptraceback {
+            Some(val.clone_ref(py))
+        } else {
+            None
+        };
         PyErr {
             ptype: self.ptype.clone_ref(py),
             pvalue: v,
@@ -425,14 +459,12 @@ impl std::fmt::Debug for PyErr {
 }
 
 impl IntoPyObject for PyErr {
-
     fn into_object(self, py: Python) -> PyObject {
         self.instance(py)
     }
 }
 
 impl ToPyObject for PyErr {
-
     fn to_object(&self, py: Python) -> PyObject {
         let err = self.clone_ref(py);
         err.instance(py)
@@ -440,7 +472,6 @@ impl ToPyObject for PyErr {
 }
 
 impl<'a> IntoPyObject for &'a PyErr {
-
     fn into_object(self, py: Python) -> PyObject {
         let err = self.clone_ref(py);
         err.instance(py)
@@ -454,8 +485,8 @@ impl std::convert::From<PyDowncastError> for PyErr {
     }
 }
 
-impl <'p> std::fmt::Debug for PyDowncastError {
+impl<'p> std::fmt::Debug for PyDowncastError {
-    fn fmt(&self, f : &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         f.write_str("PyDowncastError")
     }
 }
@@ -464,7 +495,9 @@ impl <'p> std::fmt::Debug for PyDowncastError {
 impl std::convert::From<PyErr> for std::io::Error {
     fn from(err: PyErr) -> Self {
         std::io::Error::new(
-            std::io::ErrorKind::Other, format!("Python exception: {:?}", err))
+            std::io::ErrorKind::Other,
+            format!("Python exception: {:?}", err),
+        )
     }
 }
 
@@ -488,7 +521,7 @@ macro_rules! impl_to_pyerr {
                 PyErr::from_value::<$pyexc>(PyErrValue::ToArgs(Box::new(err)))
             }
         }
-    }
+    };
 }
 
 #[cfg(Py_3)]
@@ -496,27 +529,31 @@ macro_rules! impl_to_pyerr {
 impl std::convert::From<io::Error> for PyErr {
     fn from(err: io::Error) -> PyErr {
         match err.kind() {
-            io::ErrorKind::BrokenPipe =>
+            io::ErrorKind::BrokenPipe => {
-                PyErr::from_value::<exc::BrokenPipeError>(PyErrValue::ToArgs(Box::new(err))),
+                PyErr::from_value::<exc::BrokenPipeError>(PyErrValue::ToArgs(Box::new(err)))
-            io::ErrorKind::ConnectionRefused =>
+            }
-                PyErr::from_value::<exc::ConnectionRefusedError>(
+            io::ErrorKind::ConnectionRefused => {
-                    PyErrValue::ToArgs(Box::new(err))),
+                PyErr::from_value::<exc::ConnectionRefusedError>(PyErrValue::ToArgs(Box::new(err)))
-            io::ErrorKind::ConnectionAborted =>
+            }
-                PyErr::from_value::<exc::ConnectionAbortedError>(
+            io::ErrorKind::ConnectionAborted => {
-                    PyErrValue::ToArgs(Box::new(err))),
+                PyErr::from_value::<exc::ConnectionAbortedError>(PyErrValue::ToArgs(Box::new(err)))
-            io::ErrorKind::ConnectionReset =>
+            }
-                PyErr::from_value::<exc::ConnectionResetError>(
+            io::ErrorKind::ConnectionReset => {
-                    PyErrValue::ToArgs(Box::new(err))),
+                PyErr::from_value::<exc::ConnectionResetError>(PyErrValue::ToArgs(Box::new(err)))
-            io::ErrorKind::Interrupted =>
+            }
-                PyErr::from_value::<exc::InterruptedError>(PyErrValue::ToArgs(Box::new(err))),
+            io::ErrorKind::Interrupted => {
-            io::ErrorKind::NotFound =>
+                PyErr::from_value::<exc::InterruptedError>(PyErrValue::ToArgs(Box::new(err)))
-                PyErr::from_value::<exc::FileNotFoundError>(PyErrValue::ToArgs(Box::new(err))),
+            }
-            io::ErrorKind::WouldBlock =>
+            io::ErrorKind::NotFound => {
-                PyErr::from_value::<exc::BlockingIOError>(PyErrValue::ToArgs(Box::new(err))),
+                PyErr::from_value::<exc::FileNotFoundError>(PyErrValue::ToArgs(Box::new(err)))
-            io::ErrorKind::TimedOut =>
+            }
-                PyErr::from_value::<exc::TimeoutError>(PyErrValue::ToArgs(Box::new(err))),
+            io::ErrorKind::WouldBlock => {
-            _ =>
+                PyErr::from_value::<exc::BlockingIOError>(PyErrValue::ToArgs(Box::new(err)))
-                PyErr::from_value::<exc::OSError>(PyErrValue::ToArgs(Box::new(err))),
+            }
+            io::ErrorKind::TimedOut => {
+                PyErr::from_value::<exc::TimeoutError>(PyErrValue::ToArgs(Box::new(err)))
+            }
+            _ => PyErr::from_value::<exc::OSError>(PyErrValue::ToArgs(Box::new(err))),
         }
     }
 }
@@ -529,7 +566,6 @@ impl std::convert::From<io::Error> for PyErr {
     }
 }
 
-
 /// Extract `errno` and `errdesc` from from `io::Error`
 impl PyErrArguments for io::Error {
     fn arguments(&self, py: Python) -> PyObject {
@@ -537,8 +573,7 @@ impl PyErrArguments for io::Error {
     }
 }
 
-impl<W: 'static + Send + std::fmt::Debug> std::convert::From<std::io::IntoInnerError<W>> for PyErr
+impl<W: 'static + Send + std::fmt::Debug> std::convert::From<std::io::IntoInnerError<W>> for PyErr {
-{
     fn from(err: std::io::IntoInnerError<W>) -> PyErr {
         PyErr::from_value::<exc::OSError>(PyErrValue::ToArgs(Box::new(err)))
     }
@@ -563,7 +598,9 @@ impl_to_pyerr!(std::char::DecodeUtf16Error, exc::UnicodeDecodeError);
 impl_to_pyerr!(std::net::AddrParseError, exc::ValueError);
 
 pub fn panic_after_error() -> ! {
-    unsafe { ffi::PyErr_Print(); }
+    unsafe {
+        ffi::PyErr_Print();
+    }
     panic!("Python API called failed");
 }
 
@@ -579,8 +616,8 @@ pub fn error_on_minusone(py: Python, result: libc::c_int) -> PyResult<()> {
 
 #[cfg(test)]
 mod tests {
-    use ::{Python, PyErr};
     use objects::exc;
+    use {PyErr, Python};
 
     #[test]
     fn set_typeerror() {

src/ffi2/boolobject.rs

@@ -1,10 +1,11 @@
-use std::os::raw::{c_int, c_long};
-use ffi2::object::*;
 use ffi2::intobject::PyIntObject;
+use ffi2::object::*;
+use std::os::raw::{c_int, c_long};
 
 pub type PyBoolObject = PyIntObject;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyBool_Type: PyTypeObject;
     static mut _Py_ZeroStruct: PyIntObject;
     static mut _Py_TrueStruct: PyIntObject;
@@ -12,8 +13,8 @@ pub type PyBoolObject = PyIntObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyBool_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyBool_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyBool_Type;
+    let u: *mut PyTypeObject = &mut PyBool_Type;
     (Py_TYPE(op) == u) as c_int
 }
 

src/ffi2/bufferobject.rs

@@ -1,28 +1,33 @@
-use std::os::raw::{c_void, c_int};
 use ffi2::object::*;
 use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_int, c_void};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyBuffer_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyBuffer_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyBuffer_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyBuffer_Type;
+    let u: *mut PyTypeObject = &mut PyBuffer_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
 pub const Py_END_OF_BUFFER: Py_ssize_t = -1;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyBuffer_FromObject(base: *mut PyObject, offset: Py_ssize_t,
+extern "C" {
-                               size: Py_ssize_t) -> *mut PyObject;
+    pub fn PyBuffer_FromObject(
-    pub fn PyBuffer_FromReadWriteObject(base: *mut PyObject,
+        base: *mut PyObject,
-                                        offset: Py_ssize_t, size: Py_ssize_t)
+        offset: Py_ssize_t,
-                                        -> *mut PyObject;
+        size: Py_ssize_t,
-    pub fn PyBuffer_FromMemory(ptr: *mut c_void, size: Py_ssize_t)
+    ) -> *mut PyObject;
-                               -> *mut PyObject;
+    pub fn PyBuffer_FromReadWriteObject(
-    pub fn PyBuffer_FromReadWriteMemory(ptr: *mut c_void,
+        base: *mut PyObject,
-                                        size: Py_ssize_t) -> *mut PyObject;
+        offset: Py_ssize_t,
+        size: Py_ssize_t,
+    ) -> *mut PyObject;
+    pub fn PyBuffer_FromMemory(ptr: *mut c_void, size: Py_ssize_t) -> *mut PyObject;
+    pub fn PyBuffer_FromReadWriteMemory(ptr: *mut c_void, size: Py_ssize_t) -> *mut PyObject;
     pub fn PyBuffer_New(size: Py_ssize_t) -> *mut PyObject;
 }

src/ffi2/bytearrayobject.rs

@@ -1,6 +1,6 @@
-use std::os::raw::{c_char, c_int};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
 /*#[repr(C)]
 #[deriving(Copy)]
@@ -17,30 +17,29 @@ struct PyByteArrayObject {
     pub ob_bytes: *mut c_char,
 }*/
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyByteArray_Type: PyTypeObject;
     pub static mut PyByteArrayIter_Type: PyTypeObject;
 }
 
-pub unsafe fn PyByteArray_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyByteArray_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyByteArray_Type)
 }
 
-pub unsafe fn PyByteArray_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyByteArray_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyByteArray_Type;
+    let u: *mut PyTypeObject = &mut PyByteArray_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyByteArray_FromObject(o: *mut PyObject) -> *mut PyObject;
-    pub fn PyByteArray_Concat(a: *mut PyObject, b: *mut PyObject)
+    pub fn PyByteArray_Concat(a: *mut PyObject, b: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyByteArray_FromStringAndSize(string: *const c_char, len: Py_ssize_t) -> *mut PyObject;
-    pub fn PyByteArray_FromStringAndSize(string: *const c_char,
-                                         len: Py_ssize_t) -> *mut PyObject;
     pub fn PyByteArray_Size(bytearray: *mut PyObject) -> Py_ssize_t;
     pub fn PyByteArray_AsString(bytearray: *mut PyObject) -> *mut c_char;
-    pub fn PyByteArray_Resize(bytearray: *mut PyObject, len: Py_ssize_t)
+    pub fn PyByteArray_Resize(bytearray: *mut PyObject, len: Py_ssize_t) -> c_int;
-     -> c_int;
 }
 
 #[inline(always)]

src/ffi2/bytesobject.rs

@@ -1,16 +1,16 @@
+pub use ffi2::object::Py_TPFLAGS_STRING_SUBCLASS as Py_TPFLAGS_BYTES_SUBCLASS;
 pub use ffi2::stringobject::PyStringObject as PyBytesObject;
-pub use ffi2::stringobject::PyString_Type as PyBytes_Type;
+pub use ffi2::stringobject::PyString_AS_STRING as PyBytes_AS_STRING;
+pub use ffi2::stringobject::PyString_AsString as PyBytes_AsString;
+pub use ffi2::stringobject::PyString_AsStringAndSize as PyBytes_AsStringAndSize;
 pub use ffi2::stringobject::PyString_Check as PyBytes_Check;
 pub use ffi2::stringobject::PyString_CheckExact as PyBytes_CheckExact;
-pub use ffi2::stringobject::PyString_AS_STRING as PyBytes_AS_STRING;
-pub use ffi2::stringobject::PyString_GET_SIZE as PyBytes_GET_SIZE;
-pub use ffi2::object::Py_TPFLAGS_STRING_SUBCLASS as Py_TPFLAGS_BYTES_SUBCLASS;
-pub use ffi2::stringobject::PyString_FromStringAndSize as PyBytes_FromStringAndSize;
-pub use ffi2::stringobject::PyString_FromString as PyBytes_FromString;
-pub use ffi2::stringobject::PyString_FromFormat as PyBytes_FromFormat;
-pub use ffi2::stringobject::PyString_Size as PyBytes_Size;
-pub use ffi2::stringobject::PyString_AsString as PyBytes_AsString;
 pub use ffi2::stringobject::PyString_Concat as PyBytes_Concat;
 pub use ffi2::stringobject::PyString_ConcatAndDel as PyBytes_ConcatAndDel;
 pub use ffi2::stringobject::PyString_Format as PyBytes_Format;
-pub use ffi2::stringobject::PyString_AsStringAndSize as PyBytes_AsStringAndSize;
+pub use ffi2::stringobject::PyString_FromFormat as PyBytes_FromFormat;
+pub use ffi2::stringobject::PyString_FromString as PyBytes_FromString;
+pub use ffi2::stringobject::PyString_FromStringAndSize as PyBytes_FromStringAndSize;
+pub use ffi2::stringobject::PyString_GET_SIZE as PyBytes_GET_SIZE;
+pub use ffi2::stringobject::PyString_Size as PyBytes_Size;
+pub use ffi2::stringobject::PyString_Type as PyBytes_Type;

src/ffi2/cellobject.rs

@@ -1,29 +1,31 @@
-use std::os::raw::c_int;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 struct PyCellObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
-    pub ob_ref: *mut PyObject
+    pub ob_ref: *mut PyObject,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyCell_Type: PyTypeObject;
 }
 
 #[inline(always)]
 pub unsafe fn PyCell_Check(op: *mut PyObject) -> c_int {
-     (Py_TYPE(op) == &mut PyCell_Type) as c_int
+    (Py_TYPE(op) == &mut PyCell_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyCell_New(obj: *mut PyObject) -> *mut PyObject;
     pub fn PyCell_Get(op: *mut PyObject) -> *mut PyObject;
     pub fn PyCell_Set(op: *mut PyObject, obj: *mut PyObject) -> c_int;

src/ffi2/ceval.rs

@@ -1,19 +1,24 @@
-use std::os::raw::{c_void, c_char, c_int};
-use ffi2::pyport::Py_ssize_t;
-use ffi2::object::PyObject;
 use ffi2::frameobject::PyFrameObject;
+use ffi2::object::PyObject;
+use ffi2::pyport::Py_ssize_t;
 use ffi2::pystate::{PyThreadState, Py_tracefunc};
 use ffi2::pythonrun::PyCompilerFlags;
+use std::os::raw::{c_char, c_int, c_void};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyEval_CallObjectWithKeywords(callable: *mut PyObject,
+extern "C" {
-                                         args: *mut PyObject,
+    pub fn PyEval_CallObjectWithKeywords(
-                                         kwds: *mut PyObject) -> *mut PyObject;
+        callable: *mut PyObject,
-    pub fn PyEval_CallFunction(obj: *mut PyObject,
+        args: *mut PyObject,
-                               format: *const c_char, ...) -> *mut PyObject;
+        kwds: *mut PyObject,
-    pub fn PyEval_CallMethod(obj: *mut PyObject,
+    ) -> *mut PyObject;
-                             methodname: *const c_char,
+    pub fn PyEval_CallFunction(obj: *mut PyObject, format: *const c_char, ...) -> *mut PyObject;
-                             format: *const c_char, ...) -> *mut PyObject;
+    pub fn PyEval_CallMethod(
+        obj: *mut PyObject,
+        methodname: *const c_char,
+        format: *const c_char,
+        ...
+    ) -> *mut PyObject;
     pub fn PyEval_SetProfile(func: Option<Py_tracefunc>, obj: *mut PyObject);
     pub fn PyEval_SetTrace(func: Option<Py_tracefunc>, obj: *mut PyObject);
     pub fn PyEval_GetBuiltins() -> *mut PyObject;
@@ -23,9 +28,10 @@ use ffi2::pythonrun::PyCompilerFlags;
     pub fn PyEval_GetRestricted() -> c_int;
     pub fn PyEval_MergeCompilerFlags(cf: *mut PyCompilerFlags) -> c_int;
     pub fn Py_FlushLine() -> c_int;
-    pub fn Py_AddPendingCall(func: Option<extern "C" fn (arg1: *mut c_void)
+    pub fn Py_AddPendingCall(
-                                                         -> c_int>,
+        func: Option<extern "C" fn(arg1: *mut c_void) -> c_int>,
-                             arg: *mut c_void) -> c_int;
+        arg: *mut c_void,
+    ) -> c_int;
     pub fn Py_MakePendingCalls() -> c_int;
     pub fn Py_SetRecursionLimit(arg1: c_int);
     pub fn Py_GetRecursionLimit() -> c_int;
@@ -42,8 +48,9 @@ use ffi2::pythonrun::PyCompilerFlags;
     fn _PyEval_SliceIndex(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> c_int;
 }
 
-#[cfg(py_sys_config="WITH_THREAD")]
+#[cfg(py_sys_config = "WITH_THREAD")]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyEval_ThreadsInitialized() -> c_int;
     pub fn PyEval_InitThreads();
     pub fn PyEval_AcquireLock();
@@ -52,4 +59,3 @@ use ffi2::pythonrun::PyCompilerFlags;
     pub fn PyEval_ReleaseThread(tstate: *mut PyThreadState);
     pub fn PyEval_ReInitThreads();
 }
-

src/ffi2/classobject.rs

@@ -1,13 +1,13 @@
-use std::os::raw::c_int;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyClassObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -23,9 +23,9 @@ pub struct PyClassObject {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyInstanceObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -37,9 +37,9 @@ pub struct PyInstanceObject {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyMethodObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -49,61 +49,68 @@ pub struct PyMethodObject {
     pub im_weakreflist: *mut PyObject,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyClass_Type: PyTypeObject;
     pub static mut PyInstance_Type: PyTypeObject;
     pub static mut PyMethod_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyClass_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyClass_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyClass_Type;
+    let u: *mut PyTypeObject = &mut PyClass_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyInstance_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyInstance_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyInstance_Type;
+    let u: *mut PyTypeObject = &mut PyInstance_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyMethod_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyMethod_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyMethod_Type;
+    let u: *mut PyTypeObject = &mut PyMethod_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyClass_New(arg1: *mut PyObject, arg2: *mut PyObject,
+extern "C" {
-                       arg3: *mut PyObject) -> *mut PyObject;
+    pub fn PyClass_New(
-    pub fn PyInstance_New(arg1: *mut PyObject, arg2: *mut PyObject,
+        arg1: *mut PyObject,
-                          arg3: *mut PyObject) -> *mut PyObject;
+        arg2: *mut PyObject,
-    pub fn PyInstance_NewRaw(arg1: *mut PyObject, arg2: *mut PyObject)
+        arg3: *mut PyObject,
-                             -> *mut PyObject;
+    ) -> *mut PyObject;
-    pub fn PyMethod_New(arg1: *mut PyObject, arg2: *mut PyObject,
+    pub fn PyInstance_New(
-                        arg3: *mut PyObject) -> *mut PyObject;
+        arg1: *mut PyObject,
+        arg2: *mut PyObject,
+        arg3: *mut PyObject,
+    ) -> *mut PyObject;
+    pub fn PyInstance_NewRaw(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
+    pub fn PyMethod_New(
+        arg1: *mut PyObject,
+        arg2: *mut PyObject,
+        arg3: *mut PyObject,
+    ) -> *mut PyObject;
     pub fn PyMethod_Function(arg1: *mut PyObject) -> *mut PyObject;
     pub fn PyMethod_Self(arg1: *mut PyObject) -> *mut PyObject;
     pub fn PyMethod_Class(arg1: *mut PyObject) -> *mut PyObject;
-    fn _PyInstance_Lookup(pinst: *mut PyObject, name: *mut PyObject)
+    fn _PyInstance_Lookup(pinst: *mut PyObject, name: *mut PyObject) -> *mut PyObject;
-                          -> *mut PyObject;
+    pub fn PyClass_IsSubclass(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
-    pub fn PyClass_IsSubclass(arg1: *mut PyObject, arg2: *mut PyObject)
-                              -> c_int;
     pub fn PyMethod_ClearFreeList() -> c_int;
 }
 
 #[inline(always)]
-pub unsafe fn PyMethod_GET_FUNCTION(meth : *mut PyObject) -> *mut PyObject {
+pub unsafe fn PyMethod_GET_FUNCTION(meth: *mut PyObject) -> *mut PyObject {
     (*(meth as *mut PyMethodObject)).im_func
 }
 
 #[inline(always)]
-pub unsafe fn PyMethod_GET_SELF(meth : *mut PyObject) -> *mut PyObject {
+pub unsafe fn PyMethod_GET_SELF(meth: *mut PyObject) -> *mut PyObject {
     (*(meth as *mut PyMethodObject)).im_self
 }
 
 #[inline(always)]
-pub unsafe fn PyMethod_GET_CLASS(meth : *mut PyObject) -> *mut PyObject {
+pub unsafe fn PyMethod_GET_CLASS(meth: *mut PyObject) -> *mut PyObject {
     (*(meth as *mut PyMethodObject)).im_class
 }
-

src/ffi2/cobject.rs

@@ -1,27 +1,29 @@
-use std::os::raw::{c_void, c_char, c_int};
 use ffi2::object::*;
+use std::os::raw::{c_char, c_int, c_void};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyCObject_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyCObject_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyCObject_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyCObject_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyCObject_FromVoidPtr(cobj: *mut c_void,
+extern "C" {
-                                 destruct: Option<unsafe extern "C" fn (arg1: *mut c_void)>)
+    pub fn PyCObject_FromVoidPtr(
-     -> *mut PyObject;
+        cobj: *mut c_void,
+        destruct: Option<unsafe extern "C" fn(arg1: *mut c_void)>,
+    ) -> *mut PyObject;
     pub fn PyCObject_FromVoidPtrAndDesc(
         cobj: *mut c_void,
         desc: *mut c_void,
-        destruct: Option<unsafe extern "C" fn (arg1: *mut c_void, arg2: *mut c_void)>)
+        destruct: Option<unsafe extern "C" fn(arg1: *mut c_void, arg2: *mut c_void)>,
-        -> *mut PyObject;
+    ) -> *mut PyObject;
     pub fn PyCObject_AsVoidPtr(arg1: *mut PyObject) -> *mut c_void;
     pub fn PyCObject_GetDesc(arg1: *mut PyObject) -> *mut c_void;
-    pub fn PyCObject_Import(module_name: *mut c_char,
+    pub fn PyCObject_Import(module_name: *mut c_char, cobject_name: *mut c_char) -> *mut c_void;
-                            cobject_name: *mut c_char) -> *mut c_void;
     pub fn PyCObject_SetVoidPtr(_self: *mut PyObject, cobj: *mut c_void) -> c_int;
 }

src/ffi2/code.rs

@@ -1,13 +1,13 @@
-use std::os::raw::{c_char, c_int, c_void};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int, c_void};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyCodeObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -30,58 +30,70 @@ pub struct PyCodeObject {
 }
 
 /* Masks for co_flags */
-pub const CO_OPTIMIZED : c_int = 0x0001;
+pub const CO_OPTIMIZED: c_int = 0x0001;
-pub const CO_NEWLOCALS : c_int = 0x0002;
+pub const CO_NEWLOCALS: c_int = 0x0002;
-pub const CO_VARARGS : c_int = 0x0004;
+pub const CO_VARARGS: c_int = 0x0004;
-pub const CO_VARKEYWORDS : c_int = 0x0008;
+pub const CO_VARKEYWORDS: c_int = 0x0008;
-pub const CO_NESTED : c_int = 0x0010;
+pub const CO_NESTED: c_int = 0x0010;
-pub const CO_GENERATOR : c_int = 0x0020;
+pub const CO_GENERATOR: c_int = 0x0020;
 /* The CO_NOFREE flag is set if there are no free or cell variables.
    This information is redundant, but it allows a single flag test
    to determine whether there is any extra work to be done when the
    call frame it setup.
 */
-pub const CO_NOFREE : c_int = 0x0040;
+pub const CO_NOFREE: c_int = 0x0040;
 
-pub const CO_FUTURE_DIVISION : c_int = 0x2000;
+pub const CO_FUTURE_DIVISION: c_int = 0x2000;
-pub const CO_FUTURE_ABSOLUTE_IMPORT : c_int = 0x4000; /* do absolute imports by default */
+pub const CO_FUTURE_ABSOLUTE_IMPORT: c_int = 0x4000; /* do absolute imports by default */
-pub const CO_FUTURE_WITH_STATEMENT : c_int = 0x8000;
+pub const CO_FUTURE_WITH_STATEMENT: c_int = 0x8000;
-pub const CO_FUTURE_PRINT_FUNCTION : c_int = 0x1_0000;
+pub const CO_FUTURE_PRINT_FUNCTION: c_int = 0x1_0000;
-pub const CO_FUTURE_UNICODE_LITERALS : c_int = 0x2_0000;
+pub const CO_FUTURE_UNICODE_LITERALS: c_int = 0x2_0000;
 
-pub const CO_MAXBLOCKS : usize = 20;
+pub const CO_MAXBLOCKS: usize = 20;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyCode_Type: PyTypeObject;
 
-    pub fn PyCode_New(arg1: c_int, arg2: c_int,
+    pub fn PyCode_New(
-                      arg3: c_int, arg4: c_int,
+        arg1: c_int,
-                      arg5: *mut PyObject, arg6: *mut PyObject,
+        arg2: c_int,
-                      arg7: *mut PyObject, arg8: *mut PyObject,
+        arg3: c_int,
-                      arg9: *mut PyObject, arg10: *mut PyObject,
+        arg4: c_int,
-                      arg11: *mut PyObject, arg12: *mut PyObject,
+        arg5: *mut PyObject,
-                      arg13: c_int, arg14: *mut PyObject)
+        arg6: *mut PyObject,
-     -> *mut PyCodeObject;
+        arg7: *mut PyObject,
-    pub fn PyCode_NewEmpty(filename: *const c_char,
+        arg8: *mut PyObject,
-                           funcname: *const c_char,
+        arg9: *mut PyObject,
-                           firstlineno: c_int) -> *mut PyCodeObject;
+        arg10: *mut PyObject,
-    pub fn PyCode_Addr2Line(arg1: *mut PyCodeObject, arg2: c_int)
+        arg11: *mut PyObject,
-     -> c_int;
+        arg12: *mut PyObject,
+        arg13: c_int,
+        arg14: *mut PyObject,
+    ) -> *mut PyCodeObject;
+    pub fn PyCode_NewEmpty(
+        filename: *const c_char,
+        funcname: *const c_char,
+        firstlineno: c_int,
+    ) -> *mut PyCodeObject;
+    pub fn PyCode_Addr2Line(arg1: *mut PyCodeObject, arg2: c_int) -> c_int;
     //fn _PyCode_CheckLineNumber(co: *mut PyCodeObject,
     //                               lasti: c_int,
     //                               bounds: *mut PyAddrPair) -> c_int;
-    pub fn PyCode_Optimize(code: *mut PyObject, consts: *mut PyObject,
+    pub fn PyCode_Optimize(
-                           names: *mut PyObject, lineno_obj: *mut PyObject)
+        code: *mut PyObject,
-     -> *mut PyObject;
+        consts: *mut PyObject,
+        names: *mut PyObject,
+        lineno_obj: *mut PyObject,
+    ) -> *mut PyObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyCode_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyCode_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyCode_Type) as c_int
 }
 
 #[inline]
-pub unsafe fn PyCode_GetNumFree(op : *mut PyCodeObject) -> Py_ssize_t {
+pub unsafe fn PyCode_GetNumFree(op: *mut PyCodeObject) -> Py_ssize_t {
     ::ffi2::tupleobject::PyTuple_GET_SIZE((*op).co_freevars)
 }
-

src/ffi2/compile.rs

@@ -1,7 +1,7 @@
-use std::os::raw::{c_char, c_int};
-use ffi2::pythonrun::*;
 use ffi2::code::*;
 use ffi2::pyarena::PyArena;
+use ffi2::pythonrun::*;
+use std::os::raw::{c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -10,20 +10,22 @@ pub struct PyFutureFeatures {
     pub ff_lineno: c_int,
 }
 
-pub const FUTURE_NESTED_SCOPES    : &'static str = "nested_scopes";
+pub const FUTURE_NESTED_SCOPES: &'static str = "nested_scopes";
-pub const FUTURE_GENERATORS       : &'static str = "generators";
+pub const FUTURE_GENERATORS: &'static str = "generators";
-pub const FUTURE_DIVISION         : &'static str = "division";
+pub const FUTURE_DIVISION: &'static str = "division";
-pub const FUTURE_ABSOLUTE_IMPORT  : &'static str = "absolute_import";
+pub const FUTURE_ABSOLUTE_IMPORT: &'static str = "absolute_import";
-pub const FUTURE_WITH_STATEMENT   : &'static str = "with_statement";
+pub const FUTURE_WITH_STATEMENT: &'static str = "with_statement";
-pub const FUTURE_PRINT_FUNCTION   : &'static str = "print_function";
+pub const FUTURE_PRINT_FUNCTION: &'static str = "print_function";
-pub const FUTURE_UNICODE_LITERALS : &'static str = "unicode_literals";
+pub const FUTURE_UNICODE_LITERALS: &'static str = "unicode_literals";
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyNode_Compile(arg1: *mut Struct__node,
+extern "C" {
-                          arg2: *const c_char) -> *mut PyCodeObject;
+    pub fn PyNode_Compile(arg1: *mut Struct__node, arg2: *const c_char) -> *mut PyCodeObject;
-    pub fn PyAST_Compile(arg1: *mut Struct__mod, arg2: *const c_char,
+    pub fn PyAST_Compile(
-                         arg3: *mut PyCompilerFlags, arg4: *mut PyArena)
+        arg1: *mut Struct__mod,
-                         -> *mut PyCodeObject;
+        arg2: *const c_char,
-    pub fn PyFuture_FromAST(arg1: *mut Struct__mod,
+        arg3: *mut PyCompilerFlags,
-                            arg2: *const c_char) -> *mut PyFutureFeatures;
+        arg4: *mut PyArena,
+    ) -> *mut PyCodeObject;
+    pub fn PyFuture_FromAST(arg1: *mut Struct__mod, arg2: *const c_char) -> *mut PyFutureFeatures;
 }

src/ffi2/complexobject.rs

@@ -1,15 +1,16 @@
-use std::os::raw::{c_double, c_int};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_double, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct Py_complex {
     pub real: c_double,
-    pub imag: c_double
+    pub imag: c_double,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn _Py_c_sum(left: Py_complex, right: Py_complex) -> Py_complex;
     pub fn _Py_c_diff(left: Py_complex, right: Py_complex) -> Py_complex;
     pub fn _Py_c_neg(complex: Py_complex) -> Py_complex;
@@ -22,42 +23,41 @@ pub struct Py_complex {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyComplexObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
-    pub cval: Py_complex
+    pub cval: Py_complex,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyComplex_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyComplex_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyComplex_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyComplex_Type)
 }
 
 #[inline(always)]
-pub unsafe fn PyComplex_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyComplex_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyComplex_Type;
+    let u: *mut PyTypeObject = &mut PyComplex_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyComplex_FromCComplex(v: Py_complex) -> *mut PyObject;
-    pub fn PyComplex_FromDoubles(real: c_double,
+    pub fn PyComplex_FromDoubles(real: c_double, imag: c_double) -> *mut PyObject;
-                                 imag: c_double) -> *mut PyObject;
     pub fn PyComplex_RealAsDouble(op: *mut PyObject) -> c_double;
     pub fn PyComplex_ImagAsDouble(op: *mut PyObject) -> c_double;
     pub fn PyComplex_AsCComplex(op: *mut PyObject) -> Py_complex;
 
-
+//fn _PyComplex_FormatAdvanced(obj: *mut PyObject,
-    //fn _PyComplex_FormatAdvanced(obj: *mut PyObject,
+//                                 format_spec: *mut c_char,
-    //                                 format_spec: *mut c_char,
+//                                 format_spec_len: Py_ssize_t)
-    //                                 format_spec_len: Py_ssize_t)
+// -> *mut PyObject;
-    // -> *mut PyObject;
 }
-

src/ffi2/descrobject.rs

@@ -1,16 +1,13 @@
-use std::ptr;
+use ffi2::methodobject::PyMethodDef;
-use std::os::raw::{c_void, c_char, c_int};
 use ffi2::object::{PyObject, PyTypeObject, Py_TYPE};
 use ffi2::structmember::PyMemberDef;
-use ffi2::methodobject::PyMethodDef;
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
 
-pub type getter =
+pub type getter = unsafe extern "C" fn(slf: *mut PyObject, closure: *mut c_void) -> *mut PyObject;
-    unsafe extern "C" fn
-    (slf: *mut PyObject, closure: *mut c_void) -> *mut PyObject;
 
 pub type setter =
-    unsafe extern "C" fn (slf: *mut PyObject, value: *mut PyObject,
+    unsafe extern "C" fn(slf: *mut PyObject, value: *mut PyObject, closure: *mut c_void) -> c_int;
-                          closure: *mut c_void) -> c_int;
 
 #[repr(C)]
 #[derive(Copy)]
@@ -22,7 +19,7 @@ pub struct PyGetSetDef {
     pub closure: *mut c_void,
 }
 
-pub const PyGetSetDef_INIT : PyGetSetDef = PyGetSetDef {
+pub const PyGetSetDef_INIT: PyGetSetDef = PyGetSetDef {
     name: ptr::null_mut(),
     get: None,
     set: None,
@@ -31,16 +28,22 @@ pub const PyGetSetDef_INIT : PyGetSetDef = PyGetSetDef {
 };
 
 impl Clone for PyGetSetDef {
-    #[inline] fn clone(&self) -> PyGetSetDef { *self }
+    #[inline]
+    fn clone(&self) -> PyGetSetDef {
+        *self
+    }
 }
 
 pub type wrapperfunc =
-    unsafe extern "C" fn(slf: *mut PyObject, args: *mut PyObject,
+    unsafe extern "C" fn(slf: *mut PyObject, args: *mut PyObject, wrapped: *mut c_void)
-                         wrapped: *mut c_void) -> *mut PyObject;
+        -> *mut PyObject;
 
-pub type wrapperfunc_kwds =
+pub type wrapperfunc_kwds = unsafe extern "C" fn(
-    unsafe extern "C" fn(slf: *mut PyObject, args: *mut PyObject,
+    slf: *mut PyObject,
-                         wrapped: *mut c_void, kwds: *mut PyObject) -> *mut PyObject;
+    args: *mut PyObject,
+    wrapped: *mut c_void,
+    kwds: *mut PyObject,
+) -> *mut PyObject;
 
 #[repr(C)]
 #[derive(Copy)]
@@ -51,33 +54,36 @@ pub struct wrapperbase {
     pub wrapper: Option<wrapperfunc>,
     pub doc: *mut c_char,
     pub flags: c_int,
-    pub name_strobj: *mut PyObject
+    pub name_strobj: *mut PyObject,
 }
 
 impl Clone for wrapperbase {
-    #[inline] fn clone(&self) -> wrapperbase { *self }
+    #[inline]
+    fn clone(&self) -> wrapperbase {
+        *self
+    }
 }
 
-pub const PyWrapperFlag_KEYWORDS : c_int = 1;
+pub const PyWrapperFlag_KEYWORDS: c_int = 1;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyWrapperDescr_Type: PyTypeObject;
     pub static mut PyDictProxy_Type: PyTypeObject;
     pub static mut PyGetSetDescr_Type: PyTypeObject;
     pub static mut PyMemberDescr_Type: PyTypeObject;
     pub static mut PyProperty_Type: PyTypeObject;
 
-    pub fn PyDescr_NewMethod(arg1: *mut PyTypeObject, arg2: *mut PyMethodDef)
+    pub fn PyDescr_NewMethod(arg1: *mut PyTypeObject, arg2: *mut PyMethodDef) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyDescr_NewClassMethod(arg1: *mut PyTypeObject, arg2: *mut PyMethodDef)
-    pub fn PyDescr_NewClassMethod(arg1: *mut PyTypeObject,
+        -> *mut PyObject;
-                                  arg2: *mut PyMethodDef) -> *mut PyObject;
+    pub fn PyDescr_NewMember(arg1: *mut PyTypeObject, arg2: *mut PyMemberDef) -> *mut PyObject;
-    pub fn PyDescr_NewMember(arg1: *mut PyTypeObject,
+    pub fn PyDescr_NewGetSet(arg1: *mut PyTypeObject, arg2: *mut PyGetSetDef) -> *mut PyObject;
-                             arg2: *mut PyMemberDef) -> *mut PyObject;
+    pub fn PyDescr_NewWrapper(
-    pub fn PyDescr_NewGetSet(arg1: *mut PyTypeObject,
+        arg1: *mut PyTypeObject,
-                             arg2: *mut PyGetSetDef) -> *mut PyObject;
+        arg2: *mut wrapperbase,
-    pub fn PyDescr_NewWrapper(arg1: *mut PyTypeObject,
+        arg3: *mut c_void,
-                              arg2: *mut wrapperbase,
+    ) -> *mut PyObject;
-                              arg3: *mut c_void) -> *mut PyObject;
 }
 
 #[inline(always)]
@@ -85,13 +91,9 @@ pub unsafe fn PyDescr_IsData(d: *mut PyObject) -> c_int {
     (*Py_TYPE(d)).tp_descr_set.is_some() as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     //pub fn PyDictProxy_New(arg1: *mut PyObject) -> *mut PyObject;
     // PyDictProxy_New is also defined in dictobject.h
-    pub fn PyWrapper_New(arg1: *mut PyObject, arg2: *mut PyObject)
+    pub fn PyWrapper_New(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
 }
-
-
-
-

src/ffi2/dictobject.rs

@@ -1,10 +1,11 @@
-use std::os::raw::{c_char, c_int};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
 //pub enum PyDictObject { /* representation hidden */ }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyDict_Type: PyTypeObject;
     pub static mut PyDictIterKey_Type: PyTypeObject;
     pub static mut PyDictIterValue_Type: PyTypeObject;
@@ -15,44 +16,45 @@ use ffi2::object::*;
 }
 
 #[inline(always)]
-pub unsafe fn PyDict_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyDict_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyDict_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyDict_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyDict_Type;
+    let u: *mut PyTypeObject = &mut PyDict_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyDict_New() -> *mut PyObject;
     pub fn PyDictProxy_New(dict: *mut PyObject) -> *mut PyObject;
     pub fn PyDict_Clear(mp: *mut PyObject);
-    pub fn PyDict_Contains(mp: *mut PyObject, key: *mut PyObject)
+    pub fn PyDict_Contains(mp: *mut PyObject, key: *mut PyObject) -> c_int;
-     -> c_int;
     pub fn PyDict_Copy(mp: *mut PyObject) -> *mut PyObject;
 
-    pub fn PyDict_GetItem(mp: *mut PyObject, key: *mut PyObject)
+    pub fn PyDict_GetItem(mp: *mut PyObject, key: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyDict_SetItem(mp: *mut PyObject, key: *mut PyObject, item: *mut PyObject) -> c_int;
-    pub fn PyDict_SetItem(mp: *mut PyObject, key: *mut PyObject,
+    pub fn PyDict_DelItem(mp: *mut PyObject, key: *mut PyObject) -> c_int;
-                          item: *mut PyObject) -> c_int;
+    pub fn PyDict_GetItemString(dp: *mut PyObject, key: *const c_char) -> *mut PyObject;
-    pub fn PyDict_DelItem(mp: *mut PyObject, key: *mut PyObject)
+    pub fn PyDict_SetItemString(
-     -> c_int;
+        dp: *mut PyObject,
-    pub fn PyDict_GetItemString(dp: *mut PyObject, key: *const c_char)
+        key: *const c_char,
-     -> *mut PyObject;
+        item: *mut PyObject,
-    pub fn PyDict_SetItemString(dp: *mut PyObject, key: *const c_char,
+    ) -> c_int;
-                                item: *mut PyObject) -> c_int;
+    pub fn PyDict_DelItemString(dp: *mut PyObject, key: *const c_char) -> c_int;
-    pub fn PyDict_DelItemString(dp: *mut PyObject, key: *const c_char)
-     -> c_int;
 
     pub fn PyDict_Keys(mp: *mut PyObject) -> *mut PyObject;
     pub fn PyDict_Values(mp: *mut PyObject) -> *mut PyObject;
     pub fn PyDict_Items(mp: *mut PyObject) -> *mut PyObject;
     pub fn PyDict_Size(mp: *mut PyObject) -> Py_ssize_t;
-    pub fn PyDict_Next(mp: *mut PyObject, pos: *mut Py_ssize_t,
+    pub fn PyDict_Next(
-                       key: *mut *mut PyObject, value: *mut *mut PyObject)
+        mp: *mut PyObject,
-     -> c_int;
+        pos: *mut Py_ssize_t,
+        key: *mut *mut PyObject,
+        value: *mut *mut PyObject,
+    ) -> c_int;
     /*pub fn _PyDict_Next(mp: *mut PyObject, pos: *mut Py_ssize_t,
                         key: *mut *mut PyObject, value: *mut *mut PyObject,
                         hash: *mut c_long) -> c_int;
@@ -60,12 +62,8 @@ pub unsafe fn PyDict_CheckExact(op : *mut PyObject) -> c_int {
                             hash: c_long) -> c_int;
     pub fn _PyDict_NewPresized(minused: Py_ssize_t) -> *mut PyObject;
     pub fn _PyDict_MaybeUntrack(mp: *mut PyObject);*/
-    pub fn PyDict_Update(mp: *mut PyObject, other: *mut PyObject)
+    pub fn PyDict_Update(mp: *mut PyObject, other: *mut PyObject) -> c_int;
-     -> c_int;
+    pub fn PyDict_Merge(mp: *mut PyObject, other: *mut PyObject, _override: c_int) -> c_int;
-    pub fn PyDict_Merge(mp: *mut PyObject, other: *mut PyObject,
+    pub fn PyDict_MergeFromSeq2(d: *mut PyObject, seq2: *mut PyObject, _override: c_int) -> c_int;
-                        _override: c_int) -> c_int;
-    pub fn PyDict_MergeFromSeq2(d: *mut PyObject, seq2: *mut PyObject,
-                                _override: c_int) -> c_int;
 
 }
-

src/ffi2/enumobject.rs

@@ -1,7 +1,7 @@
 use ffi2::object::PyTypeObject;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyEnum_Type: PyTypeObject;
     pub static mut PyReversed_Type: PyTypeObject;
 }
-

src/ffi2/eval.rs

@@ -1,16 +1,25 @@
-use std::os::raw::c_int;
-use ffi2::object::PyObject;
 use ffi2::code::PyCodeObject;
+use ffi2::object::PyObject;
+use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyEval_EvalCode(arg1: *mut PyCodeObject, arg2: *mut PyObject,
+extern "C" {
-                           arg3: *mut PyObject) -> *mut PyObject;
+    pub fn PyEval_EvalCode(
-    pub fn PyEval_EvalCodeEx(co: *mut PyCodeObject, globals: *mut PyObject,
+        arg1: *mut PyCodeObject,
-                             locals: *mut PyObject, args: *mut *mut PyObject,
+        arg2: *mut PyObject,
-                             argc: c_int, kwds: *mut *mut PyObject,
+        arg3: *mut PyObject,
-                             kwdc: c_int, defs: *mut *mut PyObject,
+    ) -> *mut PyObject;
-                             defc: c_int, closure: *mut PyObject)
+    pub fn PyEval_EvalCodeEx(
-                             -> *mut PyObject;
+        co: *mut PyCodeObject,
-    fn _PyEval_CallTracing(func: *mut PyObject, args: *mut PyObject)
+        globals: *mut PyObject,
-                           -> *mut PyObject;
+        locals: *mut PyObject,
+        args: *mut *mut PyObject,
+        argc: c_int,
+        kwds: *mut *mut PyObject,
+        kwdc: c_int,
+        defs: *mut *mut PyObject,
+        defc: c_int,
+        closure: *mut PyObject,
+    ) -> *mut PyObject;
+    fn _PyEval_CallTracing(func: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
 }

src/ffi2/fileobject.rs

@@ -1,59 +1,61 @@
+use ffi2::object::*;
 use libc::{size_t, FILE};
 use std::os::raw::{c_char, c_int};
-use ffi2::object::*;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyFile_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyFile_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyFile_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyFile_Type)
 }
 
 #[inline(always)]
-pub unsafe fn PyFile_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyFile_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyFile_Type) as c_int
 }
 
+pub const PY_STDIOTEXTMODE: &'static str = "b";
 
-pub const PY_STDIOTEXTMODE : &'static str = "b";
+#[cfg_attr(windows, link(name = "pythonXY"))]
-
+extern "C" {
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+    pub fn PyFile_FromString(arg1: *mut c_char, arg2: *mut c_char) -> *mut PyObject;
-    pub fn PyFile_FromString(arg1: *mut c_char,
-                             arg2: *mut c_char) -> *mut PyObject;
     pub fn PyFile_SetBufSize(arg1: *mut PyObject, arg2: c_int);
-    pub fn PyFile_SetEncoding(arg1: *mut PyObject,
+    pub fn PyFile_SetEncoding(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
-                              arg2: *const c_char) -> c_int;
+    pub fn PyFile_SetEncodingAndErrors(
-    pub fn PyFile_SetEncodingAndErrors(arg1: *mut PyObject,
+        arg1: *mut PyObject,
-                                       arg2: *const c_char,
+        arg2: *const c_char,
-                                       errors: *mut c_char)
+        errors: *mut c_char,
-                                       -> c_int;
+    ) -> c_int;
-    pub fn PyFile_FromFile(arg1: *mut FILE, arg2: *mut c_char,
+    pub fn PyFile_FromFile(
-                           arg3: *mut c_char,
+        arg1: *mut FILE,
-                           arg4: Option<unsafe extern "C" fn (arg1: *mut FILE) -> c_int>)
+        arg2: *mut c_char,
-                           -> *mut PyObject;
+        arg3: *mut c_char,
+        arg4: Option<unsafe extern "C" fn(arg1: *mut FILE) -> c_int>,
+    ) -> *mut PyObject;
     pub fn PyFile_AsFile(arg1: *mut PyObject) -> *mut FILE;
     //pub fn PyFile_IncUseCount(arg1: *mut PyFileObject);
     //pub fn PyFile_DecUseCount(arg1: *mut PyFileObject);
     pub fn PyFile_Name(arg1: *mut PyObject) -> *mut PyObject;
-    pub fn PyFile_GetLine(arg1: *mut PyObject, arg2: c_int)
+    pub fn PyFile_GetLine(arg1: *mut PyObject, arg2: c_int) -> *mut PyObject;
-                          -> *mut PyObject;
+    pub fn PyFile_WriteObject(arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int) -> c_int;
-    pub fn PyFile_WriteObject(arg1: *mut PyObject, arg2: *mut PyObject,
+    pub fn PyFile_SoftSpace(arg1: *mut PyObject, arg2: c_int) -> c_int;
-                              arg3: c_int) -> c_int;
+    pub fn PyFile_WriteString(arg1: *const c_char, arg2: *mut PyObject) -> c_int;
-    pub fn PyFile_SoftSpace(arg1: *mut PyObject, arg2: c_int)
-     -> c_int;
-    pub fn PyFile_WriteString(arg1: *const c_char,
-                              arg2: *mut PyObject) -> c_int;
     pub fn PyObject_AsFileDescriptor(arg1: *mut PyObject) -> c_int;
-    pub fn Py_UniversalNewlineFgets(arg1: *mut c_char,
+    pub fn Py_UniversalNewlineFgets(
-                                    arg2: c_int, arg3: *mut FILE,
+        arg1: *mut c_char,
-                                    arg4: *mut PyObject)
+        arg2: c_int,
-     -> *mut c_char;
+        arg3: *mut FILE,
-    pub fn Py_UniversalNewlineFread(arg1: *mut c_char, arg2: size_t,
+        arg4: *mut PyObject,
-                                    arg3: *mut FILE, arg4: *mut PyObject)
+    ) -> *mut c_char;
-     -> size_t;
+    pub fn Py_UniversalNewlineFread(
+        arg1: *mut c_char,
+        arg2: size_t,
+        arg3: *mut FILE,
+        arg4: *mut PyObject,
+    ) -> size_t;
 
     pub static mut Py_FileSystemDefaultEncoding: *const c_char;
 }
-

src/ffi2/floatobject.rs

@@ -1,40 +1,40 @@
-use std::os::raw::{c_char, c_int, c_double};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_double, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 struct PyFloatObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
-    pub ob_fval: c_double
+    pub ob_fval: c_double,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyFloat_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyFloat_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyFloat_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyFloat_Type)
 }
 
 #[inline(always)]
-pub unsafe fn PyFloat_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyFloat_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyFloat_Type;
+    let u: *mut PyTypeObject = &mut PyFloat_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-pub const PyFloat_STR_PRECISION : c_int = 12;
+pub const PyFloat_STR_PRECISION: c_int = 12;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyFloat_FromString(str: *mut PyObject,
+extern "C" {
-                              pend: *mut *mut c_char)
+    pub fn PyFloat_FromString(str: *mut PyObject, pend: *mut *mut c_char) -> *mut PyObject;
-     -> *mut PyObject;
     pub fn PyFloat_FromDouble(v: c_double) -> *mut PyObject;
     pub fn PyFloat_AsDouble(pyfloat: *mut PyObject) -> c_double;
     pub fn PyFloat_GetInfo() -> *mut PyObject;
@@ -47,4 +47,3 @@ pub const PyFloat_STR_PRECISION : c_int = 12;
 pub unsafe fn PyFloat_AS_DOUBLE(pyfloat: *mut PyObject) -> c_double {
     (*(pyfloat as *mut PyFloatObject)).ob_fval
 }
-

src/ffi2/frameobject.rs

@@ -1,38 +1,38 @@
-use std::os::raw::c_int;
+use ffi2::code::{PyCodeObject, CO_MAXBLOCKS};
 use ffi2::object::*;
 use ffi2::pyport::Py_ssize_t;
-use ffi2::code::{PyCodeObject, CO_MAXBLOCKS};
 use ffi2::pystate::PyThreadState;
+use std::os::raw::c_int;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyTryBlock {
-    pub b_type : c_int,
+    pub b_type: c_int,
-    pub b_handler : c_int,
+    pub b_handler: c_int,
-    pub b_level : c_int,
+    pub b_level: c_int,
 }
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyFrameObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
     pub ob_size: Py_ssize_t,
-    pub f_back: *mut PyFrameObject,	/* previous frame, or NULL */
+    pub f_back: *mut PyFrameObject,       /* previous frame, or NULL */
-    pub f_code: *mut PyCodeObject,	/* code segment */
+    pub f_code: *mut PyCodeObject,        /* code segment */
-    pub f_builtins: *mut PyObject,	/* builtin symbol table (PyDictObject) */
+    pub f_builtins: *mut PyObject,        /* builtin symbol table (PyDictObject) */
-    pub f_globals: *mut PyObject,	/* global symbol table (PyDictObject) */
+    pub f_globals: *mut PyObject,         /* global symbol table (PyDictObject) */
-    pub f_locals: *mut PyObject,		/* local symbol table (any mapping) */
+    pub f_locals: *mut PyObject,          /* local symbol table (any mapping) */
-    pub f_valuestack: *mut *mut PyObject,	/* points after the last local */
+    pub f_valuestack: *mut *mut PyObject, /* points after the last local */
     /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
        Frame evaluation usually NULLs it, but a frame that yields sets it
        to the current stack top. */
     pub f_stacktop: *mut *mut PyObject,
-    pub f_trace: *mut PyObject,		/* Trace function */
+    pub f_trace: *mut PyObject, /* Trace function */
 
     pub f_exc_type: *mut PyObject,
     pub f_exc_value: *mut PyObject,
@@ -40,25 +40,26 @@ pub struct PyFrameObject {
 
     pub f_tstate: *mut PyThreadState,
 
-    pub f_lasti: c_int,		/* Last instruction if called */
+    pub f_lasti: c_int, /* Last instruction if called */
     /* Call PyFrame_GetLineNumber() instead of reading this field
        directly.  As of 2.3 f_lineno is only valid when tracing is
        active (i.e. when f_trace is set).  At other times we use
        PyCode_Addr2Line to calculate the line from the current
       bytecode index. */
-    pub f_lineno: c_int,		/* Current line number */
+    pub f_lineno: c_int,                          /* Current line number */
-    pub f_iblock: c_int,		/* index in f_blockstack */
+    pub f_iblock: c_int,                          /* index in f_blockstack */
     pub f_blockstack: [PyTryBlock; CO_MAXBLOCKS], /* for try and loop blocks */
-    pub f_localsplus: [*mut PyObject; 1]	/* locals+stack, dynamically sized */
+    pub f_localsplus: [*mut PyObject; 1],         /* locals+stack, dynamically sized */
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyFrame_Type: PyTypeObject;
 }
 
 #[inline]
 pub unsafe fn PyFrame_Check(op: *mut PyObject) -> c_int {
-     ((*op).ob_type == &mut PyFrame_Type) as c_int
+    ((*op).ob_type == &mut PyFrame_Type) as c_int
 }
 
 //#[inline]
@@ -66,11 +67,21 @@ pub unsafe fn PyFrame_Check(op: *mut PyObject) -> c_int {
 //     ((*f).f_builtins != (*(*(*f).f_tstate).interp).builtins) as c_int
 //}
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyFrame_New(tstate: *mut PyThreadState, code: *mut PyCodeObject,
+extern "C" {
-        globals: *mut PyObject, locals: *mut PyObject) -> *mut PyFrameObject;
+    pub fn PyFrame_New(
+        tstate: *mut PyThreadState,
+        code: *mut PyCodeObject,
+        globals: *mut PyObject,
+        locals: *mut PyObject,
+    ) -> *mut PyFrameObject;
 
-    pub fn PyFrame_BlockSetup(f: *mut PyFrameObject, _type: c_int, handler: c_int, level: c_int) -> ();
+    pub fn PyFrame_BlockSetup(
+        f: *mut PyFrameObject,
+        _type: c_int,
+        handler: c_int,
+        level: c_int,
+    ) -> ();
     pub fn PyFrame_BlockPop(f: *mut PyFrameObject) -> *mut PyTryBlock;
 
     pub fn PyFrame_LocalsToFast(f: *mut PyFrameObject, clear: c_int) -> ();
@@ -79,4 +90,3 @@ pub unsafe fn PyFrame_Check(op: *mut PyObject) -> c_int {
     pub fn PyFrame_ClearFreeList() -> c_int;
     pub fn PyFrame_GetLineNumber(f: *mut PyFrameObject) -> c_int;
 }
-

src/ffi2/funcobject.rs

@@ -1,29 +1,27 @@
-use std::os::raw::c_int;
 use ffi2::object::*;
+use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyFunction_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyFunction_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyFunction_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyFunction_Type;
+    let u: *mut PyTypeObject = &mut PyFunction_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-
+#[cfg_attr(windows, link(name = "pythonXY"))]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+extern "C" {
-    pub fn PyFunction_New(code: *mut PyObject, globals: *mut PyObject)
+    pub fn PyFunction_New(code: *mut PyObject, globals: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
     pub fn PyFunction_GetCode(f: *mut PyObject) -> *mut PyObject;
     pub fn PyFunction_GetGlobals(f: *mut PyObject) -> *mut PyObject;
     pub fn PyFunction_GetModule(f: *mut PyObject) -> *mut PyObject;
     pub fn PyFunction_GetDefaults(f: *mut PyObject) -> *mut PyObject;
-    pub fn PyFunction_SetDefaults(f: *mut PyObject, defaults: *mut PyObject)
+    pub fn PyFunction_SetDefaults(f: *mut PyObject, defaults: *mut PyObject) -> c_int;
-     -> c_int;
     pub fn PyFunction_GetClosure(f: *mut PyObject) -> *mut PyObject;
-    pub fn PyFunction_SetClosure(f: *mut PyObject, closure: *mut PyObject)
+    pub fn PyFunction_SetClosure(f: *mut PyObject, closure: *mut PyObject) -> c_int;
-     -> c_int;
 
     pub static mut PyClassMethod_Type: PyTypeObject;
     pub static mut PyStaticMethod_Type: PyTypeObject;
@@ -31,4 +29,3 @@ pub unsafe fn PyFunction_Check(op : *mut PyObject) -> c_int {
     pub fn PyClassMethod_New(arg1: *mut PyObject) -> *mut PyObject;
     pub fn PyStaticMethod_New(arg1: *mut PyObject) -> *mut PyObject;
 }
-

src/ffi2/genobject.rs

@@ -1,39 +1,40 @@
-use std::os::raw::c_int;
-use ffi2::pyport::Py_ssize_t;
-use ffi2::object::*;
 use ffi2::frameobject::PyFrameObject;
+use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyGenObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
     pub gi_frame: *mut PyFrameObject,
     pub gi_running: c_int,
     pub gi_code: *mut PyObject,
-    pub gi_weakreflist: *mut PyObject
+    pub gi_weakreflist: *mut PyObject,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyGen_Type: PyTypeObject;
 }
 
 #[inline(always)]
 pub unsafe fn PyGen_Check(op: *mut PyObject) -> c_int {
-     PyObject_TypeCheck(op, &mut PyGen_Type)
+    PyObject_TypeCheck(op, &mut PyGen_Type)
 }
 
 #[inline(always)]
 pub unsafe fn PyGen_CheckExact(op: *mut PyObject) -> c_int {
-     (Py_TYPE(op) == &mut PyGen_Type) as c_int
+    (Py_TYPE(op) == &mut PyGen_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyGen_New(frame: *mut PyFrameObject) -> *mut PyObject;
     pub fn PyGen_NeedsFinalizing(op: *mut PyGenObject) -> c_int;
 }
-

src/ffi2/import.rs

@@ -1,5 +1,5 @@
-use std::os::raw::{c_char, c_uchar, c_int, c_long};
 use ffi2::object::*;
+use std::os::raw::{c_char, c_int, c_long, c_uchar};
 
 #[repr(C)]
 #[derive(Copy)]
@@ -9,7 +9,10 @@ pub struct PyImport_Struct_inittab {
 }
 
 impl Clone for PyImport_Struct_inittab {
-    #[inline] fn clone(&self) -> PyImport_Struct_inittab { *self }
+    #[inline]
+    fn clone(&self) -> PyImport_Struct_inittab {
+        *self
+    }
 }
 
 #[repr(C)]
@@ -21,50 +24,51 @@ pub struct PyImport_Struct_frozen {
 }
 
 #[inline]
-pub unsafe fn PyImport_ImportModuleEx(name: *mut c_char,
+pub unsafe fn PyImport_ImportModuleEx(
-                                      globals: *mut PyObject,
+    name: *mut c_char,
-                                      locals: *mut PyObject,
+    globals: *mut PyObject,
-                                      fromlist: *mut PyObject) -> *mut PyObject {
+    locals: *mut PyObject,
+    fromlist: *mut PyObject,
+) -> *mut PyObject {
     PyImport_ImportModuleLevel(name, globals, locals, fromlist, -1)
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyImport_ImportModule(name: *const c_char)
+extern "C" {
-     -> *mut PyObject;
+    pub fn PyImport_ImportModule(name: *const c_char) -> *mut PyObject;
-    pub fn PyImport_ImportModuleNoBlock(name: *const c_char)
+    pub fn PyImport_ImportModuleNoBlock(name: *const c_char) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyImport_ImportModuleLevel(
-    pub fn PyImport_ImportModuleLevel(name: *mut c_char,
+        name: *mut c_char,
-                                      globals: *mut PyObject,
+        globals: *mut PyObject,
-                                      locals: *mut PyObject,
+        locals: *mut PyObject,
-                                      fromlist: *mut PyObject,
+        fromlist: *mut PyObject,
-                                      level: c_int) -> *mut PyObject;
+        level: c_int,
+    ) -> *mut PyObject;
 
     pub fn PyImport_Import(name: *mut PyObject) -> *mut PyObject;
     pub fn PyImport_ReloadModule(m: *mut PyObject) -> *mut PyObject;
     pub fn PyImport_AddModule(name: *const c_char) -> *mut PyObject;
-    pub fn PyImport_ExecCodeModule(name: *mut c_char,
+    pub fn PyImport_ExecCodeModule(name: *mut c_char, co: *mut PyObject) -> *mut PyObject;
-                                   co: *mut PyObject) -> *mut PyObject;
+    pub fn PyImport_ExecCodeModuleEx(
-    pub fn PyImport_ExecCodeModuleEx(name: *mut c_char,
+        name: *mut c_char,
-                                     co: *mut PyObject,
+        co: *mut PyObject,
-                                     pathname: *mut c_char)
+        pathname: *mut c_char,
-     -> *mut PyObject;
+    ) -> *mut PyObject;
     pub fn PyImport_GetMagicNumber() -> c_long;
     pub fn PyImport_GetImporter(path: *mut PyObject) -> *mut PyObject;
     pub fn PyImport_GetModuleDict() -> *mut PyObject;
-    pub fn PyImport_ImportFrozenModule(name: *mut c_char)
+    pub fn PyImport_ImportFrozenModule(name: *mut c_char) -> c_int;
-     -> c_int;
 
-    pub fn PyImport_AppendInittab(name: *const c_char,
+    pub fn PyImport_AppendInittab(
-                                  initfunc:
+        name: *const c_char,
-                                      Option<unsafe extern "C" fn()>)
+        initfunc: Option<unsafe extern "C" fn()>,
-     -> c_int;
+    ) -> c_int;
-    pub fn PyImport_ExtendInittab(newtab: *mut PyImport_Struct_inittab)
+    pub fn PyImport_ExtendInittab(newtab: *mut PyImport_Struct_inittab) -> c_int;
-     -> c_int;
 
     pub static mut PyImport_Inittab: *mut PyImport_Struct_inittab;
     pub static mut PyImport_FrozenModules: *mut PyImport_Struct_frozen;
 
-    /*for internal use only:
+/*for internal use only:
     pub fn PyImport_Cleanup();
     pub fn _PyImport_AcquireLock();
     pub fn _PyImport_ReleaseLock() -> c_int;
@@ -83,4 +87,3 @@ pub unsafe fn PyImport_ImportModuleEx(name: *mut c_char,
                                     arg2: *mut c_char)
      -> *mut PyObject;*/
 }
-

src/ffi2/intobject.rs

@@ -1,43 +1,46 @@
+use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
 use libc::size_t;
 use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ulonglong};
-use ffi2::pyport::Py_ssize_t;
-use ffi2::object::*;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyIntObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
-    pub ob_ival: c_long
+    pub ob_ival: c_long,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyInt_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyInt_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyInt_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_INT_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyInt_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyInt_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyInt_Type;
+    let u: *mut PyTypeObject = &mut PyInt_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyInt_FromString(str: *mut c_char,
+extern "C" {
-                            pend: *mut *mut c_char,
+    pub fn PyInt_FromString(str: *mut c_char, pend: *mut *mut c_char, base: c_int)
-                            base: c_int) -> *mut PyObject;
+        -> *mut PyObject;
-    #[cfg(py_sys_config="Py_USING_UNICODE")]
+    #[cfg(py_sys_config = "Py_USING_UNICODE")]
-    pub fn PyInt_FromUnicode(u: *mut ::ffi2::unicodeobject::Py_UNICODE,
+    pub fn PyInt_FromUnicode(
-                             length: Py_ssize_t,
+        u: *mut ::ffi2::unicodeobject::Py_UNICODE,
-                             base: c_int) -> *mut PyObject;
+        length: Py_ssize_t,
+        base: c_int,
+    ) -> *mut PyObject;
     pub fn PyInt_FromLong(ival: c_long) -> *mut PyObject;
     pub fn PyInt_FromSize_t(ival: size_t) -> *mut PyObject;
     pub fn PyInt_FromSsize_t(ival: Py_ssize_t) -> *mut PyObject;
@@ -45,8 +48,7 @@ pub unsafe fn PyInt_CheckExact(op : *mut PyObject) -> c_int {
     pub fn PyInt_AsSsize_t(io: *mut PyObject) -> Py_ssize_t;
     fn _PyInt_AsInt(io: *mut PyObject) -> c_int;
     pub fn PyInt_AsUnsignedLongMask(io: *mut PyObject) -> c_ulong;
-    pub fn PyInt_AsUnsignedLongLongMask(io: *mut PyObject)
+    pub fn PyInt_AsUnsignedLongLongMask(io: *mut PyObject) -> c_ulonglong;
-     -> c_ulonglong;
     pub fn PyInt_GetMax() -> c_long;
     //fn PyOS_strtoul(arg1: *mut c_char,
     //                   arg2: *mut *mut c_char, arg3: c_int)
@@ -55,15 +57,14 @@ pub unsafe fn PyInt_CheckExact(op : *mut PyObject) -> c_int {
     //                  arg2: *mut *mut c_char, arg3: c_int)
     // -> c_long;
     pub fn PyInt_ClearFreeList() -> c_int;
-    //fn _PyInt_Format(v: *mut PyIntObject, base: c_int,
+//fn _PyInt_Format(v: *mut PyIntObject, base: c_int,
-    //                     newstyle: c_int) -> *mut PyObject;
+//                     newstyle: c_int) -> *mut PyObject;
-    //fn _PyInt_FormatAdvanced(obj: *mut PyObject,
+//fn _PyInt_FormatAdvanced(obj: *mut PyObject,
-    //                             format_spec: *mut c_char,
+//                             format_spec: *mut c_char,
-    //                             format_spec_len: Py_ssize_t)
+//                             format_spec_len: Py_ssize_t)
-    // -> *mut PyObject;
+// -> *mut PyObject;
 }
 
 pub unsafe fn PyInt_AS_LONG(io: *mut PyObject) -> c_long {
     (*(io as *mut PyIntObject)).ob_ival
 }
-

src/ffi2/iterobject.rs

@@ -1,13 +1,13 @@
-use std::os::raw::c_int;
 use ffi2::object::*;
+use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PySeqIter_Type: PyTypeObject;
     pub static mut PyCallIter_Type: PyTypeObject;
 
     pub fn PySeqIter_New(arg1: *mut PyObject) -> *mut PyObject;
-    pub fn PyCallIter_New(arg1: *mut PyObject, arg2: *mut PyObject)
+    pub fn PyCallIter_New(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
-                          -> *mut PyObject;
 }
 
 #[inline(always)]

src/ffi2/listobject.rs

@@ -1,13 +1,13 @@
-use std::os::raw::c_int;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyListObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -16,26 +16,26 @@ pub struct PyListObject {
     pub allocated: Py_ssize_t,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyList_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyList_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyList_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyList_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyList_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyList_Type;
+    let u: *mut PyTypeObject = &mut PyList_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-
 // Macro, trading safety for speed
 #[inline(always)]
 pub unsafe fn PyList_GET_ITEM(op: *mut PyObject, i: Py_ssize_t) -> *mut PyObject {
-   *(*(op as *mut PyListObject)).ob_item.offset(i as isize)
+    *(*(op as *mut PyListObject)).ob_item.offset(i as isize)
 }
 
 #[inline(always)]
@@ -46,29 +46,28 @@ pub unsafe fn PyList_GET_SIZE(op: *mut PyObject) -> Py_ssize_t {
 /// Macro, *only* to be used to fill in brand new lists
 #[inline(always)]
 pub unsafe fn PyList_SET_ITEM(op: *mut PyObject, i: Py_ssize_t, v: *mut PyObject) {
-   *(*(op as *mut PyListObject)).ob_item.offset(i as isize) = v;
+    *(*(op as *mut PyListObject)).ob_item.offset(i as isize) = v;
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyList_New(size: Py_ssize_t) -> *mut PyObject;
     pub fn PyList_Size(list: *mut PyObject) -> Py_ssize_t;
-    pub fn PyList_GetItem(list: *mut PyObject, index: Py_ssize_t)
+    pub fn PyList_GetItem(list: *mut PyObject, index: Py_ssize_t) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyList_SetItem(list: *mut PyObject, index: Py_ssize_t, item: *mut PyObject) -> c_int;
-    pub fn PyList_SetItem(list: *mut PyObject, index: Py_ssize_t,
+    pub fn PyList_Insert(list: *mut PyObject, index: Py_ssize_t, item: *mut PyObject) -> c_int;
-                          item: *mut PyObject) -> c_int;
+    pub fn PyList_Append(list: *mut PyObject, item: *mut PyObject) -> c_int;
-    pub fn PyList_Insert(list: *mut PyObject, index: Py_ssize_t,
+    pub fn PyList_GetSlice(list: *mut PyObject, low: Py_ssize_t, high: Py_ssize_t)
-                         item: *mut PyObject) -> c_int;
+        -> *mut PyObject;
-    pub fn PyList_Append(list: *mut PyObject, item: *mut PyObject)
+    pub fn PyList_SetSlice(
-     -> c_int;
+        list: *mut PyObject,
-    pub fn PyList_GetSlice(list: *mut PyObject, low: Py_ssize_t,
+        low: Py_ssize_t,
-                           high: Py_ssize_t) -> *mut PyObject;
+        high: Py_ssize_t,
-    pub fn PyList_SetSlice(list: *mut PyObject, low: Py_ssize_t,
+        itemlist: *mut PyObject,
-                           high: Py_ssize_t, itemlist: *mut PyObject)
+    ) -> c_int;
-     -> c_int;
     pub fn PyList_Sort(list: *mut PyObject) -> c_int;
     pub fn PyList_Reverse(list: *mut PyObject) -> c_int;
     pub fn PyList_AsTuple(list: *mut PyObject) -> *mut PyObject;
-    //fn _PyList_Extend(arg1: *mut PyListObject, arg2: *mut PyObject)
+//fn _PyList_Extend(arg1: *mut PyListObject, arg2: *mut PyObject)
-    //-> *mut PyObject;
+//-> *mut PyObject;
 }
-

src/ffi2/longobject.rs

@@ -1,59 +1,59 @@
-use std::os::raw::{
-    c_void, c_char, c_int, c_long, c_ulong, c_longlong, c_ulonglong, c_double, c_uchar
-};
-use libc::size_t;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use libc::size_t;
+use std::os::raw::{
+    c_char, c_double, c_int, c_long, c_longlong, c_uchar, c_ulong, c_ulonglong, c_void,
+};
 
 pub enum PyLongObject {}
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyLong_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyLong_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyLong_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyLong_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyLong_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyLong_Type;
+    let u: *mut PyTypeObject = &mut PyLong_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyLong_FromLong(v: c_long) -> *mut PyObject;
     pub fn PyLong_FromUnsignedLong(v: c_ulong) -> *mut PyObject;
     pub fn PyLong_FromSsize_t(v: Py_ssize_t) -> *mut PyObject;
     pub fn PyLong_FromSize_t(v: size_t) -> *mut PyObject;
     pub fn PyLong_FromLongLong(v: c_longlong) -> *mut PyObject;
-    pub fn PyLong_FromUnsignedLongLong(v: c_ulonglong)
+    pub fn PyLong_FromUnsignedLongLong(v: c_ulonglong) -> *mut PyObject;
-     -> *mut PyObject;
     pub fn PyLong_FromDouble(v: c_double) -> *mut PyObject;
-    pub fn PyLong_FromString(str: *mut c_char,
+    pub fn PyLong_FromString(
-                             pend: *mut *mut c_char,
+        str: *mut c_char,
-                             base: c_int) -> *mut PyObject;
+        pend: *mut *mut c_char,
-    #[cfg(py_sys_config="Py_USING_UNICODE")]
+        base: c_int,
-    pub fn PyLong_FromUnicode(u: *mut ::ffi2::unicodeobject::Py_UNICODE,
+    ) -> *mut PyObject;
-                              length: Py_ssize_t, base: c_int) -> *mut PyObject;
+    #[cfg(py_sys_config = "Py_USING_UNICODE")]
+    pub fn PyLong_FromUnicode(
+        u: *mut ::ffi2::unicodeobject::Py_UNICODE,
+        length: Py_ssize_t,
+        base: c_int,
+    ) -> *mut PyObject;
     pub fn PyLong_FromVoidPtr(p: *mut c_void) -> *mut PyObject;
 
     pub fn PyLong_AsLong(pylong: *mut PyObject) -> c_long;
-    pub fn PyLong_AsLongAndOverflow(pylong: *mut PyObject,
+    pub fn PyLong_AsLongAndOverflow(pylong: *mut PyObject, overflow: *mut c_int) -> c_long;
-                                    overflow: *mut c_int)
+    pub fn PyLong_AsLongLongAndOverflow(pylong: *mut PyObject, overflow: *mut c_int) -> c_longlong;
-     -> c_long;
-    pub fn PyLong_AsLongLongAndOverflow(pylong: *mut PyObject,
-                                        overflow: *mut c_int)
-     -> c_longlong;
     pub fn PyLong_AsSsize_t(pylong: *mut PyObject) -> Py_ssize_t;
     pub fn PyLong_AsUnsignedLong(pylong: *mut PyObject) -> c_ulong;
     pub fn PyLong_AsLongLong(pylong: *mut PyObject) -> c_longlong;
-    pub fn PyLong_AsUnsignedLongLong(pylong: *mut PyObject)
+    pub fn PyLong_AsUnsignedLongLong(pylong: *mut PyObject) -> c_ulonglong;
-     -> c_ulonglong;
     pub fn PyLong_AsUnsignedLongMask(pylong: *mut PyObject) -> c_ulong;
-    pub fn PyLong_AsUnsignedLongLongMask(pylong: *mut PyObject)
+    pub fn PyLong_AsUnsignedLongLongMask(pylong: *mut PyObject) -> c_ulonglong;
-     -> c_ulonglong;
     pub fn PyLong_AsDouble(pylong: *mut PyObject) -> c_double;
     pub fn PyLong_AsVoidPtr(pylong: *mut PyObject) -> *mut c_void;
 

src/ffi2/memoryobject.rs

@@ -1,32 +1,35 @@
-use std::os::raw::{c_int, c_char};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyMemoryView_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyMemoryView_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyMemoryView_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyMemoryView_Type;
+    let u: *mut PyTypeObject = &mut PyMemoryView_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyMemoryView_GET_BUFFER(op : *mut PyObject) -> *mut Py_buffer {
+pub unsafe fn PyMemoryView_GET_BUFFER(op: *mut PyObject) -> *mut Py_buffer {
     &mut (*(op as *mut PyMemoryViewObject)).view
 }
 
 #[inline(always)]
-pub unsafe fn PyMemoryView_GET_BASE(op : *mut PyObject) -> *mut PyObject {
+pub unsafe fn PyMemoryView_GET_BASE(op: *mut PyObject) -> *mut PyObject {
     (*(op as *mut PyMemoryViewObject)).view.obj
 }
 
-
+#[cfg_attr(windows, link(name = "pythonXY"))]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+extern "C" {
-    pub fn PyMemoryView_GetContiguous(base: *mut PyObject,
+    pub fn PyMemoryView_GetContiguous(
-                                      buffertype: c_int,
+        base: *mut PyObject,
-                                      fort: c_char) -> *mut PyObject;
+        buffertype: c_int,
+        fort: c_char,
+    ) -> *mut PyObject;
     pub fn PyMemoryView_FromObject(base: *mut PyObject) -> *mut PyObject;
     pub fn PyMemoryView_FromBuffer(info: *mut Py_buffer) -> *mut PyObject;
 }
@@ -34,13 +37,12 @@ pub unsafe fn PyMemoryView_GET_BASE(op : *mut PyObject) -> *mut PyObject {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyMemoryViewObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
     pub base: *mut PyObject,
     pub view: Py_buffer,
 }
-

src/ffi2/methodobject.rs

@@ -1,36 +1,35 @@
-use std::ptr;
-use std::os::raw::{c_char, c_int};
 use ffi2::object::{PyObject, PyTypeObject, Py_TYPE};
+use std::os::raw::{c_char, c_int};
+use std::ptr;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyCFunction_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyCFunction_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyCFunction_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyCFunction_Type;
+    let u: *mut PyTypeObject = &mut PyCFunction_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
 pub type PyCFunction =
-    unsafe extern "C" fn
+    unsafe extern "C" fn(slf: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
-                              (slf: *mut PyObject, args: *mut PyObject)
-                              -> *mut PyObject;
 pub type PyCFunctionWithKeywords =
-    unsafe extern "C" fn
+    unsafe extern "C" fn(slf: *mut PyObject, args: *mut PyObject, kwds: *mut PyObject)
-                              (slf: *mut PyObject, args: *mut PyObject,
+        -> *mut PyObject;
-                               kwds: *mut PyObject) -> *mut PyObject;
+pub type PyNoArgsFunction = unsafe extern "C" fn(slf: *mut PyObject) -> *mut PyObject;
-pub type PyNoArgsFunction =
-    unsafe extern "C" fn(slf: *mut PyObject)
-                              -> *mut PyObject;
 
-
+#[cfg_attr(windows, link(name = "pythonXY"))]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+extern "C" {
     pub fn PyCFunction_GetFunction(f: *mut PyObject) -> Option<PyCFunction>;
     pub fn PyCFunction_GetSelf(f: *mut PyObject) -> *mut PyObject;
     pub fn PyCFunction_GetFlags(f: *mut PyObject) -> c_int;
-    pub fn PyCFunction_Call(f: *mut PyObject, args: *mut PyObject,
+    pub fn PyCFunction_Call(
-                            kwds: *mut PyObject) -> *mut PyObject;
+        f: *mut PyObject,
+        args: *mut PyObject,
+        kwds: *mut PyObject,
+    ) -> *mut PyObject;
 }
 
 #[repr(C)]
@@ -42,7 +41,7 @@ pub struct PyMethodDef {
     pub ml_doc: *const c_char,
 }
 
-pub const PyMethodDef_INIT : PyMethodDef = PyMethodDef {
+pub const PyMethodDef_INIT: PyMethodDef = PyMethodDef {
     ml_name: ::std::ptr::null(),
     ml_meth: None,
     ml_flags: 0,
@@ -50,30 +49,32 @@ pub const PyMethodDef_INIT : PyMethodDef = PyMethodDef {
 };
 
 impl Clone for PyMethodDef {
-    #[inline] fn clone(&self) -> PyMethodDef { *self }
+    #[inline]
+    fn clone(&self) -> PyMethodDef {
+        *self
+    }
 }
 
 /* Flag passed to newmethodobject */
-pub const METH_OLDARGS  : c_int = 0x0000;
+pub const METH_OLDARGS: c_int = 0x0000;
-pub const METH_VARARGS  : c_int = 0x0001;
+pub const METH_VARARGS: c_int = 0x0001;
-pub const METH_KEYWORDS : c_int = 0x0002;
+pub const METH_KEYWORDS: c_int = 0x0002;
 /* METH_NOARGS and METH_O must not be combined with the flags above. */
-pub const METH_NOARGS   : c_int = 0x0004;
+pub const METH_NOARGS: c_int = 0x0004;
-pub const METH_O        : c_int = 0x0008;
+pub const METH_O: c_int = 0x0008;
 
 /* METH_CLASS and METH_STATIC are a little different; these control
    the construction of methods for a class.  These cannot be used for
    functions in modules. */
-pub const METH_CLASS    : c_int = 0x0010;
+pub const METH_CLASS: c_int = 0x0010;
-pub const METH_STATIC   : c_int = 0x0020;
+pub const METH_STATIC: c_int = 0x0020;
 
 /* METH_COEXIST allows a method to be entered eventhough a slot has
    already filled the entry.  When defined, the flag allows a separate
    method, "__contains__" for example, to coexist with a defined
    slot like sq_contains. */
 
-pub const METH_COEXIST   : c_int = 0x0040;
+pub const METH_COEXIST: c_int = 0x0040;
-
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -98,13 +99,23 @@ struct PyCFunctionObject {
 }
 */
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn Py_FindMethod(methods: *mut PyMethodDef, slf: *mut PyObject,
+extern "C" {
-                         name: *const c_char) -> *mut PyObject;
+    pub fn Py_FindMethod(
-    pub fn PyCFunction_NewEx(ml: *mut PyMethodDef, slf: *mut PyObject,
+        methods: *mut PyMethodDef,
-                             module: *mut PyObject) -> *mut PyObject;
+        slf: *mut PyObject,
-    pub fn Py_FindMethodInChain(chain: *mut PyMethodChain, slf: *mut PyObject,
+        name: *const c_char,
-                                name: *const c_char) -> *mut PyObject;
+    ) -> *mut PyObject;
+    pub fn PyCFunction_NewEx(
+        ml: *mut PyMethodDef,
+        slf: *mut PyObject,
+        module: *mut PyObject,
+    ) -> *mut PyObject;
+    pub fn Py_FindMethodInChain(
+        chain: *mut PyMethodChain,
+        slf: *mut PyObject,
+        name: *const c_char,
+    ) -> *mut PyObject;
     pub fn PyCFunction_ClearFreeList() -> c_int;
 }
 
@@ -112,4 +123,3 @@ struct PyCFunctionObject {
 pub unsafe fn PyCFunction_New(ml: *mut PyMethodDef, slf: *mut PyObject) -> *mut PyObject {
     PyCFunction_NewEx(ml, slf, ptr::null_mut())
 }
-

src/ffi2/mod.rs

@@ -5,95 +5,95 @@
 
 use std::os::raw::c_int;
 
-pub use self::pyport::*;
-pub use self::pymem::*;
-pub use self::object::*;
-pub use self::objimpl::*;
-pub use self::pydebug::*;
-#[cfg(py_sys_config="Py_USING_UNICODE")]
-pub use self::unicodeobject::*;
-pub use self::intobject::*;
 pub use self::boolobject::*;
-pub use self::longobject::*;
-pub use self::floatobject::*;
-pub use self::complexobject::*;
-pub use self::rangeobject::*;
-pub use self::memoryobject::*;
 pub use self::bufferobject::*;
-pub use self::stringobject::*;
-pub use self::bytesobject::*;
 pub use self::bytearrayobject::*;
-pub use self::tupleobject::*;
+pub use self::bytesobject::*;
-pub use self::listobject::*;
-pub use self::dictobject::*;
-pub use self::enumobject::*;
-pub use self::setobject::*;
-pub use self::pyerrors::*;
-pub use self::pystate::*;
-pub use self::pystate::PyGILState_STATE::*;
-pub use self::methodobject::*;
-pub use self::moduleobject::*;
-pub use self::funcobject::*;
-pub use self::classobject::*;
-pub use self::fileobject::*;
-pub use self::cobject::*;
-pub use self::pycapsule::*;
-pub use self::traceback::*;
-pub use self::sliceobject::*;
 pub use self::cellobject::*;
-pub use self::iterobject::*;
-pub use self::genobject::*;
-pub use self::descrobject::*;
-pub use self::warnings::*;
-pub use self::weakrefobject::*;
-pub use self::pyarena::*;
-pub use self::modsupport::*;
-pub use self::pythonrun::*;
 pub use self::ceval::*;
-pub use self::import::*;
+pub use self::classobject::*;
-pub use self::objectabstract::*;
+pub use self::cobject::*;
 pub use self::code::*;
 pub use self::compile::*;
+pub use self::complexobject::*;
+pub use self::descrobject::*;
+pub use self::dictobject::*;
+pub use self::enumobject::*;
 pub use self::eval::*;
-pub use self::structmember::PyMemberDef;
+pub use self::fileobject::*;
+pub use self::floatobject::*;
 pub use self::frameobject::PyFrameObject;
+pub use self::funcobject::*;
+pub use self::genobject::*;
+pub use self::import::*;
+pub use self::intobject::*;
+pub use self::iterobject::*;
+pub use self::listobject::*;
+pub use self::longobject::*;
+pub use self::memoryobject::*;
+pub use self::methodobject::*;
+pub use self::modsupport::*;
+pub use self::moduleobject::*;
+pub use self::object::*;
+pub use self::objectabstract::*;
+pub use self::objimpl::*;
+pub use self::pyarena::*;
+pub use self::pycapsule::*;
+pub use self::pydebug::*;
+pub use self::pyerrors::*;
+pub use self::pymem::*;
+pub use self::pyport::*;
+pub use self::pystate::PyGILState_STATE::*;
+pub use self::pystate::*;
+pub use self::pythonrun::*;
+pub use self::rangeobject::*;
+pub use self::setobject::*;
+pub use self::sliceobject::*;
+pub use self::stringobject::*;
+pub use self::structmember::PyMemberDef;
+pub use self::traceback::*;
+pub use self::tupleobject::*;
+#[cfg(py_sys_config = "Py_USING_UNICODE")]
+pub use self::unicodeobject::*;
+pub use self::warnings::*;
+pub use self::weakrefobject::*;
 
-mod pyport;
-mod pymem;
-mod object;
-mod objimpl;
-mod pydebug;
-#[cfg(py_sys_config="Py_USING_UNICODE")]
-mod unicodeobject; // TODO: incomplete
-mod intobject;
 mod boolobject;
-mod longobject;
-mod floatobject;
-mod complexobject;
-mod rangeobject;
-mod stringobject;
-mod memoryobject;
 mod bufferobject;
-mod bytesobject;
 mod bytearrayobject;
-mod tupleobject;
+mod bytesobject;
-mod listobject;
+mod cellobject;
+mod classobject;
+mod cobject;
+mod complexobject;
+mod descrobject;
 mod dictobject;
 mod enumobject;
-mod setobject;
+mod fileobject;
+mod floatobject;
+mod funcobject;
+mod genobject;
+mod intobject;
+mod iterobject;
+mod listobject;
+mod longobject;
+mod memoryobject;
 mod methodobject;
 mod moduleobject;
-mod funcobject;
+mod object;
-mod classobject;
+mod objimpl;
-mod fileobject;
-mod cobject;
 mod pycapsule;
-mod traceback;
+mod pydebug;
+mod pymem;
+mod pyport;
+mod rangeobject;
+mod setobject;
 mod sliceobject;
-mod cellobject;
+mod stringobject;
-mod iterobject;
+mod traceback;
-mod genobject;
+mod tupleobject;
-mod descrobject;
+#[cfg(py_sys_config = "Py_USING_UNICODE")]
+mod unicodeobject; // TODO: incomplete
 mod warnings;
 mod weakrefobject;
 
@@ -102,10 +102,10 @@ mod pyerrors;
 
 mod pystate;
 
-mod pyarena;
-mod modsupport;
-mod pythonrun;
 mod ceval;
+mod modsupport;
+mod pyarena;
+mod pythonrun;
 // mod sysmodule; // TODO: incomplete
 // mod intrcheck; // TODO: incomplete
 mod import;
@@ -124,17 +124,21 @@ mod eval;
 // mod pyfpe; // TODO: incomplete
 
 // Additional headers that are not exported by Python.h
-pub mod structmember;
 pub mod frameobject;
+pub mod structmember;
 
 pub const Py_single_input: c_int = 256;
 pub const Py_file_input: c_int = 257;
 pub const Py_eval_input: c_int = 258;
 
-#[cfg(not(py_sys_config="Py_USING_UNICODE"))]
+#[cfg(not(py_sys_config = "Py_USING_UNICODE"))]
 #[inline(always)]
-pub fn PyUnicode_Check(op : *mut PyObject) -> libc::c_int { 0 }
+pub fn PyUnicode_Check(op: *mut PyObject) -> libc::c_int {
+    0
+}
 
-#[cfg(not(py_sys_config="Py_USING_UNICODE"))]
+#[cfg(not(py_sys_config = "Py_USING_UNICODE"))]
 #[inline(always)]
-pub fn PyUnicode_CheckExact(op : *mut PyObject) -> libc::c_int { 0 }
+pub fn PyUnicode_CheckExact(op: *mut PyObject) -> libc::c_int {
+    0
+}

src/ffi2/modsupport.rs

@@ -1,94 +1,164 @@
-use std::ptr;
-use std::os::raw::{c_char, c_int, c_long};
-use ffi2::pyport::Py_ssize_t;
-use ffi2::object::PyObject;
 use ffi2::methodobject::PyMethodDef;
+use ffi2::object::PyObject;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int, c_long};
+use std::ptr;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyArg_Parse(args: *mut PyObject, format: *const c_char, ...) -> c_int;
-    pub fn PyArg_ParseTuple(args: *mut PyObject,
+    pub fn PyArg_ParseTuple(args: *mut PyObject, format: *const c_char, ...) -> c_int;
-                            format: *const c_char, ...) -> c_int;
+    pub fn PyArg_ParseTupleAndKeywords(
-    pub fn PyArg_ParseTupleAndKeywords(args: *mut PyObject,
+        args: *mut PyObject,
-                                       kw: *mut PyObject,
+        kw: *mut PyObject,
-                                       format: *const c_char,
+        format: *const c_char,
-                                       keywords: *mut *mut c_char, ...) -> c_int;
+        keywords: *mut *mut c_char,
-    pub fn PyArg_UnpackTuple(args: *mut PyObject, name: *const c_char,
+        ...
-                             min: Py_ssize_t, max: Py_ssize_t, ...) -> c_int;
+    ) -> c_int;
+    pub fn PyArg_UnpackTuple(
+        args: *mut PyObject,
+        name: *const c_char,
+        min: Py_ssize_t,
+        max: Py_ssize_t,
+        ...
+    ) -> c_int;
     pub fn Py_BuildValue(format: *const c_char, ...) -> *mut PyObject;
     //fn _Py_BuildValue_SizeT(arg1: *const c_char, ...)
     // -> *mut PyObject;
     //fn _PyArg_NoKeywords(funcname: *const c_char,
     //                     kw: *mut PyObject) -> c_int;
-    pub fn PyModule_AddObject(module: *mut PyObject,
+    pub fn PyModule_AddObject(
-                              name: *const c_char,
+        module: *mut PyObject,
-                              value: *mut PyObject) -> c_int;
+        name: *const c_char,
-    pub fn PyModule_AddIntConstant(module: *mut PyObject,
+        value: *mut PyObject,
-                                   name: *const c_char,
+    ) -> c_int;
-                                   value: c_long) -> c_int;
+    pub fn PyModule_AddIntConstant(
-    pub fn PyModule_AddStringConstant(module: *mut PyObject,
+        module: *mut PyObject,
-                                      name: *const c_char,
+        name: *const c_char,
-                                      value: *const c_char) -> c_int;
+        value: c_long,
+    ) -> c_int;
+    pub fn PyModule_AddStringConstant(
+        module: *mut PyObject,
+        name: *const c_char,
+        value: *const c_char,
+    ) -> c_int;
 
-    #[cfg(all(target_pointer_width = "64", not(py_sys_config = "Py_TRACE_REFS")))]
+    #[cfg(
-    fn Py_InitModule4_64(name: *const c_char,
+        all(
-                         methods: *mut PyMethodDef,
+            target_pointer_width = "64",
-                         doc: *const c_char, _self: *mut PyObject,
+            not(py_sys_config = "Py_TRACE_REFS")
-                         apiver: c_int) -> *mut PyObject;
+        )
+    )]
+    fn Py_InitModule4_64(
+        name: *const c_char,
+        methods: *mut PyMethodDef,
+        doc: *const c_char,
+        _self: *mut PyObject,
+        apiver: c_int,
+    ) -> *mut PyObject;
 
     #[cfg(all(target_pointer_width = "64", py_sys_config = "Py_TRACE_REFS"))]
-    fn Py_InitModule4TraceRefs_64(name: *const c_char,
+    fn Py_InitModule4TraceRefs_64(
-                                  methods: *mut PyMethodDef,
+        name: *const c_char,
-                                  doc: *const c_char, _self: *mut PyObject,
+        methods: *mut PyMethodDef,
-                                  apiver: c_int) -> *mut PyObject;
+        doc: *const c_char,
+        _self: *mut PyObject,
+        apiver: c_int,
+    ) -> *mut PyObject;
 
-    #[cfg(all(not(target_pointer_width = "64"), not(py_sys_config = "Py_TRACE_REFS")))]
+    #[cfg(
-    pub fn Py_InitModule4(name: *const c_char,
+        all(
-                          methods: *mut PyMethodDef,
+            not(target_pointer_width = "64"),
-                          doc: *const c_char, _self: *mut PyObject,
+            not(py_sys_config = "Py_TRACE_REFS")
-                          apiver: c_int) -> *mut PyObject;
+        )
+    )]
+    pub fn Py_InitModule4(
+        name: *const c_char,
+        methods: *mut PyMethodDef,
+        doc: *const c_char,
+        _self: *mut PyObject,
+        apiver: c_int,
+    ) -> *mut PyObject;
 
-    #[cfg(all(not(target_pointer_width = "64"), py_sys_config = "Py_TRACE_REFS"))]
+    #[cfg(
-    fn Py_InitModule4TraceRefs(name: *const c_char,
+        all(
-                               methods: *mut PyMethodDef,
+            not(target_pointer_width = "64"),
-                               doc: *const c_char, _self: *mut PyObject,
+            py_sys_config = "Py_TRACE_REFS"
-                               apiver: c_int) -> *mut PyObject;
+        )
+    )]
+    fn Py_InitModule4TraceRefs(
+        name: *const c_char,
+        methods: *mut PyMethodDef,
+        doc: *const c_char,
+        _self: *mut PyObject,
+        apiver: c_int,
+    ) -> *mut PyObject;
 }
 
-pub const PYTHON_API_VERSION : c_int = 1013;
+pub const PYTHON_API_VERSION: c_int = 1013;
 
-#[cfg(all(target_pointer_width = "64", not(py_sys_config = "Py_TRACE_REFS")))]
+#[cfg(
+    all(
+        target_pointer_width = "64",
+        not(py_sys_config = "Py_TRACE_REFS")
+    )
+)]
 #[inline(always)]
-pub unsafe fn Py_InitModule4(name: *const c_char,
+pub unsafe fn Py_InitModule4(
-                             methods: *mut PyMethodDef,
+    name: *const c_char,
-                             doc: *const c_char, _self: *mut PyObject,
+    methods: *mut PyMethodDef,
-                             apiver: c_int) -> *mut PyObject {
+    doc: *const c_char,
+    _self: *mut PyObject,
+    apiver: c_int,
+) -> *mut PyObject {
     Py_InitModule4_64(name, methods, doc, _self, apiver)
 }
 
 #[cfg(all(target_pointer_width = "64", py_sys_config = "Py_TRACE_REFS"))]
 #[inline(always)]
-pub unsafe fn Py_InitModule4(name: *const c_char,
+pub unsafe fn Py_InitModule4(
-                             methods: *mut PyMethodDef,
+    name: *const c_char,
-                             doc: *const c_char, _self: *mut PyObject,
+    methods: *mut PyMethodDef,
-                             apiver: c_int) -> *mut PyObject {
+    doc: *const c_char,
+    _self: *mut PyObject,
+    apiver: c_int,
+) -> *mut PyObject {
     Py_InitModule4TraceRefs_64(name, methods, doc, _self, apiver)
 }
 
-#[cfg(all(not(target_pointer_width = "64"), py_sys_config = "Py_TRACE_REFS"))]
+#[cfg(
+    all(
+        not(target_pointer_width = "64"),
+        py_sys_config = "Py_TRACE_REFS"
+    )
+)]
 #[inline(always)]
-pub unsafe fn Py_InitModule4(name: *const c_char,
+pub unsafe fn Py_InitModule4(
-                             methods: *mut PyMethodDef,
+    name: *const c_char,
-                             doc: *const c_char, _self: *mut PyObject,
+    methods: *mut PyMethodDef,
-                             apiver: c_int) -> *mut PyObject {
+    doc: *const c_char,
+    _self: *mut PyObject,
+    apiver: c_int,
+) -> *mut PyObject {
     Py_InitModule4TraceRefs(name, methods, doc, _self, apiver)
 }
 
 #[inline(always)]
 pub unsafe fn Py_InitModule(name: *const c_char, methods: *mut PyMethodDef) -> *mut PyObject {
-    Py_InitModule4(name, methods, ptr::null(), ptr::null_mut(), PYTHON_API_VERSION)
+    Py_InitModule4(
+        name,
+        methods,
+        ptr::null(),
+        ptr::null_mut(),
+        PYTHON_API_VERSION,
+    )
 }
 
 #[inline(always)]
-pub unsafe fn Py_InitModule3(name: *const c_char, methods: *mut PyMethodDef, doc : *const c_char) -> *mut PyObject {
+pub unsafe fn Py_InitModule3(
+    name: *const c_char,
+    methods: *mut PyMethodDef,
+    doc: *const c_char,
+) -> *mut PyObject {
     Py_InitModule4(name, methods, doc, ptr::null_mut(), PYTHON_API_VERSION)
 }

src/ffi2/moduleobject.rs

@@ -1,23 +1,25 @@
-use std::os::raw::{c_char, c_int, c_void};
-use ffi2::pyport::Py_ssize_t;
-use ffi2::object::*;
 use ffi2::methodobject::PyMethodDef;
+use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int, c_void};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyModule_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyModule_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyModule_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyModule_Type)
 }
 
 #[inline(always)]
-pub unsafe fn PyModule_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyModule_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyModule_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyModule_NewObject(name: *mut PyObject) -> *mut PyObject;
     pub fn PyModule_New(name: *const c_char) -> *mut PyObject;
     pub fn PyModule_GetDict(arg1: *mut PyObject) -> *mut PyObject;
@@ -40,14 +42,16 @@ pub struct PyModuleDef_Base {
     pub m_copy: *mut PyObject,
 }
 impl Clone for PyModuleDef_Base {
-    fn clone(&self) -> PyModuleDef_Base { *self }
+    fn clone(&self) -> PyModuleDef_Base {
+        *self
+    }
 }
 
 pub const PyModuleDef_HEAD_INIT: PyModuleDef_Base = PyModuleDef_Base {
     ob_base: PyObject_HEAD_INIT,
     m_init: None,
     m_index: 0,
-    m_copy: ::std::ptr::null_mut()
+    m_copy: ::std::ptr::null_mut(),
 };
 
 #[repr(C)]
@@ -57,11 +61,13 @@ pub struct PyModuleDef_Slot {
     pub value: *mut c_void,
 }
 impl Clone for PyModuleDef_Slot {
-    fn clone(&self) -> PyModuleDef_Slot { *self }
+    fn clone(&self) -> PyModuleDef_Slot {
+        *self
+    }
 }
 
-pub const Py_mod_create : c_int = 1;
+pub const Py_mod_create: c_int = 1;
-pub const Py_mod_exec : c_int = 2;
+pub const Py_mod_exec: c_int = 2;
 
 #[repr(C)]
 #[derive(Copy)]
@@ -77,7 +83,9 @@ pub struct PyModuleDef {
     pub m_free: Option<freefunc>,
 }
 impl Clone for PyModuleDef {
-    fn clone(&self) -> PyModuleDef { *self }
+    fn clone(&self) -> PyModuleDef {
+        *self
+    }
 }
 
 pub const PyModuleDef_INIT: PyModuleDef = PyModuleDef {
@@ -89,5 +97,5 @@ pub const PyModuleDef_INIT: PyModuleDef = PyModuleDef {
     m_slots: ::std::ptr::null_mut(),
     m_traverse: None,
     m_clear: None,
-    m_free: None
+    m_free: None,
 };

src/ffi2/object.rs

@@ -1,33 +1,33 @@
-use std::ptr;
-use std::os::raw::{c_void, c_int, c_uint, c_long, c_char, c_double};
-use libc::FILE;
 use ffi2;
-use ffi2::pyport::{Py_ssize_t, Py_hash_t};
 use ffi2::methodobject::PyMethodDef;
+use ffi2::pyport::{Py_hash_t, Py_ssize_t};
+use libc::FILE;
+use std::os::raw::{c_char, c_double, c_int, c_long, c_uint, c_void};
+use std::ptr;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
 }
 
-#[cfg(py_sys_config="Py_TRACE_REFS")]
+#[cfg(py_sys_config = "Py_TRACE_REFS")]
 pub const PyObject_HEAD_INIT: PyObject = PyObject {
     _ob_next: ::std::ptr::null_mut(),
     _ob_prev: ::std::ptr::null_mut(),
     ob_refcnt: 1,
-    ob_type: ::std::ptr::null_mut()
+    ob_type: ::std::ptr::null_mut(),
 };
 
-#[cfg(not(py_sys_config="Py_TRACE_REFS"))]
+#[cfg(not(py_sys_config = "Py_TRACE_REFS"))]
 pub const PyObject_HEAD_INIT: PyObject = PyObject {
     ob_refcnt: 1,
-    ob_type: ::std::ptr::null_mut()
+    ob_type: ::std::ptr::null_mut(),
 };
 
 #[repr(C)]
@@ -38,74 +38,67 @@ pub struct PyVarObject {
 }
 
 #[inline(always)]
-pub unsafe fn Py_REFCNT(ob : *mut PyObject) -> Py_ssize_t {
+pub unsafe fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t {
     (*ob).ob_refcnt
 }
 
 #[inline(always)]
-pub unsafe fn Py_TYPE(ob : *mut PyObject) -> *mut PyTypeObject {
+pub unsafe fn Py_TYPE(ob: *mut PyObject) -> *mut PyTypeObject {
     (*ob).ob_type
 }
 
 #[inline(always)]
-pub unsafe fn Py_SIZE(ob : *mut PyObject) -> Py_ssize_t {
+pub unsafe fn Py_SIZE(ob: *mut PyObject) -> Py_ssize_t {
     (*(ob as *mut PyVarObject)).ob_size
 }
 
-pub type unaryfunc =
+pub type unaryfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
-    unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
 pub type binaryfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
 pub type ternaryfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject)
-                          arg3: *mut PyObject) -> *mut PyObject;
+        -> *mut PyObject;
-pub type inquiry =
+pub type inquiry = unsafe extern "C" fn(arg1: *mut PyObject) -> c_int;
-    unsafe extern "C" fn(arg1: *mut PyObject) -> c_int;
+pub type lenfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> Py_ssize_t;
-pub type lenfunc =
-    unsafe extern "C" fn(arg1: *mut PyObject) -> Py_ssize_t;
 pub type coercion =
-    unsafe extern "C" fn (arg1: *mut *mut PyObject,
+    unsafe extern "C" fn(arg1: *mut *mut PyObject, arg2: *mut *mut PyObject) -> c_int;
-                          arg2: *mut *mut PyObject) -> c_int;
 pub type ssizeargfunc =
     unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject;
 pub type ssizessizeargfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: Py_ssize_t) -> *mut PyObject;
-                          arg3: Py_ssize_t) -> *mut PyObject;
 pub type intobjargproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: c_int, arg3: *mut PyObject) -> c_int;
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: *mut PyObject) -> c_int;
 pub type intintobjargproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: c_int,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: c_int, arg4: *mut PyObject)
-                          arg3: c_int, arg4: *mut PyObject) -> c_int;
+        -> c_int;
 pub type ssizeobjargproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject) -> c_int;
-                          arg3: *mut PyObject) -> c_int;
+pub type ssizessizeobjargproc = unsafe extern "C" fn(
-pub type ssizessizeobjargproc =
+    arg1: *mut PyObject,
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t,
+    arg2: Py_ssize_t,
-                          arg3: Py_ssize_t, arg4: *mut PyObject) -> c_int;
+    arg3: Py_ssize_t,
+    arg4: *mut PyObject,
+) -> c_int;
 pub type objobjargproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int;
-                          arg3: *mut PyObject) -> c_int;
 pub type getreadbufferproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: c_int,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: *mut *mut c_void) -> c_int;
-                          arg3: *mut *mut c_void) -> c_int;
 pub type getwritebufferproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: c_int,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: *mut *mut c_void) -> c_int;
-                          arg3: *mut *mut c_void) -> c_int;
+pub type getsegcountproc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut c_int) -> c_int;
-pub type getsegcountproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut c_int) -> c_int;
 pub type getcharbufferproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: c_int, arg3: *mut *mut c_char) -> c_int;
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: c_int, arg3: *mut *mut c_char) -> c_int;
 pub type readbufferproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut *mut c_void)
-                          arg3: *mut *mut c_void) -> Py_ssize_t;
+        -> Py_ssize_t;
 pub type writebufferproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut *mut c_void)
-                          arg3: *mut *mut c_void) -> Py_ssize_t;
+        -> Py_ssize_t;
 pub type segcountproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> Py_ssize_t;
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> Py_ssize_t;
 pub type charbufferproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: Py_ssize_t,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut *mut c_char)
-                          arg3: *mut *mut c_char) -> Py_ssize_t;
+        -> Py_ssize_t;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -125,47 +118,41 @@ pub struct Py_buffer {
 }
 
 pub type getbufferproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut Py_buffer,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut Py_buffer, arg3: c_int) -> c_int;
-                          arg3: c_int) -> c_int;
+pub type releasebufferproc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut Py_buffer);
-pub type releasebufferproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut Py_buffer);
 
 // flags:
-pub const PyBUF_SIMPLE : c_int = 0;
+pub const PyBUF_SIMPLE: c_int = 0;
-pub const PyBUF_WRITABLE : c_int = 0x0001;
+pub const PyBUF_WRITABLE: c_int = 0x0001;
-pub const PyBUF_FORMAT : c_int = 0x0004;
+pub const PyBUF_FORMAT: c_int = 0x0004;
-pub const PyBUF_ND : c_int = 0x0008;
+pub const PyBUF_ND: c_int = 0x0008;
-pub const PyBUF_STRIDES : c_int = (0x0010 | PyBUF_ND);
+pub const PyBUF_STRIDES: c_int = (0x0010 | PyBUF_ND);
-pub const PyBUF_C_CONTIGUOUS : c_int = (0x0020 | PyBUF_STRIDES);
+pub const PyBUF_C_CONTIGUOUS: c_int = (0x0020 | PyBUF_STRIDES);
-pub const PyBUF_F_CONTIGUOUS : c_int = (0x0040 | PyBUF_STRIDES);
+pub const PyBUF_F_CONTIGUOUS: c_int = (0x0040 | PyBUF_STRIDES);
-pub const PyBUF_ANY_CONTIGUOUS : c_int = (0x0080 | PyBUF_STRIDES);
+pub const PyBUF_ANY_CONTIGUOUS: c_int = (0x0080 | PyBUF_STRIDES);
-pub const PyBUF_INDIRECT : c_int = (0x0100 | PyBUF_STRIDES);
+pub const PyBUF_INDIRECT: c_int = (0x0100 | PyBUF_STRIDES);
 
-pub const PyBUF_CONTIG : c_int = (PyBUF_ND | PyBUF_WRITABLE);
+pub const PyBUF_CONTIG: c_int = (PyBUF_ND | PyBUF_WRITABLE);
-pub const PyBUF_CONTIG_RO : c_int = (PyBUF_ND);
+pub const PyBUF_CONTIG_RO: c_int = (PyBUF_ND);
 
-pub const PyBUF_STRIDED : c_int = (PyBUF_STRIDES | PyBUF_WRITABLE);
+pub const PyBUF_STRIDED: c_int = (PyBUF_STRIDES | PyBUF_WRITABLE);
-pub const PyBUF_STRIDED_RO : c_int = (PyBUF_STRIDES);
+pub const PyBUF_STRIDED_RO: c_int = (PyBUF_STRIDES);
 
-pub const PyBUF_RECORDS : c_int = (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT);
+pub const PyBUF_RECORDS: c_int = (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT);
-pub const PyBUF_RECORDS_RO : c_int = (PyBUF_STRIDES | PyBUF_FORMAT);
+pub const PyBUF_RECORDS_RO: c_int = (PyBUF_STRIDES | PyBUF_FORMAT);
 
-pub const PyBUF_FULL : c_int = (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT);
+pub const PyBUF_FULL: c_int = (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT);
-pub const PyBUF_FULL_RO : c_int = (PyBUF_INDIRECT | PyBUF_FORMAT);
+pub const PyBUF_FULL_RO: c_int = (PyBUF_INDIRECT | PyBUF_FORMAT);
 
 // buffertype:
-pub const PyBUF_READ : c_int = 0x100;
+pub const PyBUF_READ: c_int = 0x100;
-pub const PyBUF_WRITE : c_int = 0x200;
+pub const PyBUF_WRITE: c_int = 0x200;
-pub const PyBUF_SHADOW : c_int = 0x400;
+pub const PyBUF_SHADOW: c_int = 0x400;
 
-
+pub type objobjproc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
-pub type objobjproc =
+pub type visitproc = unsafe extern "C" fn(object: *mut PyObject, arg: *mut c_void) -> c_int;
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
-pub type visitproc =
-    unsafe extern "C" fn (object: *mut PyObject, arg: *mut c_void) -> c_int;
 pub type traverseproc =
-    unsafe extern "C" fn (slf: *mut PyObject, visit: visitproc, arg: *mut c_void) -> c_int;
+    unsafe extern "C" fn(slf: *mut PyObject, visit: visitproc, arg: *mut c_void) -> c_int;
-
 
 #[repr(C)]
 #[derive(Copy)]
@@ -212,10 +199,13 @@ pub struct PyNumberMethods {
 }
 
 impl Clone for PyNumberMethods {
-    #[inline] fn clone(&self) -> PyNumberMethods { *self }
+    #[inline]
+    fn clone(&self) -> PyNumberMethods {
+        *self
+    }
 }
 
-pub const PyNumberMethods_INIT : PyNumberMethods = PyNumberMethods {
+pub const PyNumberMethods_INIT: PyNumberMethods = PyNumberMethods {
     nb_add: None,
     nb_subtract: None,
     nb_multiply: None,
@@ -273,10 +263,13 @@ pub struct PySequenceMethods {
 }
 
 impl Clone for PySequenceMethods {
-    #[inline] fn clone(&self) -> PySequenceMethods { *self }
+    #[inline]
+    fn clone(&self) -> PySequenceMethods {
+        *self
+    }
 }
 
-pub const PySequenceMethods_INIT : PySequenceMethods = PySequenceMethods {
+pub const PySequenceMethods_INIT: PySequenceMethods = PySequenceMethods {
     sq_length: None,
     sq_concat: None,
     sq_repeat: None,
@@ -298,10 +291,13 @@ pub struct PyMappingMethods {
 }
 
 impl Clone for PyMappingMethods {
-    #[inline] fn clone(&self) -> PyMappingMethods { *self }
+    #[inline]
+    fn clone(&self) -> PyMappingMethods {
+        *self
+    }
 }
 
-pub const PyMappingMethods_INIT : PyMappingMethods = PyMappingMethods {
+pub const PyMappingMethods_INIT: PyMappingMethods = PyMappingMethods {
     mp_length: None,
     mp_subscript: None,
     mp_ass_subscript: None,
@@ -319,10 +315,13 @@ pub struct PyBufferProcs {
 }
 
 impl Clone for PyBufferProcs {
-    #[inline] fn clone(&self) -> PyBufferProcs { *self }
+    #[inline]
+    fn clone(&self) -> PyBufferProcs {
+        *self
+    }
 }
 
-pub const PyBufferProcs_INIT : PyBufferProcs = PyBufferProcs {
+pub const PyBufferProcs_INIT: PyBufferProcs = PyBufferProcs {
     bf_getreadbuffer: None,
     bf_getwritebuffer: None,
     bf_getsegcount: None,
@@ -331,49 +330,37 @@ pub const PyBufferProcs_INIT : PyBufferProcs = PyBufferProcs {
     bf_releasebuffer: None,
 };
 
-pub type freefunc =
+pub type freefunc = unsafe extern "C" fn(arg1: *mut c_void);
-    unsafe extern "C" fn(arg1: *mut c_void);
+pub type destructor = unsafe extern "C" fn(arg1: *mut PyObject);
-pub type destructor =
-    unsafe extern "C" fn(arg1: *mut PyObject);
 pub type printfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut FILE, arg3: c_int) -> c_int;
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut FILE, arg3: c_int) -> c_int;
 pub type getattrfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut c_char) -> *mut PyObject;
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut c_char) -> *mut PyObject;
 pub type getattrofunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
 pub type setattrfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut c_char,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut c_char, arg3: *mut PyObject) -> c_int;
-                          arg3: *mut PyObject) -> c_int;
 pub type setattrofunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int;
-                          arg3: *mut PyObject) -> c_int;
+pub type cmpfunc = unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
-pub type cmpfunc =
+pub type reprfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
+pub type hashfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> Py_hash_t;
-pub type reprfunc =
-    unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
-pub type hashfunc =
-    unsafe extern "C" fn(arg1: *mut PyObject) -> Py_hash_t;
 pub type richcmpfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int) -> *mut PyObject;
-                          arg2: *mut PyObject, arg3: c_int) -> *mut PyObject;
+pub type getiterfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
-pub type getiterfunc =
+pub type iternextfunc = unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
-    unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
-pub type iternextfunc =
-    unsafe extern "C" fn(arg1: *mut PyObject) -> *mut PyObject;
 pub type descrgetfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject)
-                          arg3: *mut PyObject) -> *mut PyObject;
+        -> *mut PyObject;
 pub type descrsetfunc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int;
-                          arg3: *mut PyObject) -> c_int;
 pub type initproc =
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyObject,
+    unsafe extern "C" fn(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject) -> c_int;
-                          arg3: *mut PyObject) -> c_int;
 pub type newfunc =
-    unsafe extern "C" fn (arg1: *mut PyTypeObject,
+    unsafe extern "C" fn(arg1: *mut PyTypeObject, arg2: *mut PyObject, arg3: *mut PyObject)
-                          arg2: *mut PyObject, arg3: *mut PyObject) -> *mut PyObject;
+        -> *mut PyObject;
 pub type allocfunc =
-    unsafe extern "C" fn (arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject;
+    unsafe extern "C" fn(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyObject;
 
 #[repr(C)]
 #[derive(Copy)]
@@ -430,11 +417,14 @@ pub struct PyTypeObject {
 }
 
 impl Clone for PyTypeObject {
-    #[inline] fn clone(&self) -> PyTypeObject { *self }
+    #[inline]
+    fn clone(&self) -> PyTypeObject {
+        *self
+    }
 }
 
-#[cfg(py_sys_config="Py_TRACE_REFS")]
+#[cfg(py_sys_config = "Py_TRACE_REFS")]
-pub const PyTypeObject_INIT : PyTypeObject = PyTypeObject {
+pub const PyTypeObject_INIT: PyTypeObject = PyTypeObject {
     _ob_next: ::std::ptr::null_mut(),
     _ob_prev: ::std::ptr::null_mut(),
     ob_refcnt: 1,
@@ -488,8 +478,8 @@ pub const PyTypeObject_INIT : PyTypeObject = PyTypeObject {
     tp_version_tag: 0,
 };
 
-#[cfg(not(py_sys_config="Py_TRACE_REFS"))]
+#[cfg(not(py_sys_config = "Py_TRACE_REFS"))]
-pub const PyTypeObject_INIT : PyTypeObject = PyTypeObject {
+pub const PyTypeObject_INIT: PyTypeObject = PyTypeObject {
     ob_refcnt: 1,
     ob_type: ::std::ptr::null_mut(),
     ob_size: 0,
@@ -554,17 +544,23 @@ pub struct PyHeapTypeObject {
 }
 
 impl Clone for PyHeapTypeObject {
-    #[inline] fn clone(&self) -> PyHeapTypeObject { *self }
+    #[inline]
+    fn clone(&self) -> PyHeapTypeObject {
+        *self
+    }
 }
 
 // access macro to the members which are floating "behind" the object
 #[inline]
-pub unsafe fn PyHeapType_GET_MEMBERS(etype: *mut PyHeapTypeObject) -> *mut ffi2::structmember::PyMemberDef {
+pub unsafe fn PyHeapType_GET_MEMBERS(
+    etype: *mut PyHeapTypeObject,
+) -> *mut ffi2::structmember::PyMemberDef {
     let basicsize = (*Py_TYPE(etype as *mut PyObject)).tp_basicsize;
     (etype as *mut u8).offset(basicsize as isize) as *mut ffi2::structmember::PyMemberDef
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyType_IsSubtype(a: *mut PyTypeObject, b: *mut PyTypeObject) -> c_int;
 }
 
@@ -573,7 +569,8 @@ pub unsafe fn PyObject_TypeCheck(ob: *mut PyObject, tp: *mut PyTypeObject) -> c_
     (Py_TYPE(ob) == tp || PyType_IsSubtype(Py_TYPE(ob), tp) != 0) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyType_Type: PyTypeObject;
     pub static mut PyBaseObject_Type: PyTypeObject;
     pub static mut PySuper_Type: PyTypeObject;
@@ -589,20 +586,25 @@ pub unsafe fn PyType_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == (&mut PyType_Type as *mut _)) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyType_Ready(t: *mut PyTypeObject) -> c_int;
     pub fn PyType_GenericAlloc(t: *mut PyTypeObject, nitems: Py_ssize_t) -> *mut PyObject;
-    pub fn PyType_GenericNew(t: *mut PyTypeObject, args: *mut PyObject,
+    pub fn PyType_GenericNew(
-                             kwds: *mut PyObject) -> *mut PyObject;
+        t: *mut PyTypeObject,
+        args: *mut PyObject,
+        kwds: *mut PyObject,
+    ) -> *mut PyObject;
     fn _PyType_Lookup(arg1: *mut PyTypeObject, arg2: *mut PyObject) -> *mut PyObject;
-    fn _PyObject_LookupSpecial(arg1: *mut PyObject,
+    fn _PyObject_LookupSpecial(
-                               arg2: *mut c_char,
+        arg1: *mut PyObject,
-                               arg3: *mut *mut PyObject) -> *mut PyObject;
+        arg2: *mut c_char,
+        arg3: *mut *mut PyObject,
+    ) -> *mut PyObject;
     pub fn PyType_ClearCache() -> c_uint;
     pub fn PyType_Modified(t: *mut PyTypeObject);
 
-    pub fn PyObject_Print(o: *mut PyObject, fp: *mut FILE,
+    pub fn PyObject_Print(o: *mut PyObject, fp: *mut FILE, flags: c_int) -> c_int;
-                          flags: c_int) -> c_int;
     fn _PyObject_Dump(o: *mut PyObject);
     pub fn PyObject_Repr(o: *mut PyObject) -> *mut PyObject;
     fn _PyObject_Str(o: *mut PyObject) -> *mut PyObject;
@@ -614,48 +616,58 @@ pub unsafe fn PyObject_Bytes(o: *mut PyObject) -> *mut PyObject {
     PyObject_Str(o)
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    #[cfg(py_sys_config="Py_USING_UNICODE")]
+extern "C" {
+    #[cfg(py_sys_config = "Py_USING_UNICODE")]
     pub fn PyObject_Unicode(o: *mut PyObject) -> *mut PyObject;
 
     pub fn PyObject_Compare(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
-    pub fn PyObject_RichCompare(arg1: *mut PyObject, arg2: *mut PyObject,
+    pub fn PyObject_RichCompare(
-                                arg3: c_int) -> *mut PyObject;
+        arg1: *mut PyObject,
-    pub fn PyObject_RichCompareBool(arg1: *mut PyObject, arg2: *mut PyObject,
+        arg2: *mut PyObject,
-                                    arg3: c_int) -> c_int;
+        arg3: c_int,
-    pub fn PyObject_GetAttrString(arg1: *mut PyObject,
+    ) -> *mut PyObject;
-                                  arg2: *const c_char) -> *mut PyObject;
+    pub fn PyObject_RichCompareBool(arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int)
-    pub fn PyObject_SetAttrString(arg1: *mut PyObject,
+        -> c_int;
-                                  arg2: *const c_char,
+    pub fn PyObject_GetAttrString(arg1: *mut PyObject, arg2: *const c_char) -> *mut PyObject;
-                                  arg3: *mut PyObject) -> c_int;
+    pub fn PyObject_SetAttrString(
-    pub fn PyObject_HasAttrString(arg1: *mut PyObject,
+        arg1: *mut PyObject,
-                                  arg2: *const c_char) -> c_int;
+        arg2: *const c_char,
+        arg3: *mut PyObject,
+    ) -> c_int;
+    pub fn PyObject_HasAttrString(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
     pub fn PyObject_GetAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
-    pub fn PyObject_SetAttr(arg1: *mut PyObject, arg2: *mut PyObject,
+    pub fn PyObject_SetAttr(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject)
-                            arg3: *mut PyObject) -> c_int;
+        -> c_int;
     pub fn PyObject_HasAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
     fn _PyObject_GetDictPtr(arg1: *mut PyObject) -> *mut *mut PyObject;
     pub fn PyObject_SelfIter(arg1: *mut PyObject) -> *mut PyObject;
     pub fn PyObject_GenericGetAttr(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
-    pub fn PyObject_GenericSetAttr(arg1: *mut PyObject, arg2: *mut PyObject,
+    pub fn PyObject_GenericSetAttr(
-                                   arg3: *mut PyObject) -> c_int;
+        arg1: *mut PyObject,
+        arg2: *mut PyObject,
+        arg3: *mut PyObject,
+    ) -> c_int;
     pub fn PyObject_Hash(arg1: *mut PyObject) -> Py_hash_t;
     pub fn PyObject_HashNotImplemented(arg1: *mut PyObject) -> Py_hash_t;
     pub fn PyObject_IsTrue(arg1: *mut PyObject) -> c_int;
     pub fn PyObject_Not(arg1: *mut PyObject) -> c_int;
     pub fn PyCallable_Check(arg1: *mut PyObject) -> c_int;
     pub fn PyNumber_Coerce(arg1: *mut *mut PyObject, arg2: *mut *mut PyObject) -> c_int;
-    pub fn PyNumber_CoerceEx(arg1: *mut *mut PyObject,
+    pub fn PyNumber_CoerceEx(arg1: *mut *mut PyObject, arg2: *mut *mut PyObject) -> c_int;
-                             arg2: *mut *mut PyObject) -> c_int;
     pub fn PyObject_ClearWeakRefs(arg1: *mut PyObject);
     fn _PyObject_SlotCompare(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
-    fn _PyObject_GenericGetAttrWithDict(arg1: *mut PyObject,
+    fn _PyObject_GenericGetAttrWithDict(
-                                        arg2: *mut PyObject,
+        arg1: *mut PyObject,
-                                        arg3: *mut PyObject) -> *mut PyObject;
+        arg2: *mut PyObject,
-    fn _PyObject_GenericSetAttrWithDict(arg1: *mut PyObject,
+        arg3: *mut PyObject,
-                                        arg2: *mut PyObject,
+    ) -> *mut PyObject;
-                                        arg3: *mut PyObject,
+    fn _PyObject_GenericSetAttrWithDict(
-                                        arg4: *mut PyObject) -> c_int;
+        arg1: *mut PyObject,
+        arg2: *mut PyObject,
+        arg3: *mut PyObject,
+        arg4: *mut PyObject,
+    ) -> c_int;
     pub fn PyObject_Dir(arg1: *mut PyObject) -> *mut PyObject;
     pub fn Py_ReprEnter(arg1: *mut PyObject) -> c_int;
     pub fn Py_ReprLeave(arg1: *mut PyObject);
@@ -664,100 +676,99 @@ pub unsafe fn PyObject_Bytes(o: *mut PyObject) -> *mut PyObject {
 }
 
 // Flag bits for printing:
-pub const Py_PRINT_RAW : c_int = 1;       // No string quotes etc.
+pub const Py_PRINT_RAW: c_int = 1; // No string quotes etc.
 
 // PyBufferProcs contains bf_getcharbuffer
-pub const Py_TPFLAGS_HAVE_GETCHARBUFFER : c_long = (1<<0);
+pub const Py_TPFLAGS_HAVE_GETCHARBUFFER: c_long = (1 << 0);
 
 // PySequenceMethods contains sq_contains
-pub const Py_TPFLAGS_HAVE_SEQUENCE_IN : c_long = (1<<1);
+pub const Py_TPFLAGS_HAVE_SEQUENCE_IN: c_long = (1 << 1);
 
 // PySequenceMethods and PyNumberMethods contain in-place operators
-pub const Py_TPFLAGS_HAVE_INPLACEOPS : c_long = (1<<3);
+pub const Py_TPFLAGS_HAVE_INPLACEOPS: c_long = (1 << 3);
 
 // PyNumberMethods do their own coercion
-pub const Py_TPFLAGS_CHECKTYPES : c_long = (1<<4);
+pub const Py_TPFLAGS_CHECKTYPES: c_long = (1 << 4);
 
 // tp_richcompare is defined
-pub const Py_TPFLAGS_HAVE_RICHCOMPARE : c_long = (1<<5);
+pub const Py_TPFLAGS_HAVE_RICHCOMPARE: c_long = (1 << 5);
 
 // Objects which are weakly referencable if their tp_weaklistoffset is >0
-pub const Py_TPFLAGS_HAVE_WEAKREFS : c_long = (1<<6);
+pub const Py_TPFLAGS_HAVE_WEAKREFS: c_long = (1 << 6);
 
 // tp_iter is defined
-pub const Py_TPFLAGS_HAVE_ITER : c_long = (1<<7);
+pub const Py_TPFLAGS_HAVE_ITER: c_long = (1 << 7);
 
 // New members introduced by Python 2.2 exist
-pub const Py_TPFLAGS_HAVE_CLASS : c_long = (1<<8);
+pub const Py_TPFLAGS_HAVE_CLASS: c_long = (1 << 8);
 
 // Set if the type object is dynamically allocated
-pub const Py_TPFLAGS_HEAPTYPE : c_long = (1<<9);
+pub const Py_TPFLAGS_HEAPTYPE: c_long = (1 << 9);
 
 // Set if the type allows subclassing
-pub const Py_TPFLAGS_BASETYPE : c_long = (1<<10);
+pub const Py_TPFLAGS_BASETYPE: c_long = (1 << 10);
 
 // Set if the type is 'ready' -- fully initialized
-pub const Py_TPFLAGS_READY : c_long = (1<<12);
+pub const Py_TPFLAGS_READY: c_long = (1 << 12);
 
 // Set while the type is being 'readied', to prevent recursive ready calls
-pub const Py_TPFLAGS_READYING : c_long = (1<<13);
+pub const Py_TPFLAGS_READYING: c_long = (1 << 13);
 
 // Objects support garbage collection (see objimp.h)
-pub const Py_TPFLAGS_HAVE_GC : c_long = (1<<14);
+pub const Py_TPFLAGS_HAVE_GC: c_long = (1 << 14);
 
 // Two bits are preserved for Stackless Python, next after this is 17.
-const Py_TPFLAGS_HAVE_STACKLESS_EXTENSION : c_long = 0;
+const Py_TPFLAGS_HAVE_STACKLESS_EXTENSION: c_long = 0;
 
 // Objects support nb_index in PyNumberMethods
-pub const Py_TPFLAGS_HAVE_INDEX : c_long = (1<<17);
+pub const Py_TPFLAGS_HAVE_INDEX: c_long = (1 << 17);
 
 // Objects support type attribute cache
-pub const Py_TPFLAGS_HAVE_VERSION_TAG  : c_long = (1<<18);
+pub const Py_TPFLAGS_HAVE_VERSION_TAG: c_long = (1 << 18);
-pub const Py_TPFLAGS_VALID_VERSION_TAG : c_long = (1<<19);
+pub const Py_TPFLAGS_VALID_VERSION_TAG: c_long = (1 << 19);
 
 /* Type is abstract and cannot be instantiated */
-pub const Py_TPFLAGS_IS_ABSTRACT : c_long = (1<<20);
+pub const Py_TPFLAGS_IS_ABSTRACT: c_long = (1 << 20);
 
 /* Has the new buffer protocol */
-pub const Py_TPFLAGS_HAVE_NEWBUFFER : c_long = (1<<21);
+pub const Py_TPFLAGS_HAVE_NEWBUFFER: c_long = (1 << 21);
 
 /* These flags are used to determine if a type is a subclass. */
-pub const Py_TPFLAGS_INT_SUBCLASS         : c_long = (1<<23);
+pub const Py_TPFLAGS_INT_SUBCLASS: c_long = (1 << 23);
-pub const Py_TPFLAGS_LONG_SUBCLASS        : c_long = (1<<24);
+pub const Py_TPFLAGS_LONG_SUBCLASS: c_long = (1 << 24);
-pub const Py_TPFLAGS_LIST_SUBCLASS        : c_long = (1<<25);
+pub const Py_TPFLAGS_LIST_SUBCLASS: c_long = (1 << 25);
-pub const Py_TPFLAGS_TUPLE_SUBCLASS       : c_long = (1<<26);
+pub const Py_TPFLAGS_TUPLE_SUBCLASS: c_long = (1 << 26);
-pub const Py_TPFLAGS_STRING_SUBCLASS      : c_long = (1<<27);
+pub const Py_TPFLAGS_STRING_SUBCLASS: c_long = (1 << 27);
-pub const Py_TPFLAGS_UNICODE_SUBCLASS     : c_long = (1<<28);
+pub const Py_TPFLAGS_UNICODE_SUBCLASS: c_long = (1 << 28);
-pub const Py_TPFLAGS_DICT_SUBCLASS        : c_long = (1<<29);
+pub const Py_TPFLAGS_DICT_SUBCLASS: c_long = (1 << 29);
-pub const Py_TPFLAGS_BASE_EXC_SUBCLASS    : c_long = (1<<30);
+pub const Py_TPFLAGS_BASE_EXC_SUBCLASS: c_long = (1 << 30);
-pub const Py_TPFLAGS_TYPE_SUBCLASS        : c_long = (1<<31);
+pub const Py_TPFLAGS_TYPE_SUBCLASS: c_long = (1 << 31);
 
-pub const Py_TPFLAGS_DEFAULT : c_long = (
+pub const Py_TPFLAGS_DEFAULT: c_long = (Py_TPFLAGS_HAVE_GETCHARBUFFER
-                 Py_TPFLAGS_HAVE_GETCHARBUFFER |
+    | Py_TPFLAGS_HAVE_SEQUENCE_IN
-                 Py_TPFLAGS_HAVE_SEQUENCE_IN |
+    | Py_TPFLAGS_HAVE_INPLACEOPS
-                 Py_TPFLAGS_HAVE_INPLACEOPS |
+    | Py_TPFLAGS_HAVE_RICHCOMPARE
-                 Py_TPFLAGS_HAVE_RICHCOMPARE |
+    | Py_TPFLAGS_HAVE_WEAKREFS
-                 Py_TPFLAGS_HAVE_WEAKREFS |
+    | Py_TPFLAGS_HAVE_ITER
-                 Py_TPFLAGS_HAVE_ITER |
+    | Py_TPFLAGS_HAVE_CLASS
-                 Py_TPFLAGS_HAVE_CLASS |
+    | Py_TPFLAGS_HAVE_STACKLESS_EXTENSION
-                 Py_TPFLAGS_HAVE_STACKLESS_EXTENSION |
+    | Py_TPFLAGS_HAVE_INDEX
-                 Py_TPFLAGS_HAVE_INDEX |
+    | 0);
-                 0);
 
 #[inline(always)]
-pub unsafe fn PyType_HasFeature(t : *mut PyTypeObject, f : c_long) -> c_int {
+pub unsafe fn PyType_HasFeature(t: *mut PyTypeObject, f: c_long) -> c_int {
     (((*t).tp_flags & f) != 0) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyType_FastSubclass(t : *mut PyTypeObject, f : c_long) -> c_int {
+pub unsafe fn PyType_FastSubclass(t: *mut PyTypeObject, f: c_long) -> c_int {
     PyType_HasFeature(t, f)
 }
 
 // Reference counting macros.
 #[inline(always)]
-pub unsafe fn Py_INCREF(op : *mut PyObject) {
+pub unsafe fn Py_INCREF(op: *mut PyObject) {
-    if cfg!(py_sys_config="Py_REF_DEBUG") {
+    if cfg!(py_sys_config = "Py_REF_DEBUG") {
         Py_IncRef(op)
     } else {
         (*op).ob_refcnt += 1
@@ -766,7 +777,7 @@ pub unsafe fn Py_INCREF(op : *mut PyObject) {
 
 #[inline(always)]
 pub unsafe fn Py_DECREF(op: *mut PyObject) {
-    if cfg!(py_sys_config="Py_REF_DEBUG") || cfg!(py_sys_config="COUNT_ALLOCS") {
+    if cfg!(py_sys_config = "Py_REF_DEBUG") || cfg!(py_sys_config = "COUNT_ALLOCS") {
         Py_DecRef(op)
     } else {
         (*op).ob_refcnt -= 1;
@@ -786,20 +797,21 @@ pub unsafe fn Py_CLEAR(op: &mut *mut PyObject) {
 }
 
 #[inline(always)]
-pub unsafe fn Py_XINCREF(op : *mut PyObject) {
+pub unsafe fn Py_XINCREF(op: *mut PyObject) {
     if !op.is_null() {
         Py_INCREF(op)
     }
 }
 
 #[inline(always)]
-pub unsafe fn Py_XDECREF(op : *mut PyObject) {
+pub unsafe fn Py_XDECREF(op: *mut PyObject) {
     if !op.is_null() {
         Py_DECREF(op)
     }
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn Py_IncRef(o: *mut PyObject);
     pub fn Py_DecRef(o: *mut PyObject);
 
@@ -818,12 +830,12 @@ pub unsafe fn Py_NotImplemented() -> *mut PyObject {
 }
 
 /* Rich comparison opcodes */
-pub const Py_LT : c_int = 0;
+pub const Py_LT: c_int = 0;
-pub const Py_LE : c_int = 1;
+pub const Py_LE: c_int = 1;
-pub const Py_EQ : c_int = 2;
+pub const Py_EQ: c_int = 2;
-pub const Py_NE : c_int = 3;
+pub const Py_NE: c_int = 3;
-pub const Py_GT : c_int = 4;
+pub const Py_GT: c_int = 4;
-pub const Py_GE : c_int = 5;
+pub const Py_GE: c_int = 5;
 
 #[inline]
 pub fn PyObject_Check(_arg1: *mut PyObject) -> c_int {
@@ -835,15 +847,16 @@ pub fn PySuper_Check(_arg1: *mut PyObject) -> c_int {
     0
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     fn _PyTrash_thread_deposit_object(o: *mut PyObject);
     fn _PyTrash_thread_destroy_chain();
 }
 
-pub const PyTrash_UNWIND_LEVEL : c_int = 50;
+pub const PyTrash_UNWIND_LEVEL: c_int = 50;
 
 #[inline(always)]
-pub unsafe fn Py_TRASHCAN<F : FnOnce() -> ()>(op: *mut PyObject, body: F) {
+pub unsafe fn Py_TRASHCAN<F: FnOnce() -> ()>(op: *mut PyObject, body: F) {
     let tstate = ffi2::pystate::PyThreadState_GET();
     if tstate.is_null() || (*tstate).trash_delete_nesting < PyTrash_UNWIND_LEVEL {
         if !tstate.is_null() {
@@ -860,4 +873,3 @@ pub unsafe fn Py_TRASHCAN<F : FnOnce() -> ()>(op: *mut PyObject, body: F) {
         _PyTrash_thread_deposit_object(op)
     }
 }
-

src/ffi2/objectabstract.rs

@@ -1,8 +1,8 @@
-use std::ptr;
-use std::os::raw::{c_void, c_char, c_int};
 use ffi2;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
 
 #[inline]
 pub unsafe fn PyObject_DelAttrString(o: *mut PyObject, attr_name: *const c_char) -> c_int {
@@ -14,241 +14,224 @@ pub unsafe fn PyObject_DelAttr(o: *mut PyObject, attr_name: *mut PyObject) -> c_
     PyObject_SetAttr(o, attr_name, ptr::null_mut())
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyObject_Cmp(o1: *mut PyObject, o2: *mut PyObject,
+extern "C" {
-                        result: *mut c_int) -> c_int;
+    pub fn PyObject_Cmp(o1: *mut PyObject, o2: *mut PyObject, result: *mut c_int) -> c_int;
-    pub fn PyObject_Call(callable_object: *mut PyObject, args: *mut PyObject,
+    pub fn PyObject_Call(
-                         kw: *mut PyObject) -> *mut PyObject;
+        callable_object: *mut PyObject,
-    pub fn PyObject_CallObject(callable_object: *mut PyObject,
+        args: *mut PyObject,
-                               args: *mut PyObject) -> *mut PyObject;
+        kw: *mut PyObject,
-    pub fn PyObject_CallFunction(callable_object: *mut PyObject,
+    ) -> *mut PyObject;
-                                 format: *mut c_char, ...)
+    pub fn PyObject_CallObject(
-     -> *mut PyObject;
+        callable_object: *mut PyObject,
-    pub fn PyObject_CallMethod(o: *mut PyObject, m: *mut c_char,
+        args: *mut PyObject,
-                               format: *mut c_char, ...)
+    ) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyObject_CallFunction(
-    fn _PyObject_CallFunction_SizeT(callable: *mut PyObject,
+        callable_object: *mut PyObject,
-                                        format: *mut c_char, ...)
+        format: *mut c_char,
-     -> *mut PyObject;
+        ...
-    fn _PyObject_CallMethod_SizeT(o: *mut PyObject,
+    ) -> *mut PyObject;
-                                      name: *mut c_char,
+    pub fn PyObject_CallMethod(
-                                      format: *mut c_char, ...)
+        o: *mut PyObject,
-     -> *mut PyObject;
+        m: *mut c_char,
-    pub fn PyObject_CallFunctionObjArgs(callable: *mut PyObject, ...)
+        format: *mut c_char,
-     -> *mut PyObject;
+        ...
-    pub fn PyObject_CallMethodObjArgs(o: *mut PyObject, m: *mut PyObject, ...)
+    ) -> *mut PyObject;
-     -> *mut PyObject;
+    fn _PyObject_CallFunction_SizeT(
+        callable: *mut PyObject,
+        format: *mut c_char,
+        ...
+    ) -> *mut PyObject;
+    fn _PyObject_CallMethod_SizeT(
+        o: *mut PyObject,
+        name: *mut c_char,
+        format: *mut c_char,
+        ...
+    ) -> *mut PyObject;
+    pub fn PyObject_CallFunctionObjArgs(callable: *mut PyObject, ...) -> *mut PyObject;
+    pub fn PyObject_CallMethodObjArgs(o: *mut PyObject, m: *mut PyObject, ...) -> *mut PyObject;
     pub fn PyObject_Type(o: *mut PyObject) -> *mut PyObject;
     pub fn PyObject_Size(o: *mut PyObject) -> Py_ssize_t;
-    pub fn _PyObject_LengthHint(o: *mut PyObject, arg1: Py_ssize_t)
+    pub fn _PyObject_LengthHint(o: *mut PyObject, arg1: Py_ssize_t) -> Py_ssize_t;
-     -> Py_ssize_t;
+    pub fn PyObject_GetItem(o: *mut PyObject, key: *mut PyObject) -> *mut PyObject;
-    pub fn PyObject_GetItem(o: *mut PyObject, key: *mut PyObject)
+    pub fn PyObject_SetItem(o: *mut PyObject, key: *mut PyObject, v: *mut PyObject) -> c_int;
-     -> *mut PyObject;
+    pub fn PyObject_DelItemString(o: *mut PyObject, key: *mut c_char) -> c_int;
-    pub fn PyObject_SetItem(o: *mut PyObject, key: *mut PyObject,
+    pub fn PyObject_DelItem(o: *mut PyObject, key: *mut PyObject) -> c_int;
-                            v: *mut PyObject) -> c_int;
+    pub fn PyObject_AsCharBuffer(
-    pub fn PyObject_DelItemString(o: *mut PyObject, key: *mut c_char)
+        obj: *mut PyObject,
-     -> c_int;
+        buffer: *mut *const c_char,
-    pub fn PyObject_DelItem(o: *mut PyObject, key: *mut PyObject)
+        buffer_len: *mut Py_ssize_t,
-     -> c_int;
+    ) -> c_int;
-    pub fn PyObject_AsCharBuffer(obj: *mut PyObject,
-                                 buffer: *mut *const c_char,
-                                 buffer_len: *mut Py_ssize_t)
-     -> c_int;
     pub fn PyObject_CheckReadBuffer(obj: *mut PyObject) -> c_int;
-    pub fn PyObject_AsReadBuffer(obj: *mut PyObject,
+    pub fn PyObject_AsReadBuffer(
-                                 buffer: *mut *const c_void,
+        obj: *mut PyObject,
-                                 buffer_len: *mut Py_ssize_t)
+        buffer: *mut *const c_void,
-     -> c_int;
+        buffer_len: *mut Py_ssize_t,
-    pub fn PyObject_AsWriteBuffer(obj: *mut PyObject,
+    ) -> c_int;
-                                  buffer: *mut *mut c_void,
+    pub fn PyObject_AsWriteBuffer(
-                                  buffer_len: *mut Py_ssize_t)
+        obj: *mut PyObject,
-     -> c_int;
+        buffer: *mut *mut c_void,
+        buffer_len: *mut Py_ssize_t,
+    ) -> c_int;
 
-    pub fn PyObject_GetBuffer(obj: *mut PyObject, view: *mut Py_buffer,
+    pub fn PyObject_GetBuffer(obj: *mut PyObject, view: *mut Py_buffer, flags: c_int) -> c_int;
-                              flags: c_int) -> c_int;
 
-    pub fn PyBuffer_GetPointer(view: *mut Py_buffer, indices: *mut Py_ssize_t)
+    pub fn PyBuffer_GetPointer(view: *mut Py_buffer, indices: *mut Py_ssize_t) -> *mut c_void;
-     -> *mut c_void;
+    pub fn PyBuffer_ToContiguous(
-    pub fn PyBuffer_ToContiguous(buf: *mut c_void,
+        buf: *mut c_void,
-                                 view: *mut Py_buffer, len: Py_ssize_t,
+        view: *mut Py_buffer,
-                                 fort: c_char) -> c_int;
+        len: Py_ssize_t,
-    pub fn PyBuffer_FromContiguous(view: *mut Py_buffer,
+        fort: c_char,
-                                   buf: *mut c_void, len: Py_ssize_t,
+    ) -> c_int;
-                                   fort: c_char) -> c_int;
+    pub fn PyBuffer_FromContiguous(
-    pub fn PyObject_CopyData(dest: *mut PyObject, src: *mut PyObject)
+        view: *mut Py_buffer,
-     -> c_int;
+        buf: *mut c_void,
-    pub fn PyBuffer_IsContiguous(view: *mut Py_buffer, fort: c_char)
+        len: Py_ssize_t,
-     -> c_int;
+        fort: c_char,
-    pub fn PyBuffer_FillContiguousStrides(ndims: c_int,
+    ) -> c_int;
-                                          shape: *mut Py_ssize_t,
+    pub fn PyObject_CopyData(dest: *mut PyObject, src: *mut PyObject) -> c_int;
-                                          strides: *mut Py_ssize_t,
+    pub fn PyBuffer_IsContiguous(view: *mut Py_buffer, fort: c_char) -> c_int;
-                                          itemsize: c_int,
+    pub fn PyBuffer_FillContiguousStrides(
-                                          fort: c_char);
+        ndims: c_int,
-    pub fn PyBuffer_FillInfo(view: *mut Py_buffer, o: *mut PyObject,
+        shape: *mut Py_ssize_t,
-                             buf: *mut c_void, len: Py_ssize_t,
+        strides: *mut Py_ssize_t,
-                             readonly: c_int, flags: c_int)
+        itemsize: c_int,
-     -> c_int;
+        fort: c_char,
+    );
+    pub fn PyBuffer_FillInfo(
+        view: *mut Py_buffer,
+        o: *mut PyObject,
+        buf: *mut c_void,
+        len: Py_ssize_t,
+        readonly: c_int,
+        flags: c_int,
+    ) -> c_int;
     pub fn PyBuffer_Release(view: *mut Py_buffer);
-    pub fn PyObject_Format(obj: *mut PyObject, format_spec: *mut PyObject)
+    pub fn PyObject_Format(obj: *mut PyObject, format_spec: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
     pub fn PyObject_GetIter(arg1: *mut PyObject) -> *mut PyObject;
     pub fn PyIter_Next(arg1: *mut PyObject) -> *mut PyObject;
     fn _PyObject_NextNotImplemented(arg1: *mut PyObject) -> *mut PyObject;
 
     pub fn PyNumber_Check(o: *mut PyObject) -> c_int;
-    pub fn PyNumber_Add(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_Add(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_Subtract(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_Subtract(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_Multiply(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_Divide(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_Multiply(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_FloorDivide(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_TrueDivide(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_Divide(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_Remainder(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_Divmod(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_FloorDivide(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_Power(o1: *mut PyObject, o2: *mut PyObject, o3: *mut PyObject)
-     -> *mut PyObject;
+        -> *mut PyObject;
-    pub fn PyNumber_TrueDivide(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyNumber_Remainder(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyNumber_Divmod(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyNumber_Power(o1: *mut PyObject, o2: *mut PyObject,
-                          o3: *mut PyObject) -> *mut PyObject;
     pub fn PyNumber_Negative(o: *mut PyObject) -> *mut PyObject;
     pub fn PyNumber_Positive(o: *mut PyObject) -> *mut PyObject;
     pub fn PyNumber_Absolute(o: *mut PyObject) -> *mut PyObject;
     pub fn PyNumber_Invert(o: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_Lshift(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_Lshift(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_Rshift(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_Rshift(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_And(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_Xor(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_And(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyNumber_Xor(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
     pub fn PyNumber_Or(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
     pub fn PyNumber_Index(o: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_AsSsize_t(o: *mut PyObject, exc: *mut PyObject)
+    pub fn PyNumber_AsSsize_t(o: *mut PyObject, exc: *mut PyObject) -> Py_ssize_t;
-     -> Py_ssize_t;
+    fn _PyNumber_ConvertIntegralToInt(
-    fn _PyNumber_ConvertIntegralToInt(integral: *mut PyObject,
+        integral: *mut PyObject,
-                                          error_format: *const c_char)
+        error_format: *const c_char,
-     -> *mut PyObject;
+    ) -> *mut PyObject;
     pub fn PyNumber_Int(o: *mut PyObject) -> *mut PyObject;
     pub fn PyNumber_Long(o: *mut PyObject) -> *mut PyObject;
     pub fn PyNumber_Float(o: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_InPlaceAdd(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_InPlaceAdd(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_InPlaceSubtract(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_InPlaceSubtract(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_InPlaceMultiply(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_InPlaceDivide(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_InPlaceMultiply(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_InPlaceFloorDivide(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_InPlaceTrueDivide(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_InPlaceDivide(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_InPlaceRemainder(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_InPlacePower(
-    pub fn PyNumber_InPlaceFloorDivide(o1: *mut PyObject, o2: *mut PyObject)
+        o1: *mut PyObject,
-     -> *mut PyObject;
+        o2: *mut PyObject,
-    pub fn PyNumber_InPlaceTrueDivide(o1: *mut PyObject, o2: *mut PyObject)
+        o3: *mut PyObject,
-     -> *mut PyObject;
+    ) -> *mut PyObject;
-    pub fn PyNumber_InPlaceRemainder(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_InPlaceLshift(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_InPlaceRshift(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_InPlacePower(o1: *mut PyObject, o2: *mut PyObject,
+    pub fn PyNumber_InPlaceAnd(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-                                 o3: *mut PyObject) -> *mut PyObject;
+    pub fn PyNumber_InPlaceXor(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-    pub fn PyNumber_InPlaceLshift(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PyNumber_InPlaceOr(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyNumber_ToBase(n: *mut PyObject, base: c_int) -> *mut PyObject;
-    pub fn PyNumber_InPlaceRshift(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyNumber_InPlaceAnd(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyNumber_InPlaceXor(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyNumber_InPlaceOr(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyNumber_ToBase(n: *mut PyObject, base: c_int)
-     -> *mut PyObject;
     pub fn PySequence_Check(o: *mut PyObject) -> c_int;
     pub fn PySequence_Size(o: *mut PyObject) -> Py_ssize_t;
     pub fn PySequence_Length(o: *mut PyObject) -> Py_ssize_t;
-    pub fn PySequence_Concat(o1: *mut PyObject, o2: *mut PyObject)
+    pub fn PySequence_Concat(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PySequence_Repeat(o: *mut PyObject, count: Py_ssize_t) -> *mut PyObject;
-    pub fn PySequence_Repeat(o: *mut PyObject, count: Py_ssize_t)
+    pub fn PySequence_GetItem(o: *mut PyObject, i: Py_ssize_t) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PySequence_GetSlice(o: *mut PyObject, i1: Py_ssize_t, i2: Py_ssize_t) -> *mut PyObject;
-    pub fn PySequence_GetItem(o: *mut PyObject, i: Py_ssize_t)
+    pub fn PySequence_SetItem(o: *mut PyObject, i: Py_ssize_t, v: *mut PyObject) -> c_int;
-     -> *mut PyObject;
+    pub fn PySequence_DelItem(o: *mut PyObject, i: Py_ssize_t) -> c_int;
-    pub fn PySequence_GetSlice(o: *mut PyObject, i1: Py_ssize_t,
+    pub fn PySequence_SetSlice(
-                               i2: Py_ssize_t) -> *mut PyObject;
+        o: *mut PyObject,
-    pub fn PySequence_SetItem(o: *mut PyObject, i: Py_ssize_t,
+        i1: Py_ssize_t,
-                              v: *mut PyObject) -> c_int;
+        i2: Py_ssize_t,
-    pub fn PySequence_DelItem(o: *mut PyObject, i: Py_ssize_t)
+        v: *mut PyObject,
-     -> c_int;
+    ) -> c_int;
-    pub fn PySequence_SetSlice(o: *mut PyObject, i1: Py_ssize_t,
+    pub fn PySequence_DelSlice(o: *mut PyObject, i1: Py_ssize_t, i2: Py_ssize_t) -> c_int;
-                               i2: Py_ssize_t, v: *mut PyObject)
-     -> c_int;
-    pub fn PySequence_DelSlice(o: *mut PyObject, i1: Py_ssize_t,
-                               i2: Py_ssize_t) -> c_int;
     pub fn PySequence_Tuple(o: *mut PyObject) -> *mut PyObject;
     pub fn PySequence_List(o: *mut PyObject) -> *mut PyObject;
-    pub fn PySequence_Fast(o: *mut PyObject, m: *const c_char)
+    pub fn PySequence_Fast(o: *mut PyObject, m: *const c_char) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PySequence_Count(o: *mut PyObject, value: *mut PyObject) -> Py_ssize_t;
-    pub fn PySequence_Count(o: *mut PyObject, value: *mut PyObject)
+    pub fn PySequence_Contains(seq: *mut PyObject, ob: *mut PyObject) -> c_int;
-     -> Py_ssize_t;
+    pub fn _PySequence_IterSearch(
-    pub fn PySequence_Contains(seq: *mut PyObject, ob: *mut PyObject)
+        seq: *mut PyObject,
-     -> c_int;
+        obj: *mut PyObject,
-    pub fn _PySequence_IterSearch(seq: *mut PyObject, obj: *mut PyObject,
+        operation: c_int,
-                                  operation: c_int) -> Py_ssize_t;
+    ) -> Py_ssize_t;
-    pub fn PySequence_In(o: *mut PyObject, value: *mut PyObject)
+    pub fn PySequence_In(o: *mut PyObject, value: *mut PyObject) -> c_int;
-     -> c_int;
+    pub fn PySequence_Index(o: *mut PyObject, value: *mut PyObject) -> Py_ssize_t;
-    pub fn PySequence_Index(o: *mut PyObject, value: *mut PyObject)
+    pub fn PySequence_InPlaceConcat(o1: *mut PyObject, o2: *mut PyObject) -> *mut PyObject;
-     -> Py_ssize_t;
+    pub fn PySequence_InPlaceRepeat(o: *mut PyObject, count: Py_ssize_t) -> *mut PyObject;
-    pub fn PySequence_InPlaceConcat(o1: *mut PyObject, o2: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PySequence_InPlaceRepeat(o: *mut PyObject, count: Py_ssize_t)
-     -> *mut PyObject;
     pub fn PyMapping_Check(o: *mut PyObject) -> c_int;
     pub fn PyMapping_Size(o: *mut PyObject) -> Py_ssize_t;
     pub fn PyMapping_Length(o: *mut PyObject) -> Py_ssize_t;
-    pub fn PyMapping_HasKeyString(o: *mut PyObject, key: *mut c_char)
+    pub fn PyMapping_HasKeyString(o: *mut PyObject, key: *mut c_char) -> c_int;
-     -> c_int;
+    pub fn PyMapping_HasKey(o: *mut PyObject, key: *mut PyObject) -> c_int;
-    pub fn PyMapping_HasKey(o: *mut PyObject, key: *mut PyObject)
+    pub fn PyMapping_GetItemString(o: *mut PyObject, key: *mut c_char) -> *mut PyObject;
-     -> c_int;
+    pub fn PyMapping_SetItemString(
-    pub fn PyMapping_GetItemString(o: *mut PyObject, key: *mut c_char)
+        o: *mut PyObject,
-     -> *mut PyObject;
+        key: *mut c_char,
-    pub fn PyMapping_SetItemString(o: *mut PyObject, key: *mut c_char,
+        value: *mut PyObject,
-                                   value: *mut PyObject) -> c_int;
+    ) -> c_int;
-    pub fn PyObject_IsInstance(object: *mut PyObject,
+    pub fn PyObject_IsInstance(object: *mut PyObject, typeorclass: *mut PyObject) -> c_int;
-                               typeorclass: *mut PyObject) -> c_int;
+    pub fn PyObject_IsSubclass(object: *mut PyObject, typeorclass: *mut PyObject) -> c_int;
-    pub fn PyObject_IsSubclass(object: *mut PyObject,
-                               typeorclass: *mut PyObject) -> c_int;
 }
 
-
 #[inline]
 pub unsafe fn PyObject_CheckBuffer(obj: *mut PyObject) -> c_int {
     let t = (*obj).ob_type;
     let b = (*t).tp_as_buffer;
-    (!b.is_null() &&
+    (!b.is_null()
-     (PyType_HasFeature(t, Py_TPFLAGS_HAVE_NEWBUFFER) != 0) &&
+        && (PyType_HasFeature(t, Py_TPFLAGS_HAVE_NEWBUFFER) != 0)
-     ((*b).bf_getbuffer.is_some())) as c_int
+        && ((*b).bf_getbuffer.is_some())) as c_int
 }
 
-
 #[inline]
 pub unsafe fn PyIter_Check(obj: *mut PyObject) -> c_int {
     let t = (*obj).ob_type;
-    (PyType_HasFeature(t, Py_TPFLAGS_HAVE_ITER) != 0 &&
+    (PyType_HasFeature(t, Py_TPFLAGS_HAVE_ITER) != 0 && match (*t).tp_iternext {
-      match (*t).tp_iternext {
         None => false,
         Some(f) => f as *const c_void != _PyObject_NextNotImplemented as *const c_void,
-      }) as c_int
+    }) as c_int
 }
 
 #[inline]
 pub unsafe fn PyIndex_Check(obj: *mut PyObject) -> c_int {
     let t = (*obj).ob_type;
     let n = (*t).tp_as_number;
-    (!n.is_null() && PyType_HasFeature(t, Py_TPFLAGS_HAVE_INDEX) != 0 && (*n).nb_index.is_some()) as c_int
+    (!n.is_null() && PyType_HasFeature(t, Py_TPFLAGS_HAVE_INDEX) != 0 && (*n).nb_index.is_some())
+        as c_int
 }
 
 #[inline]
-pub unsafe fn PySequence_Fast_GET_SIZE(o : *mut PyObject) -> Py_ssize_t {
+pub unsafe fn PySequence_Fast_GET_SIZE(o: *mut PyObject) -> Py_ssize_t {
     if ffi2::listobject::PyList_Check(o) != 0 {
         ffi2::listobject::PyList_GET_SIZE(o)
     } else {
@@ -257,7 +240,7 @@ pub unsafe fn PySequence_Fast_GET_SIZE(o : *mut PyObject) -> Py_ssize_t {
 }
 
 #[inline]
-pub unsafe fn PySequence_Fast_GET_ITEM(o : *mut PyObject, i : Py_ssize_t) -> *mut PyObject {
+pub unsafe fn PySequence_Fast_GET_ITEM(o: *mut PyObject, i: Py_ssize_t) -> *mut PyObject {
     if ffi2::listobject::PyList_Check(o) != 0 {
         ffi2::listobject::PyList_GET_ITEM(o, i)
     } else {
@@ -266,44 +249,48 @@ pub unsafe fn PySequence_Fast_GET_ITEM(o : *mut PyObject, i : Py_ssize_t) -> *mu
 }
 
 #[inline]
-pub unsafe fn PySequence_Fast_ITEMS(o : *mut PyObject) -> *mut *mut PyObject {
+pub unsafe fn PySequence_Fast_ITEMS(o: *mut PyObject) -> *mut *mut PyObject {
     if ffi2::listobject::PyList_Check(o) != 0 {
         (*(o as *mut ffi2::listobject::PyListObject)).ob_item
     } else {
-        (*(o as *mut ffi2::tupleobject::PyTupleObject)).ob_item.as_mut_ptr()
+        (*(o as *mut ffi2::tupleobject::PyTupleObject))
+            .ob_item
+            .as_mut_ptr()
     }
 }
 
 #[inline]
-pub unsafe fn PySequence_ITEM(o : *mut PyObject, i : Py_ssize_t) -> *mut PyObject {
+pub unsafe fn PySequence_ITEM(o: *mut PyObject, i: Py_ssize_t) -> *mut PyObject {
-    (*(*Py_TYPE(o)).tp_as_sequence).sq_item.expect("Failed to get sq_item")(o, i)
+    (*(*Py_TYPE(o)).tp_as_sequence)
+        .sq_item
+        .expect("Failed to get sq_item")(o, i)
 }
 
-pub const PY_ITERSEARCH_COUNT    : c_int = 1;
+pub const PY_ITERSEARCH_COUNT: c_int = 1;
-pub const PY_ITERSEARCH_INDEX    : c_int = 2;
+pub const PY_ITERSEARCH_INDEX: c_int = 2;
-pub const PY_ITERSEARCH_CONTAINS : c_int = 3;
+pub const PY_ITERSEARCH_CONTAINS: c_int = 3;
 
 #[inline]
-pub unsafe fn PyMapping_DelItemString(o : *mut PyObject, key : *mut c_char) -> c_int {
+pub unsafe fn PyMapping_DelItemString(o: *mut PyObject, key: *mut c_char) -> c_int {
     PyObject_DelItemString(o, key)
 }
 
 #[inline]
-pub unsafe fn PyMapping_DelItem(o : *mut PyObject, key : *mut PyObject) -> c_int {
+pub unsafe fn PyMapping_DelItem(o: *mut PyObject, key: *mut PyObject) -> c_int {
     PyObject_DelItem(o, key)
 }
 
 #[inline]
-pub unsafe fn PyMapping_Keys(o : *mut PyObject) -> *mut PyObject {
+pub unsafe fn PyMapping_Keys(o: *mut PyObject) -> *mut PyObject {
     PyObject_CallMethod(o, "keys\0".as_ptr() as *mut c_char, ptr::null_mut())
 }
 
 #[inline]
-pub unsafe fn PyMapping_Values(o : *mut PyObject) -> *mut PyObject {
+pub unsafe fn PyMapping_Values(o: *mut PyObject) -> *mut PyObject {
     PyObject_CallMethod(o, "values\0".as_ptr() as *mut c_char, ptr::null_mut())
 }
 
 #[inline]
-pub unsafe fn PyMapping_Items(o : *mut PyObject) -> *mut PyObject {
+pub unsafe fn PyMapping_Items(o: *mut PyObject) -> *mut PyObject {
     PyObject_CallMethod(o, "items\0".as_ptr() as *mut c_char, ptr::null_mut())
 }

src/ffi2/objimpl.rs

@@ -1,30 +1,29 @@
-use std::os::raw::{c_void, c_char, c_int};
-use libc::size_t;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use libc::size_t;
+use std::os::raw::{c_char, c_int, c_void};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyObject_Malloc(arg1: size_t) -> *mut c_void;
-    pub fn PyObject_Realloc(arg1: *mut c_void, arg2: size_t)
+    pub fn PyObject_Realloc(arg1: *mut c_void, arg2: size_t) -> *mut c_void;
-                            -> *mut c_void;
     pub fn PyObject_Free(arg1: *mut c_void);
 
-    pub fn PyObject_Init(arg1: *mut PyObject, arg2: *mut PyTypeObject)
+    pub fn PyObject_Init(arg1: *mut PyObject, arg2: *mut PyTypeObject) -> *mut PyObject;
-                         -> *mut PyObject;
+    pub fn PyObject_InitVar(
-    pub fn PyObject_InitVar(arg1: *mut PyVarObject, arg2: *mut PyTypeObject,
+        arg1: *mut PyVarObject,
-                            arg3: Py_ssize_t) -> *mut PyVarObject;
+        arg2: *mut PyTypeObject,
+        arg3: Py_ssize_t,
+    ) -> *mut PyVarObject;
     pub fn _PyObject_New(arg1: *mut PyTypeObject) -> *mut PyObject;
-    pub fn _PyObject_NewVar(arg1: *mut PyTypeObject, arg2: Py_ssize_t)
+    pub fn _PyObject_NewVar(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyVarObject;
-                            -> *mut PyVarObject;
 
     // GC Support
     pub fn PyGC_Collect() -> Py_ssize_t;
-    pub fn _PyObject_GC_Resize(arg1: *mut PyVarObject, arg2: Py_ssize_t)
+    pub fn _PyObject_GC_Resize(arg1: *mut PyVarObject, arg2: Py_ssize_t) -> *mut PyVarObject;
-     -> *mut PyVarObject;
     pub fn _PyObject_GC_Malloc(arg1: size_t) -> *mut PyObject;
     pub fn _PyObject_GC_New(arg1: *mut PyTypeObject) -> *mut PyObject;
-    pub fn _PyObject_GC_NewVar(arg1: *mut PyTypeObject, arg2: Py_ssize_t)
+    pub fn _PyObject_GC_NewVar(arg1: *mut PyTypeObject, arg2: Py_ssize_t) -> *mut PyVarObject;
-     -> *mut PyVarObject;
     pub fn PyObject_GC_Track(arg1: *mut c_void);
     pub fn PyObject_GC_UnTrack(arg1: *mut c_void);
     pub fn PyObject_GC_Del(arg1: *mut c_void);
@@ -33,31 +32,28 @@ use ffi2::object::*;
 /// Test if a type has a GC head
 #[inline(always)]
 #[allow(unused_parens)]
-pub unsafe fn PyType_IS_GC(t : *mut PyTypeObject) -> c_int {
+pub unsafe fn PyType_IS_GC(t: *mut PyTypeObject) -> c_int {
     PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
 }
 
 /// Test if an object has a GC head
 #[inline(always)]
-pub unsafe fn PyObject_IS_GC(o : *mut PyObject) -> c_int {
+pub unsafe fn PyObject_IS_GC(o: *mut PyObject) -> c_int {
-    (PyType_IS_GC(Py_TYPE(o)) != 0 &&
+    (PyType_IS_GC(Py_TYPE(o)) != 0 && match (*Py_TYPE(o)).tp_is_gc {
-    match (*Py_TYPE(o)).tp_is_gc {
         Some(tp_is_gc) => tp_is_gc(o) != 0,
-        None => true
+        None => true,
     }) as c_int
 }
 
 /* Test if a type supports weak references */
 #[inline(always)]
 #[allow(unused_parens)]
-pub unsafe fn PyType_SUPPORTS_WEAKREFS(t : *mut PyTypeObject) -> c_int {
+pub unsafe fn PyType_SUPPORTS_WEAKREFS(t: *mut PyTypeObject) -> c_int {
-    (PyType_HasFeature((t), Py_TPFLAGS_HAVE_WEAKREFS) != 0
+    (PyType_HasFeature((t), Py_TPFLAGS_HAVE_WEAKREFS) != 0 && ((*t).tp_weaklistoffset > 0)) as c_int
-     && ((*t).tp_weaklistoffset > 0)) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyObject_GET_WEAKREFS_LISTPTR(o : *mut PyObject) -> *mut *mut PyObject {
+pub unsafe fn PyObject_GET_WEAKREFS_LISTPTR(o: *mut PyObject) -> *mut *mut PyObject {
     let weaklistoffset = (*Py_TYPE(o)).tp_weaklistoffset as isize;
     (o as *mut c_char).offset(weaklistoffset) as *mut *mut PyObject
 }
-

src/ffi2/pyarena.rs

@@ -1,11 +1,12 @@
-use libc::size_t;
-use std::os::raw::{c_void, c_int};
 use ffi2::object::PyObject;
+use libc::size_t;
+use std::os::raw::{c_int, c_void};
 
 #[allow(missing_copy_implementations)]
-pub enum PyArena { }
+pub enum PyArena {}
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyArena_New() -> *mut PyArena;
     pub fn PyArena_Free(arg1: *mut PyArena);
     pub fn PyArena_Malloc(arg1: *mut PyArena, size: size_t) -> *mut c_void;

src/ffi2/pycapsule.rs

@@ -1,7 +1,8 @@
-use std::os::raw::{c_void, c_char, c_int};
 use ffi2::object::*;
+use std::os::raw::{c_char, c_int, c_void};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyCapsule_Type: PyTypeObject;
 }
 
@@ -12,25 +13,24 @@ pub unsafe fn PyCapsule_CheckExact(ob: *mut PyObject) -> c_int {
     (Py_TYPE(ob) == &mut PyCapsule_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyCapsule_New(pointer: *mut c_void,
+extern "C" {
-                         name: *const c_char,
+    pub fn PyCapsule_New(
-                         destructor: Option<PyCapsule_Destructor>) -> *mut PyObject;
+        pointer: *mut c_void,
-    pub fn PyCapsule_GetPointer(capsule: *mut PyObject,
+        name: *const c_char,
-                                name: *const c_char) -> *mut c_void;
+        destructor: Option<PyCapsule_Destructor>,
+    ) -> *mut PyObject;
+    pub fn PyCapsule_GetPointer(capsule: *mut PyObject, name: *const c_char) -> *mut c_void;
     pub fn PyCapsule_GetDestructor(capsule: *mut PyObject) -> Option<PyCapsule_Destructor>;
     pub fn PyCapsule_GetName(capsule: *mut PyObject) -> *const c_char;
     pub fn PyCapsule_GetContext(capsule: *mut PyObject) -> *mut c_void;
-    pub fn PyCapsule_IsValid(capsule: *mut PyObject,
+    pub fn PyCapsule_IsValid(capsule: *mut PyObject, name: *const c_char) -> c_int;
-                             name: *const c_char) -> c_int;
+    pub fn PyCapsule_SetPointer(capsule: *mut PyObject, pointer: *mut c_void) -> c_int;
-    pub fn PyCapsule_SetPointer(capsule: *mut PyObject,
+    pub fn PyCapsule_SetDestructor(
-                                pointer: *mut c_void) -> c_int;
+        capsule: *mut PyObject,
-    pub fn PyCapsule_SetDestructor(capsule: *mut PyObject,
+        destructor: Option<PyCapsule_Destructor>,
-                                   destructor: Option<PyCapsule_Destructor>) -> c_int;
+    ) -> c_int;
-    pub fn PyCapsule_SetName(capsule: *mut PyObject,
+    pub fn PyCapsule_SetName(capsule: *mut PyObject, name: *const c_char) -> c_int;
-                             name: *const c_char) -> c_int;
+    pub fn PyCapsule_SetContext(capsule: *mut PyObject, context: *mut c_void) -> c_int;
-    pub fn PyCapsule_SetContext(capsule: *mut PyObject,
+    pub fn PyCapsule_Import(name: *const c_char, no_block: c_int) -> *mut c_void;
-                                context: *mut c_void) -> c_int;
-    pub fn PyCapsule_Import(name: *const c_char,
-                            no_block: c_int) -> *mut c_void;
 }

src/ffi2/pydebug.rs

@@ -1,6 +1,7 @@
 use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut Py_DebugFlag: c_int;
     pub static mut Py_VerboseFlag: c_int;
     pub static mut Py_InteractiveFlag: c_int;
@@ -22,4 +23,3 @@ use std::os::raw::{c_char, c_int};
 
     pub fn Py_FatalError(message: *const c_char);
 }
-

src/ffi2/pyerrors.rs

@@ -1,39 +1,45 @@
-use std::os::raw::{c_char, c_int};
-use ffi2::pyport::Py_ssize_t;
-use ffi2::object::*;
 use ffi2::classobject::*;
+use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
 use ffi2::stringobject::PyString_AS_STRING;
-#[cfg(py_sys_config="Py_USING_UNICODE")]
+#[cfg(py_sys_config = "Py_USING_UNICODE")]
 use ffi2::unicodeobject::Py_UNICODE;
+use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyErr_SetNone(arg1: *mut PyObject);
     pub fn PyErr_SetObject(arg1: *mut PyObject, arg2: *mut PyObject);
     pub fn PyErr_SetString(arg1: *mut PyObject, arg2: *const c_char);
     pub fn PyErr_Occurred() -> *mut PyObject;
     pub fn PyErr_Clear();
-    pub fn PyErr_Fetch(arg1: *mut *mut PyObject, arg2: *mut *mut PyObject,
+    pub fn PyErr_Fetch(
-                       arg3: *mut *mut PyObject);
+        arg1: *mut *mut PyObject,
-    pub fn PyErr_Restore(arg1: *mut PyObject, arg2: *mut PyObject,
+        arg2: *mut *mut PyObject,
-                         arg3: *mut PyObject);
+        arg3: *mut *mut PyObject,
-    pub fn PyErr_GivenExceptionMatches(arg1: *mut PyObject,
+    );
-                                       arg2: *mut PyObject) -> c_int;
+    pub fn PyErr_Restore(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject);
+    pub fn PyErr_GivenExceptionMatches(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
     pub fn PyErr_ExceptionMatches(arg1: *mut PyObject) -> c_int;
-    pub fn PyErr_NormalizeException(arg1: *mut *mut PyObject,
+    pub fn PyErr_NormalizeException(
-                                    arg2: *mut *mut PyObject,
+        arg1: *mut *mut PyObject,
-                                    arg3: *mut *mut PyObject);
+        arg2: *mut *mut PyObject,
+        arg3: *mut *mut PyObject,
+    );
 }
 
 #[inline]
 pub unsafe fn PyExceptionClass_Check(x: *mut PyObject) -> c_int {
-    (PyClass_Check(x) != 0 || (PyType_Check(x) != 0 &&
+    (PyClass_Check(x) != 0
-      PyType_FastSubclass(x as *mut PyTypeObject, Py_TPFLAGS_BASE_EXC_SUBCLASS) != 0)) as c_int
+        || (PyType_Check(x) != 0
+            && PyType_FastSubclass(x as *mut PyTypeObject, Py_TPFLAGS_BASE_EXC_SUBCLASS) != 0))
+        as c_int
 }
 
 #[inline]
 pub unsafe fn PyExceptionInstance_Check(x: *mut PyObject) -> c_int {
-    (PyInstance_Check(x) != 0 ||
+    (PyInstance_Check(x) != 0
-     PyType_FastSubclass((*x).ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS) != 0) as c_int
+        || PyType_FastSubclass((*x).ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS) != 0) as c_int
 }
 
 #[inline]
@@ -54,7 +60,8 @@ pub unsafe fn PyExceptionInstance_Class(x: *mut PyObject) -> *mut PyObject {
     }
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyExc_BaseException: *mut PyObject;
     pub static mut PyExc_Exception: *mut PyObject;
     pub static mut PyExc_StopIteration: *mut PyObject;
@@ -92,7 +99,8 @@ pub unsafe fn PyExceptionInstance_Class(x: *mut PyObject) -> *mut PyObject {
     pub static mut PyExc_UnicodeTranslateError: *mut PyObject;
     pub static mut PyExc_ValueError: *mut PyObject;
     pub static mut PyExc_ZeroDivisionError: *mut PyObject;
-    #[cfg(windows)] pub static mut PyExc_WindowsError: *mut PyObject;
+    #[cfg(windows)]
+    pub static mut PyExc_WindowsError: *mut PyObject;
     pub static mut PyExc_BufferError: *mut PyObject;
     pub static mut PyExc_MemoryErrorInst: *mut PyObject;
     pub static mut PyExc_RecursionErrorInst: *mut PyObject;
@@ -110,107 +118,83 @@ pub unsafe fn PyExceptionInstance_Class(x: *mut PyObject) -> *mut PyObject {
     pub fn PyErr_BadArgument() -> c_int;
     pub fn PyErr_NoMemory() -> *mut PyObject;
     pub fn PyErr_SetFromErrno(arg1: *mut PyObject) -> *mut PyObject;
-    pub fn PyErr_SetFromErrnoWithFilenameObject(arg1: *mut PyObject,
+    pub fn PyErr_SetFromErrnoWithFilenameObject(
-                                                arg2: *mut PyObject)
+        arg1: *mut PyObject,
-     -> *mut PyObject;
+        arg2: *mut PyObject,
-    pub fn PyErr_SetFromErrnoWithFilename(arg1: *mut PyObject,
+    ) -> *mut PyObject;
-                                          arg2: *const c_char)
+    pub fn PyErr_SetFromErrnoWithFilename(
-     -> *mut PyObject;
+        arg1: *mut PyObject,
-    pub fn PyErr_Format(arg1: *mut PyObject, arg2: *const c_char, ...)
+        arg2: *const c_char,
-     -> *mut PyObject;
+    ) -> *mut PyObject;
+    pub fn PyErr_Format(arg1: *mut PyObject, arg2: *const c_char, ...) -> *mut PyObject;
     pub fn PyErr_BadInternalCall();
-    pub fn _PyErr_BadInternalCall(filename: *mut c_char,
+    pub fn _PyErr_BadInternalCall(filename: *mut c_char, lineno: c_int);
-                                  lineno: c_int);
+    pub fn PyErr_NewException(
-    pub fn PyErr_NewException(name: *mut c_char, base: *mut PyObject,
+        name: *mut c_char,
-                              dict: *mut PyObject) -> *mut PyObject;
+        base: *mut PyObject,
-    pub fn PyErr_NewExceptionWithDoc(name: *mut c_char,
+        dict: *mut PyObject,
-                                     doc: *mut c_char,
+    ) -> *mut PyObject;
-                                     base: *mut PyObject, dict: *mut PyObject)
+    pub fn PyErr_NewExceptionWithDoc(
-     -> *mut PyObject;
+        name: *mut c_char,
+        doc: *mut c_char,
+        base: *mut PyObject,
+        dict: *mut PyObject,
+    ) -> *mut PyObject;
     pub fn PyErr_WriteUnraisable(arg1: *mut PyObject);
     pub fn PyErr_CheckSignals() -> c_int;
     pub fn PyErr_SetInterrupt();
     pub fn PySignal_SetWakeupFd(fd: c_int) -> c_int;
-    pub fn PyErr_SyntaxLocation(arg1: *const c_char,
+    pub fn PyErr_SyntaxLocation(arg1: *const c_char, arg2: c_int);
-                                arg2: c_int);
+    pub fn PyErr_ProgramText(arg1: *const c_char, arg2: c_int) -> *mut PyObject;
-    pub fn PyErr_ProgramText(arg1: *const c_char, arg2: c_int)
-     -> *mut PyObject;
 }
 
-#[cfg(py_sys_config="Py_USING_UNICODE")]
+#[cfg(py_sys_config = "Py_USING_UNICODE")]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyUnicodeDecodeError_Create(arg1: *const c_char,
+extern "C" {
-                                       arg2: *const c_char,
+    pub fn PyUnicodeDecodeError_Create(
-                                       arg3: Py_ssize_t, arg4: Py_ssize_t,
+        arg1: *const c_char,
-                                       arg5: Py_ssize_t,
+        arg2: *const c_char,
-                                       arg6: *const c_char)
+        arg3: Py_ssize_t,
-     -> *mut PyObject;
+        arg4: Py_ssize_t,
-    pub fn PyUnicodeEncodeError_Create(arg1: *const c_char,
+        arg5: Py_ssize_t,
-                                       arg2: *const Py_UNICODE,
+        arg6: *const c_char,
-                                       arg3: Py_ssize_t, arg4: Py_ssize_t,
+    ) -> *mut PyObject;
-                                       arg5: Py_ssize_t,
+    pub fn PyUnicodeEncodeError_Create(
-                                       arg6: *const c_char)
+        arg1: *const c_char,
-     -> *mut PyObject;
+        arg2: *const Py_UNICODE,
-    pub fn PyUnicodeTranslateError_Create(arg1: *const Py_UNICODE,
+        arg3: Py_ssize_t,
-                                          arg2: Py_ssize_t, arg3: Py_ssize_t,
+        arg4: Py_ssize_t,
-                                          arg4: Py_ssize_t,
+        arg5: Py_ssize_t,
-                                          arg5: *const c_char)
+        arg6: *const c_char,
-     -> *mut PyObject;
+    ) -> *mut PyObject;
-    pub fn PyUnicodeEncodeError_GetEncoding(arg1: *mut PyObject)
+    pub fn PyUnicodeTranslateError_Create(
-     -> *mut PyObject;
+        arg1: *const Py_UNICODE,
-    pub fn PyUnicodeDecodeError_GetEncoding(arg1: *mut PyObject)
+        arg2: Py_ssize_t,
-     -> *mut PyObject;
+        arg3: Py_ssize_t,
-    pub fn PyUnicodeEncodeError_GetObject(arg1: *mut PyObject)
+        arg4: Py_ssize_t,
-     -> *mut PyObject;
+        arg5: *const c_char,
-    pub fn PyUnicodeDecodeError_GetObject(arg1: *mut PyObject)
+    ) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyUnicodeEncodeError_GetEncoding(arg1: *mut PyObject) -> *mut PyObject;
-    pub fn PyUnicodeTranslateError_GetObject(arg1: *mut PyObject)
+    pub fn PyUnicodeDecodeError_GetEncoding(arg1: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyUnicodeEncodeError_GetObject(arg1: *mut PyObject) -> *mut PyObject;
-    pub fn PyUnicodeEncodeError_GetStart(arg1: *mut PyObject,
+    pub fn PyUnicodeDecodeError_GetObject(arg1: *mut PyObject) -> *mut PyObject;
-                                         arg2: *mut Py_ssize_t)
+    pub fn PyUnicodeTranslateError_GetObject(arg1: *mut PyObject) -> *mut PyObject;
-     -> c_int;
+    pub fn PyUnicodeEncodeError_GetStart(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> c_int;
-    pub fn PyUnicodeDecodeError_GetStart(arg1: *mut PyObject,
+    pub fn PyUnicodeDecodeError_GetStart(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> c_int;
-                                         arg2: *mut Py_ssize_t)
+    pub fn PyUnicodeTranslateError_GetStart(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> c_int;
-     -> c_int;
+    pub fn PyUnicodeEncodeError_SetStart(arg1: *mut PyObject, arg2: Py_ssize_t) -> c_int;
-    pub fn PyUnicodeTranslateError_GetStart(arg1: *mut PyObject,
+    pub fn PyUnicodeDecodeError_SetStart(arg1: *mut PyObject, arg2: Py_ssize_t) -> c_int;
-                                            arg2: *mut Py_ssize_t)
+    pub fn PyUnicodeTranslateError_SetStart(arg1: *mut PyObject, arg2: Py_ssize_t) -> c_int;
-     -> c_int;
+    pub fn PyUnicodeEncodeError_GetEnd(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> c_int;
-    pub fn PyUnicodeEncodeError_SetStart(arg1: *mut PyObject,
+    pub fn PyUnicodeDecodeError_GetEnd(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> c_int;
-                                         arg2: Py_ssize_t) -> c_int;
+    pub fn PyUnicodeTranslateError_GetEnd(arg1: *mut PyObject, arg2: *mut Py_ssize_t) -> c_int;
-    pub fn PyUnicodeDecodeError_SetStart(arg1: *mut PyObject,
+    pub fn PyUnicodeEncodeError_SetEnd(arg1: *mut PyObject, arg2: Py_ssize_t) -> c_int;
-                                         arg2: Py_ssize_t) -> c_int;
+    pub fn PyUnicodeDecodeError_SetEnd(arg1: *mut PyObject, arg2: Py_ssize_t) -> c_int;
-    pub fn PyUnicodeTranslateError_SetStart(arg1: *mut PyObject,
+    pub fn PyUnicodeTranslateError_SetEnd(arg1: *mut PyObject, arg2: Py_ssize_t) -> c_int;
-                                            arg2: Py_ssize_t)
+    pub fn PyUnicodeEncodeError_GetReason(arg1: *mut PyObject) -> *mut PyObject;
-     -> c_int;
+    pub fn PyUnicodeDecodeError_GetReason(arg1: *mut PyObject) -> *mut PyObject;
-    pub fn PyUnicodeEncodeError_GetEnd(arg1: *mut PyObject,
+    pub fn PyUnicodeTranslateError_GetReason(arg1: *mut PyObject) -> *mut PyObject;
-                                       arg2: *mut Py_ssize_t)
+    pub fn PyUnicodeEncodeError_SetReason(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
-     -> c_int;
+    pub fn PyUnicodeDecodeError_SetReason(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
-    pub fn PyUnicodeDecodeError_GetEnd(arg1: *mut PyObject,
+    pub fn PyUnicodeTranslateError_SetReason(arg1: *mut PyObject, arg2: *const c_char) -> c_int;
-                                       arg2: *mut Py_ssize_t)
-     -> c_int;
-    pub fn PyUnicodeTranslateError_GetEnd(arg1: *mut PyObject,
-                                          arg2: *mut Py_ssize_t)
-     -> c_int;
-    pub fn PyUnicodeEncodeError_SetEnd(arg1: *mut PyObject, arg2: Py_ssize_t)
-     -> c_int;
-    pub fn PyUnicodeDecodeError_SetEnd(arg1: *mut PyObject, arg2: Py_ssize_t)
-     -> c_int;
-    pub fn PyUnicodeTranslateError_SetEnd(arg1: *mut PyObject,
-                                          arg2: Py_ssize_t) -> c_int;
-    pub fn PyUnicodeEncodeError_GetReason(arg1: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyUnicodeDecodeError_GetReason(arg1: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyUnicodeTranslateError_GetReason(arg1: *mut PyObject)
-     -> *mut PyObject;
-    pub fn PyUnicodeEncodeError_SetReason(arg1: *mut PyObject,
-                                          arg2: *const c_char)
-     -> c_int;
-    pub fn PyUnicodeDecodeError_SetReason(arg1: *mut PyObject,
-                                          arg2: *const c_char)
-     -> c_int;
-    pub fn PyUnicodeTranslateError_SetReason(arg1: *mut PyObject,
-                                             arg2: *const c_char)
-     -> c_int;
 }
-

src/ffi2/pymem.rs

@@ -1,6 +1,7 @@
 use libc::{c_void, size_t};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyMem_Malloc(n: size_t) -> *mut c_void;
     pub fn PyMem_Realloc(p: *mut c_void, n: size_t) -> *mut c_void;
     pub fn PyMem_Free(p: *mut c_void);

src/ffi2/pyport.rs

@@ -1,9 +1,8 @@
-
 pub type Py_uintptr_t = ::libc::uintptr_t;
 pub type Py_intptr_t = ::libc::intptr_t;
 pub type Py_ssize_t = ::libc::ssize_t;
 pub type Py_hash_t = Py_ssize_t;
 pub type Py_uhash_t = ::libc::size_t;
 
-pub const PY_SSIZE_T_MIN : Py_ssize_t = ::std::isize::MIN as Py_ssize_t;
+pub const PY_SSIZE_T_MIN: Py_ssize_t = ::std::isize::MIN as Py_ssize_t;
-pub const PY_SSIZE_T_MAX : Py_ssize_t = ::std::isize::MAX as Py_ssize_t;
+pub const PY_SSIZE_T_MAX: Py_ssize_t = ::std::isize::MAX as Py_ssize_t;

src/ffi2/pystate.rs

@@ -1,22 +1,24 @@
-use std::os::raw::{c_int, c_long};
-use ffi2::object::PyObject;
 use ffi2::frameobject::PyFrameObject;
+use ffi2::object::PyObject;
+use std::os::raw::{c_int, c_long};
 
-pub enum PyInterpreterState { }
+pub enum PyInterpreterState {}
 
-pub type Py_tracefunc =
+pub type Py_tracefunc = unsafe extern "C" fn(
-    unsafe extern "C" fn (arg1: *mut PyObject, arg2: *mut PyFrameObject,
+    arg1: *mut PyObject,
-                          arg3: c_int, arg4: *mut PyObject)
+    arg2: *mut PyFrameObject,
-                          -> c_int;
+    arg3: c_int,
+    arg4: *mut PyObject,
+) -> c_int;
 
 /* The following values are used for 'what' for tracefunc functions: */
-pub const PyTrace_CALL : c_int = 0;
+pub const PyTrace_CALL: c_int = 0;
-pub const PyTrace_EXCEPTION : c_int = 1;
+pub const PyTrace_EXCEPTION: c_int = 1;
-pub const PyTrace_LINE : c_int = 2;
+pub const PyTrace_LINE: c_int = 2;
-pub const PyTrace_RETURN : c_int = 3;
+pub const PyTrace_RETURN: c_int = 3;
-pub const PyTrace_C_CALL : c_int = 4;
+pub const PyTrace_C_CALL: c_int = 4;
-pub const PyTrace_C_EXCEPTION : c_int = 5;
+pub const PyTrace_C_EXCEPTION: c_int = 5;
-pub const PyTrace_C_RETURN : c_int = 6;
+pub const PyTrace_C_RETURN: c_int = 6;
 
 #[repr(C)]
 #[derive(Copy)]
@@ -47,60 +49,56 @@ pub struct PyThreadState {
 }
 
 impl Clone for PyThreadState {
-    #[inline] fn clone(&self) -> PyThreadState { *self }
+    #[inline]
+    fn clone(&self) -> PyThreadState {
+        *self
+    }
 }
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub enum PyGILState_STATE {
     PyGILState_LOCKED,
-    PyGILState_UNLOCKED
+    PyGILState_UNLOCKED,
 }
 
-
+#[cfg_attr(windows, link(name = "pythonXY"))]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+extern "C" {
     static mut _PyThreadState_Current: *mut PyThreadState;
     //static mut _PyThreadState_GetFrame: PyThreadFrameGetter;
 
     pub fn PyInterpreterState_New() -> *mut PyInterpreterState;
     pub fn PyInterpreterState_Clear(arg1: *mut PyInterpreterState);
     pub fn PyInterpreterState_Delete(arg1: *mut PyInterpreterState);
-    pub fn PyThreadState_New(arg1: *mut PyInterpreterState)
+    pub fn PyThreadState_New(arg1: *mut PyInterpreterState) -> *mut PyThreadState;
-     -> *mut PyThreadState;
+    pub fn _PyThreadState_Prealloc(arg1: *mut PyInterpreterState) -> *mut PyThreadState;
-    pub fn _PyThreadState_Prealloc(arg1: *mut PyInterpreterState)
-     -> *mut PyThreadState;
     pub fn _PyThreadState_Init(arg1: *mut PyThreadState);
     pub fn PyThreadState_Clear(arg1: *mut PyThreadState);
     pub fn PyThreadState_Delete(arg1: *mut PyThreadState);
-    #[cfg(py_sys_config="WITH_THREAD")]
+    #[cfg(py_sys_config = "WITH_THREAD")]
     pub fn PyThreadState_DeleteCurrent();
     pub fn PyThreadState_Get() -> *mut PyThreadState;
     pub fn PyThreadState_Swap(arg1: *mut PyThreadState) -> *mut PyThreadState;
     pub fn PyThreadState_GetDict() -> *mut PyObject;
-    pub fn PyThreadState_SetAsyncExc(arg1: c_long,
+    pub fn PyThreadState_SetAsyncExc(arg1: c_long, arg2: *mut PyObject) -> c_int;
-                                     arg2: *mut PyObject) -> c_int;
     pub fn PyGILState_Ensure() -> PyGILState_STATE;
     pub fn PyGILState_Release(arg1: PyGILState_STATE);
     pub fn PyGILState_GetThisThreadState() -> *mut PyThreadState;
     fn _PyThread_CurrentFrames() -> *mut PyObject;
     pub fn PyInterpreterState_Head() -> *mut PyInterpreterState;
-    pub fn PyInterpreterState_Next(arg1: *mut PyInterpreterState)
+    pub fn PyInterpreterState_Next(arg1: *mut PyInterpreterState) -> *mut PyInterpreterState;
-     -> *mut PyInterpreterState;
+    pub fn PyInterpreterState_ThreadHead(arg1: *mut PyInterpreterState) -> *mut PyThreadState;
-    pub fn PyInterpreterState_ThreadHead(arg1: *mut PyInterpreterState)
-     -> *mut PyThreadState;
     pub fn PyThreadState_Next(arg1: *mut PyThreadState) -> *mut PyThreadState;
 }
 
-#[cfg(py_sys_config="Py_DEBUG")]
+#[cfg(py_sys_config = "Py_DEBUG")]
 #[inline(always)]
 pub unsafe fn PyThreadState_GET() -> *mut PyThreadState {
     PyThreadState_Get()
 }
 
-#[cfg(not(py_sys_config="Py_DEBUG"))]
+#[cfg(not(py_sys_config = "Py_DEBUG"))]
 #[inline(always)]
 pub unsafe fn PyThreadState_GET() -> *mut PyThreadState {
     _PyThreadState_Current
 }
-
-

src/ffi2/pythonrun.rs

@@ -1,31 +1,34 @@
-use libc::{c_char, c_int, FILE};
-use ffi2::object::*;
 use ffi2::code::*;
-use ffi2::pystate::PyThreadState;
+use ffi2::object::*;
 use ffi2::pyarena::PyArena;
+use ffi2::pystate::PyThreadState;
+use libc::{c_char, c_int, FILE};
 
-pub const PyCF_MASK : c_int = (CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT |
+pub const PyCF_MASK: c_int = (CO_FUTURE_DIVISION
-                               CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION |
+    | CO_FUTURE_ABSOLUTE_IMPORT
-                               CO_FUTURE_UNICODE_LITERALS);
+    | CO_FUTURE_WITH_STATEMENT
-pub const PyCF_MASK_OBSOLETE : c_int = (CO_NESTED);
+    | CO_FUTURE_PRINT_FUNCTION
-pub const PyCF_SOURCE_IS_UTF8 : c_int = 0x0100;
+    | CO_FUTURE_UNICODE_LITERALS);
-pub const PyCF_DONT_IMPLY_DEDENT : c_int = 0x0200;
+pub const PyCF_MASK_OBSOLETE: c_int = (CO_NESTED);
-pub const PyCF_ONLY_AST : c_int = 0x0400;
+pub const PyCF_SOURCE_IS_UTF8: c_int = 0x0100;
+pub const PyCF_DONT_IMPLY_DEDENT: c_int = 0x0200;
+pub const PyCF_ONLY_AST: c_int = 0x0400;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyCompilerFlags {
-    cf_flags : c_int
+    cf_flags: c_int,
 }
 
 #[allow(missing_copy_implementations)]
-pub enum Struct__mod { }
+pub enum Struct__mod {}
 #[allow(missing_copy_implementations)]
-pub enum Struct__node { }
+pub enum Struct__node {}
 #[allow(missing_copy_implementations)]
-pub enum Struct_symtable { }
+pub enum Struct_symtable {}
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn Py_SetProgramName(arg1: *mut c_char);
     pub fn Py_GetProgramName() -> *mut c_char;
     pub fn Py_SetPythonHome(arg1: *mut c_char);
@@ -36,73 +39,96 @@ pub enum Struct_symtable { }
     pub fn Py_IsInitialized() -> c_int;
     pub fn Py_NewInterpreter() -> *mut PyThreadState;
     pub fn Py_EndInterpreter(arg1: *mut PyThreadState);
-    pub fn PyRun_AnyFileFlags(arg1: *mut FILE, arg2: *const c_char,
+    pub fn PyRun_AnyFileFlags(
-                              arg3: *mut PyCompilerFlags) -> c_int;
+        arg1: *mut FILE,
-    pub fn PyRun_AnyFileExFlags(arg1: *mut FILE, arg2: *const c_char,
+        arg2: *const c_char,
-                                arg3: c_int,
+        arg3: *mut PyCompilerFlags,
-                                arg4: *mut PyCompilerFlags) -> c_int;
+    ) -> c_int;
-    pub fn PyRun_SimpleStringFlags(arg1: *const c_char,
+    pub fn PyRun_AnyFileExFlags(
-                                   arg2: *mut PyCompilerFlags)
+        arg1: *mut FILE,
-     -> c_int;
+        arg2: *const c_char,
-    pub fn PyRun_SimpleFileExFlags(arg1: *mut FILE,
+        arg3: c_int,
-                                   arg2: *const c_char,
+        arg4: *mut PyCompilerFlags,
-                                   arg3: c_int,
+    ) -> c_int;
-                                   arg4: *mut PyCompilerFlags)
+    pub fn PyRun_SimpleStringFlags(arg1: *const c_char, arg2: *mut PyCompilerFlags) -> c_int;
-     -> c_int;
+    pub fn PyRun_SimpleFileExFlags(
-    pub fn PyRun_InteractiveOneFlags(arg1: *mut FILE,
+        arg1: *mut FILE,
-                                     arg2: *const c_char,
+        arg2: *const c_char,
-                                     arg3: *mut PyCompilerFlags)
+        arg3: c_int,
-     -> c_int;
+        arg4: *mut PyCompilerFlags,
-    pub fn PyRun_InteractiveLoopFlags(arg1: *mut FILE,
+    ) -> c_int;
-                                      arg2: *const c_char,
+    pub fn PyRun_InteractiveOneFlags(
-                                      arg3: *mut PyCompilerFlags)
+        arg1: *mut FILE,
-     -> c_int;
+        arg2: *const c_char,
-    pub fn PyParser_ASTFromString(arg1: *const c_char,
+        arg3: *mut PyCompilerFlags,
-                                  arg2: *const c_char,
+    ) -> c_int;
-                                  arg3: c_int,
+    pub fn PyRun_InteractiveLoopFlags(
-                                  flags: *mut PyCompilerFlags,
+        arg1: *mut FILE,
-                                  arg4: *mut PyArena) -> *mut Struct__mod;
+        arg2: *const c_char,
-    pub fn PyParser_ASTFromFile(arg1: *mut FILE, arg2: *const c_char,
+        arg3: *mut PyCompilerFlags,
-                                arg3: c_int,
+    ) -> c_int;
-                                arg4: *mut c_char,
+    pub fn PyParser_ASTFromString(
-                                arg5: *mut c_char,
+        arg1: *const c_char,
-                                arg6: *mut PyCompilerFlags,
+        arg2: *const c_char,
-                                arg7: *mut c_int, arg8: *mut PyArena)
+        arg3: c_int,
-     -> *mut Struct__mod;
+        flags: *mut PyCompilerFlags,
-    pub fn PyParser_SimpleParseStringFlags(arg1: *const c_char,
+        arg4: *mut PyArena,
-                                           arg2: c_int,
+    ) -> *mut Struct__mod;
-                                           arg3: c_int)
+    pub fn PyParser_ASTFromFile(
-     -> *mut Struct__node;
+        arg1: *mut FILE,
-    pub fn PyParser_SimpleParseFileFlags(arg1: *mut FILE,
+        arg2: *const c_char,
-                                         arg2: *const c_char,
+        arg3: c_int,
-                                         arg3: c_int,
+        arg4: *mut c_char,
-                                         arg4: c_int)
+        arg5: *mut c_char,
-     -> *mut Struct__node;
+        arg6: *mut PyCompilerFlags,
-    pub fn PyRun_StringFlags(arg1: *const c_char, arg2: c_int,
+        arg7: *mut c_int,
-                             arg3: *mut PyObject, arg4: *mut PyObject,
+        arg8: *mut PyArena,
-                             arg5: *mut PyCompilerFlags) -> *mut PyObject;
+    ) -> *mut Struct__mod;
-    pub fn PyRun_FileExFlags(arg1: *mut FILE, arg2: *const c_char,
+    pub fn PyParser_SimpleParseStringFlags(
-                             arg3: c_int, arg4: *mut PyObject,
+        arg1: *const c_char,
-                             arg5: *mut PyObject, arg6: c_int,
+        arg2: c_int,
-                             arg7: *mut PyCompilerFlags) -> *mut PyObject;
+        arg3: c_int,
-    pub fn Py_CompileStringFlags(arg1: *const c_char,
+    ) -> *mut Struct__node;
-                                 arg2: *const c_char,
+    pub fn PyParser_SimpleParseFileFlags(
-                                 arg3: c_int,
+        arg1: *mut FILE,
-                                 arg4: *mut PyCompilerFlags) -> *mut PyObject;
+        arg2: *const c_char,
-    pub fn Py_SymtableString(arg1: *const c_char,
+        arg3: c_int,
-                             arg2: *const c_char, arg3: c_int)
+        arg4: c_int,
-     -> *mut Struct_symtable;
+    ) -> *mut Struct__node;
+    pub fn PyRun_StringFlags(
+        arg1: *const c_char,
+        arg2: c_int,
+        arg3: *mut PyObject,
+        arg4: *mut PyObject,
+        arg5: *mut PyCompilerFlags,
+    ) -> *mut PyObject;
+    pub fn PyRun_FileExFlags(
+        arg1: *mut FILE,
+        arg2: *const c_char,
+        arg3: c_int,
+        arg4: *mut PyObject,
+        arg5: *mut PyObject,
+        arg6: c_int,
+        arg7: *mut PyCompilerFlags,
+    ) -> *mut PyObject;
+    pub fn Py_CompileStringFlags(
+        arg1: *const c_char,
+        arg2: *const c_char,
+        arg3: c_int,
+        arg4: *mut PyCompilerFlags,
+    ) -> *mut PyObject;
+    pub fn Py_SymtableString(
+        arg1: *const c_char,
+        arg2: *const c_char,
+        arg3: c_int,
+    ) -> *mut Struct_symtable;
     pub fn PyErr_Print();
     pub fn PyErr_PrintEx(arg1: c_int);
-    pub fn PyErr_Display(arg1: *mut PyObject, arg2: *mut PyObject,
+    pub fn PyErr_Display(arg1: *mut PyObject, arg2: *mut PyObject, arg3: *mut PyObject);
-                         arg3: *mut PyObject);
+    pub fn Py_AtExit(func: Option<unsafe extern "C" fn()>) -> c_int;
-    pub fn Py_AtExit(func: Option<unsafe extern "C" fn()>)
-     -> c_int;
     pub fn Py_Exit(arg1: c_int);
-    pub fn Py_FdIsInteractive(arg1: *mut FILE, arg2: *const c_char)
+    pub fn Py_FdIsInteractive(arg1: *mut FILE, arg2: *const c_char) -> c_int;
-     -> c_int;
+    pub fn Py_Main(argc: c_int, argv: *mut *mut c_char) -> c_int;
-    pub fn Py_Main(argc: c_int, argv: *mut *mut c_char)
-     -> c_int;
     pub fn Py_GetProgramFullPath() -> *mut c_char;
     pub fn Py_GetPrefix() -> *mut c_char;
     pub fn Py_GetExecPrefix() -> *mut c_char;
@@ -118,4 +144,3 @@ pub enum Struct_symtable { }
     fn _Py_hgidentifier() -> *const c_char;
     fn _Py_hgversion() -> *const c_char;
 }
-

src/ffi2/rangeobject.rs

@@ -1,13 +1,13 @@
-use std::os::raw::c_int;
 use ffi2::object::*;
+use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyRange_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyRange_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyRange_Check(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyRange_Type;
+    let u: *mut PyTypeObject = &mut PyRange_Type;
     (Py_TYPE(op) == u) as c_int
 }
-

src/ffi2/setobject.rs

@@ -1,55 +1,55 @@
-use std::os::raw::c_int;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
 //enum PySetObject { /* representation hidden */ }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PySet_Type: PyTypeObject;
     pub static mut PyFrozenSet_Type: PyTypeObject;
 }
 
 #[inline]
-pub unsafe fn PyFrozenSet_CheckExact(ob : *mut PyObject) -> c_int {
+pub unsafe fn PyFrozenSet_CheckExact(ob: *mut PyObject) -> c_int {
-    let f : *mut PyTypeObject = &mut PyFrozenSet_Type;
+    let f: *mut PyTypeObject = &mut PyFrozenSet_Type;
     (Py_TYPE(ob) == f) as c_int
 }
 
 #[inline]
-pub unsafe fn PyAnySet_CheckExact(ob : *mut PyObject) -> c_int {
+pub unsafe fn PyAnySet_CheckExact(ob: *mut PyObject) -> c_int {
-    let s : *mut PyTypeObject = &mut PySet_Type;
+    let s: *mut PyTypeObject = &mut PySet_Type;
-    let f : *mut PyTypeObject = &mut PyFrozenSet_Type;
+    let f: *mut PyTypeObject = &mut PyFrozenSet_Type;
     (Py_TYPE(ob) == s || Py_TYPE(ob) == f) as c_int
 }
 
 #[inline]
-pub unsafe fn PyAnySet_Check(ob : *mut PyObject) -> c_int {
+pub unsafe fn PyAnySet_Check(ob: *mut PyObject) -> c_int {
-    (PyAnySet_CheckExact(ob) != 0 ||
+    (PyAnySet_CheckExact(ob) != 0
-      PyType_IsSubtype(Py_TYPE(ob), &mut PySet_Type) != 0 ||
+        || PyType_IsSubtype(Py_TYPE(ob), &mut PySet_Type) != 0
-      PyType_IsSubtype(Py_TYPE(ob), &mut PyFrozenSet_Type) != 0) as c_int
+        || PyType_IsSubtype(Py_TYPE(ob), &mut PyFrozenSet_Type) != 0) as c_int
 }
 
 #[inline]
-pub unsafe fn PySet_Check(ob : *mut PyObject) -> c_int {
+pub unsafe fn PySet_Check(ob: *mut PyObject) -> c_int {
-    let s : *mut PyTypeObject = &mut PySet_Type;
+    let s: *mut PyTypeObject = &mut PySet_Type;
     (Py_TYPE(ob) == s || PyType_IsSubtype(Py_TYPE(ob), s) != 0) as c_int
 }
 
 #[inline]
-pub unsafe fn PyFrozenSet_Check(ob : *mut PyObject) -> c_int {
+pub unsafe fn PyFrozenSet_Check(ob: *mut PyObject) -> c_int {
-    let f : *mut PyTypeObject = &mut PyFrozenSet_Type;
+    let f: *mut PyTypeObject = &mut PyFrozenSet_Type;
     (Py_TYPE(ob) == f || PyType_IsSubtype(Py_TYPE(ob), f) != 0) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PySet_New(iterable: *mut PyObject) -> *mut PyObject;
     pub fn PyFrozenSet_New(iterable: *mut PyObject) -> *mut PyObject;
     pub fn PySet_Size(anyset: *mut PyObject) -> Py_ssize_t;
     pub fn PySet_Clear(set: *mut PyObject) -> c_int;
-    pub fn PySet_Contains(anyset: *mut PyObject, key: *mut PyObject)
+    pub fn PySet_Contains(anyset: *mut PyObject, key: *mut PyObject) -> c_int;
-     -> c_int;
+    pub fn PySet_Discard(set: *mut PyObject, key: *mut PyObject) -> c_int;
-    pub fn PySet_Discard(set: *mut PyObject, key: *mut PyObject)
-     -> c_int;
     pub fn PySet_Add(set: *mut PyObject, key: *mut PyObject) -> c_int;
     //pub fn _PySet_Next(set: *mut PyObject, pos: *mut Py_ssize_t,
     //                   key: *mut *mut PyObject) -> c_int;
@@ -57,7 +57,6 @@ pub unsafe fn PyFrozenSet_Check(ob : *mut PyObject) -> c_int {
     //                        key: *mut *mut PyObject,
     //                        hash: *mut c_long) -> c_int;
     pub fn PySet_Pop(set: *mut PyObject) -> *mut PyObject;
-    //pub fn _PySet_Update(set: *mut PyObject, iterable: *mut PyObject)
+//pub fn _PySet_Update(set: *mut PyObject, iterable: *mut PyObject)
-    // -> c_int;
+// -> c_int;
 }
-

src/ffi2/sliceobject.rs

@@ -1,8 +1,9 @@
-use std::os::raw::c_int;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     static mut _Py_EllipsisObject: PyObject;
 }
 
@@ -14,37 +15,48 @@ pub unsafe fn Py_Ellipsis() -> *mut PyObject {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PySliceObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
     pub start: *mut PyObject,
     pub stop: *mut PyObject,
-    pub step: *mut PyObject
+    pub step: *mut PyObject,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PySlice_Type: PyTypeObject;
     pub static mut PyEllipsis_Type: PyTypeObject;
 }
 
 #[inline(always)]
 pub unsafe fn PySlice_Check(op: *mut PyObject) -> c_int {
-     (Py_TYPE(op) == &mut PySlice_Type) as c_int
+    (Py_TYPE(op) == &mut PySlice_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PySlice_New(start: *mut PyObject, stop: *mut PyObject,
+extern "C" {
-                       step: *mut PyObject) -> *mut PyObject;
+    pub fn PySlice_New(
-    pub fn PySlice_GetIndices(r: *mut PyObject, length: Py_ssize_t,
+        start: *mut PyObject,
-                              start: *mut Py_ssize_t, stop: *mut Py_ssize_t,
+        stop: *mut PyObject,
-                              step: *mut Py_ssize_t) -> c_int;
+        step: *mut PyObject,
-    pub fn PySlice_GetIndicesEx(r: *mut PyObject, length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                start: *mut Py_ssize_t, stop: *mut Py_ssize_t,
+    pub fn PySlice_GetIndices(
-                                step: *mut Py_ssize_t,
+        r: *mut PyObject,
-                                slicelength: *mut Py_ssize_t)
+        length: Py_ssize_t,
-     -> c_int;
+        start: *mut Py_ssize_t,
+        stop: *mut Py_ssize_t,
+        step: *mut Py_ssize_t,
+    ) -> c_int;
+    pub fn PySlice_GetIndicesEx(
+        r: *mut PyObject,
+        length: Py_ssize_t,
+        start: *mut Py_ssize_t,
+        stop: *mut Py_ssize_t,
+        step: *mut Py_ssize_t,
+        slicelength: *mut Py_ssize_t,
+    ) -> c_int;
 }
-

src/ffi2/stringobject.rs

@@ -1,13 +1,13 @@
-use std::os::raw::{c_char, c_int, c_long};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int, c_long};
 
 #[repr(C)]
 #[allow(missing_copy_implementations)]
 pub struct PyStringObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -17,69 +17,83 @@ pub struct PyStringObject {
     pub ob_sval: [c_char; 1],
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyBaseString_Type: PyTypeObject;
     pub static mut PyString_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyString_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyString_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_STRING_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyBaseString_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyBaseString_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(
-        Py_TYPE(op), Py_TPFLAGS_STRING_SUBCLASS | Py_TPFLAGS_UNICODE_SUBCLASS)
+        Py_TYPE(op),
+        Py_TPFLAGS_STRING_SUBCLASS | Py_TPFLAGS_UNICODE_SUBCLASS,
+    )
 }
 
 #[inline(always)]
-pub unsafe fn PyString_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyString_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyString_Type;
+    let u: *mut PyTypeObject = &mut PyString_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyString_GET_SIZE(op : *mut PyObject) -> Py_ssize_t {
+pub unsafe fn PyString_GET_SIZE(op: *mut PyObject) -> Py_ssize_t {
     (*(op as *mut PyStringObject)).ob_size
 }
 
 #[inline(always)]
-pub unsafe fn PyString_AS_STRING(op : *mut PyObject) -> *mut c_char {
+pub unsafe fn PyString_AS_STRING(op: *mut PyObject) -> *mut c_char {
     (*(op as *mut PyStringObject)).ob_sval.as_mut_ptr()
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyString_FromString(v: *const c_char) -> *mut PyObject;
-    pub fn PyString_FromStringAndSize(v: *const c_char,
+    pub fn PyString_FromStringAndSize(v: *const c_char, len: Py_ssize_t) -> *mut PyObject;
-                                      len: Py_ssize_t) -> *mut PyObject;
     pub fn PyString_FromFormat(format: *const c_char, ...) -> *mut PyObject;
     pub fn PyString_Size(string: *mut PyObject) -> Py_ssize_t;
     pub fn PyString_AsString(string: *mut PyObject) -> *mut c_char;
-    pub fn PyString_AsStringAndSize(obj: *mut PyObject,
+    pub fn PyString_AsStringAndSize(
-                                    s: *mut *mut c_char,
+        obj: *mut PyObject,
-                                    len: *mut Py_ssize_t) -> c_int;
+        s: *mut *mut c_char,
+        len: *mut Py_ssize_t,
+    ) -> c_int;
     pub fn PyString_Concat(string: *mut *mut PyObject, newpart: *mut PyObject);
     pub fn PyString_ConcatAndDel(string: *mut *mut PyObject, newpart: *mut PyObject);
     pub fn _PyString_Resize(string: *mut *mut PyObject, newsize: Py_ssize_t) -> c_int;
-    pub fn PyString_Format(format: *mut PyObject, args: *mut PyObject)
+    pub fn PyString_Format(format: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
-                           -> *mut PyObject;
     pub fn PyString_InternInPlace(string: *mut *mut PyObject);
     pub fn PyString_InternFromString(v: *const c_char) -> *mut PyObject;
-    pub fn PyString_Decode(s: *const c_char, size: Py_ssize_t,
+    pub fn PyString_Decode(
-                           encoding: *const c_char,
+        s: *const c_char,
-                           errors: *const c_char) -> *mut PyObject;
+        size: Py_ssize_t,
-    pub fn PyString_AsDecodedObject(str: *mut PyObject,
+        encoding: *const c_char,
-                                    encoding: *const c_char,
+        errors: *const c_char,
-                                    errors: *const c_char) -> *mut PyObject;
+    ) -> *mut PyObject;
-    pub fn PyString_Encode(s: *const c_char, size: Py_ssize_t,
+    pub fn PyString_AsDecodedObject(
-                           encoding: *const c_char,
+        str: *mut PyObject,
-                           errors: *const c_char) -> *mut PyObject;
+        encoding: *const c_char,
-    pub fn PyString_AsEncodedObject(str: *mut PyObject,
+        errors: *const c_char,
-                                    encoding: *const c_char,
+    ) -> *mut PyObject;
-                                    errors: *const c_char) -> *mut PyObject;
+    pub fn PyString_Encode(
+        s: *const c_char,
+        size: Py_ssize_t,
+        encoding: *const c_char,
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    pub fn PyString_AsEncodedObject(
+        str: *mut PyObject,
+        encoding: *const c_char,
+        errors: *const c_char,
+    ) -> *mut PyObject;
 
-    /*
+/*
     pub fn PyString_Repr(arg1: *mut PyObject, arg2: c_int)
      -> *mut PyObject;
     pub fn _PyString_Eq(arg1: *mut PyObject, arg2: *mut PyObject)
@@ -129,4 +143,3 @@ pub unsafe fn PyString_AS_STRING(op : *mut PyObject) -> *mut c_char {
                                    format_spec_len: Py_ssize_t)
      -> *mut PyObject;*/
 }
-

src/ffi2/structmember.rs

@@ -1,6 +1,6 @@
-use std::os::raw::{c_char, c_int};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::PyObject;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -9,52 +9,50 @@ pub struct PyMemberDef {
     pub type_code: c_int,
     pub offset: Py_ssize_t,
     pub flags: c_int,
-    pub doc: *mut c_char
+    pub doc: *mut c_char,
 }
 
 /* Types */
-pub const T_SHORT  : c_int = 0;
+pub const T_SHORT: c_int = 0;
-pub const T_INT    : c_int = 1;
+pub const T_INT: c_int = 1;
-pub const T_LONG   : c_int = 2;
+pub const T_LONG: c_int = 2;
-pub const T_FLOAT  : c_int = 3;
+pub const T_FLOAT: c_int = 3;
-pub const T_DOUBLE : c_int = 4;
+pub const T_DOUBLE: c_int = 4;
-pub const T_STRING : c_int = 5;
+pub const T_STRING: c_int = 5;
-pub const T_OBJECT : c_int = 6;
+pub const T_OBJECT: c_int = 6;
 /* XXX the ordering here is weird for binary compatibility */
-pub const T_CHAR   : c_int = 7;       /* 1-character string */
+pub const T_CHAR: c_int = 7; /* 1-character string */
-pub const T_BYTE   : c_int = 8;       /* 8-bit signed int */
+pub const T_BYTE: c_int = 8; /* 8-bit signed int */
 /* unsigned variants: */
-pub const T_UBYTE  : c_int = 9;
+pub const T_UBYTE: c_int = 9;
-pub const T_USHORT : c_int = 10;
+pub const T_USHORT: c_int = 10;
-pub const T_UINT   : c_int = 11;
+pub const T_UINT: c_int = 11;
-pub const T_ULONG  : c_int = 12;
+pub const T_ULONG: c_int = 12;
 
 /* Added by Jack: strings contained in the structure */
-pub const T_STRING_INPLACE : c_int = 13;
+pub const T_STRING_INPLACE: c_int = 13;
 
 /* Added by Lillo: bools contained in the structure (assumed char) */
-pub const T_BOOL : c_int = 14;
+pub const T_BOOL: c_int = 14;
 
-pub const T_OBJECT_EX : c_int = 16; /* Like T_OBJECT, but raises AttributeError
+pub const T_OBJECT_EX: c_int = 16; /* Like T_OBJECT, but raises AttributeError
                    when the value is NULL, instead of
                    converting to None. */
 
-pub const T_LONGLONG  : c_int = 17;
+pub const T_LONGLONG: c_int = 17;
-pub const T_ULONGLONG : c_int = 18;
+pub const T_ULONGLONG: c_int = 18;
-
-pub const T_PYSSIZET : c_int = 19; /* Py_ssize_t */
 
+pub const T_PYSSIZET: c_int = 19; /* Py_ssize_t */
 
 /* Flags */
-pub const READONLY : c_int = 1;
+pub const READONLY: c_int = 1;
-pub const RO       : c_int = READONLY;                /* Shorthand */
+pub const RO: c_int = READONLY; /* Shorthand */
-pub const READ_RESTRICTED : c_int = 2;
+pub const READ_RESTRICTED: c_int = 2;
-pub const PY_WRITE_RESTRICTED : c_int = 4;
+pub const PY_WRITE_RESTRICTED: c_int = 4;
-pub const RESTRICTED : c_int = (READ_RESTRICTED | PY_WRITE_RESTRICTED);
+pub const RESTRICTED: c_int = (READ_RESTRICTED | PY_WRITE_RESTRICTED);
 
-
+#[cfg_attr(windows, link(name = "pythonXY"))]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+extern "C" {
     pub fn PyMember_GetOne(addr: *const c_char, l: *mut PyMemberDef) -> *mut PyObject;
     pub fn PyMember_SetOne(addr: *mut c_char, l: *mut PyMemberDef, value: *mut PyObject) -> c_int;
 }
-

src/ffi2/traceback.rs

@@ -1,33 +1,32 @@
-use std::os::raw::c_int;
+use ffi2::frameobject::PyFrameObject;
 use ffi2::object::*;
 use ffi2::pyport::Py_ssize_t;
-use ffi2::frameobject::PyFrameObject;
+use std::os::raw::c_int;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyTracebackObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
     pub tb_next: *mut PyTracebackObject,
     pub tb_frame: *mut PyFrameObject,
     pub tb_lasti: c_int,
-    pub tb_lineno: c_int
+    pub tb_lineno: c_int,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyTraceBack_Here(arg1: *mut PyFrameObject) -> c_int;
-    pub fn PyTraceBack_Print(arg1: *mut PyObject, arg2: *mut PyObject)
+    pub fn PyTraceBack_Print(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
-     -> c_int;
 
     pub static mut PyTraceBack_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyTraceBack_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyTraceBack_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyTraceBack_Type) as c_int
 }
-

src/ffi2/tupleobject.rs

@@ -1,13 +1,13 @@
-use std::os::raw::c_int;
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyTupleObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -15,26 +15,29 @@ pub struct PyTupleObject {
     pub ob_item: [*mut PyObject; 1],
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyTuple_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyTuple_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyTuple_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyTuple_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyTuple_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyTuple_Type;
+    let u: *mut PyTypeObject = &mut PyTuple_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
-
 // Macro, trading safety for speed
 #[inline(always)]
 pub unsafe fn PyTuple_GET_ITEM(op: *mut PyObject, i: Py_ssize_t) -> *mut PyObject {
-   *(*(op as *mut PyTupleObject)).ob_item.as_ptr().offset(i as isize)
+    *(*(op as *mut PyTupleObject))
+        .ob_item
+        .as_ptr()
+        .offset(i as isize)
 }
 
 #[inline(always)]
@@ -45,17 +48,19 @@ pub unsafe fn PyTuple_GET_SIZE(op: *mut PyObject) -> Py_ssize_t {
 /// Macro, *only* to be used to fill in brand new tuples
 #[inline(always)]
 pub unsafe fn PyTuple_SET_ITEM(op: *mut PyObject, i: Py_ssize_t, v: *mut PyObject) {
-   *(*(op as *mut PyTupleObject)).ob_item.as_mut_ptr().offset(i as isize) = v;
+    *(*(op as *mut PyTupleObject))
+        .ob_item
+        .as_mut_ptr()
+        .offset(i as isize) = v;
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyTuple_New(size: Py_ssize_t) -> *mut PyObject;
     pub fn PyTuple_Size(p: *mut PyObject) -> Py_ssize_t;
     pub fn PyTuple_GetItem(p: *mut PyObject, pos: Py_ssize_t) -> *mut PyObject;
-    pub fn PyTuple_SetItem(p: *mut PyObject, pos: Py_ssize_t,
+    pub fn PyTuple_SetItem(p: *mut PyObject, pos: Py_ssize_t, o: *mut PyObject) -> c_int;
-                           o: *mut PyObject) -> c_int;
+    pub fn PyTuple_GetSlice(p: *mut PyObject, low: Py_ssize_t, high: Py_ssize_t) -> *mut PyObject;
-    pub fn PyTuple_GetSlice(p: *mut PyObject, low: Py_ssize_t,
-                            high: Py_ssize_t) -> *mut PyObject;
     pub fn _PyTuple_Resize(p: *mut *mut PyObject, newsize: Py_ssize_t) -> c_int;
     pub fn PyTuple_Pack(n: Py_ssize_t, ...) -> *mut PyObject;
     //pub fn _PyTuple_MaybeUntrack(arg1: *mut PyObject);

src/ffi2/unicodeobject.rs

@@ -1,26 +1,26 @@
-use libc::wchar_t;
-use std::os::raw::{c_char, c_int, c_long, c_double};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use libc::wchar_t;
+use std::os::raw::{c_char, c_double, c_int, c_long};
 
-#[cfg(py_sys_config="Py_UNICODE_SIZE_4")]
+#[cfg(py_sys_config = "Py_UNICODE_SIZE_4")]
-pub const Py_UNICODE_SIZE : Py_ssize_t = 4;
+pub const Py_UNICODE_SIZE: Py_ssize_t = 4;
-#[cfg(not(py_sys_config="Py_UNICODE_SIZE_4"))]
+#[cfg(not(py_sys_config = "Py_UNICODE_SIZE_4"))]
-pub const Py_UNICODE_SIZE : Py_ssize_t = 2;
+pub const Py_UNICODE_SIZE: Py_ssize_t = 2;
 
 pub type Py_UCS4 = u32;
 
-#[cfg(py_sys_config="Py_UNICODE_SIZE_4")]
+#[cfg(py_sys_config = "Py_UNICODE_SIZE_4")]
 pub type Py_UNICODE = u32;
-#[cfg(not(py_sys_config="Py_UNICODE_SIZE_4"))]
+#[cfg(not(py_sys_config = "Py_UNICODE_SIZE_4"))]
 pub type Py_UNICODE = u16;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyUnicodeObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -30,18 +30,19 @@ pub struct PyUnicodeObject {
     pub defenc: *mut PyObject,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyUnicode_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyUnicode_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyUnicode_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyUnicode_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyUnicode_CheckExact(op: *mut PyObject) -> c_int {
-    let u : *mut PyTypeObject = &mut PyUnicode_Type;
+    let u: *mut PyTypeObject = &mut PyUnicode_Type;
     (Py_TYPE(op) == u) as c_int
 }
 
@@ -65,178 +66,278 @@ pub unsafe fn PyUnicode_AS_DATA(o: *mut PyObject) -> *const c_char {
     (*(o as *mut PyUnicodeObject)).data as *const c_char
 }
 
-pub const Py_UNICODE_REPLACEMENT_CHARACTER : Py_UNICODE = 0xFFFD;
+pub const Py_UNICODE_REPLACEMENT_CHARACTER: Py_UNICODE = 0xFFFD;
-
 
 #[allow(dead_code)]
-#[cfg(py_sys_config="Py_UNICODE_SIZE_4")]
+#[cfg(py_sys_config = "Py_UNICODE_SIZE_4")]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     fn PyUnicodeUCS4_FromUnicode(u: *const Py_UNICODE, size: Py_ssize_t) -> *mut PyObject;
-    fn PyUnicodeUCS4_FromStringAndSize(u: *const c_char,
+    fn PyUnicodeUCS4_FromStringAndSize(u: *const c_char, size: Py_ssize_t) -> *mut PyObject;
-                                       size: Py_ssize_t) -> *mut PyObject;
     fn PyUnicodeUCS4_FromString(u: *const c_char) -> *mut PyObject;
     fn PyUnicodeUCS4_AsUnicode(unicode: *mut PyObject) -> *mut Py_UNICODE;
     fn PyUnicodeUCS4_GetSize(unicode: *mut PyObject) -> Py_ssize_t;
     fn PyUnicodeUCS4_GetMax() -> Py_UNICODE;
-    fn PyUnicodeUCS4_Resize(unicode: *mut *mut PyObject,
+    fn PyUnicodeUCS4_Resize(unicode: *mut *mut PyObject, length: Py_ssize_t) -> c_int;
-                            length: Py_ssize_t) -> c_int;
+    fn PyUnicodeUCS4_FromEncodedObject(
-    fn PyUnicodeUCS4_FromEncodedObject(obj: *mut PyObject,
+        obj: *mut PyObject,
-                                       encoding: *const c_char,
+        encoding: *const c_char,
-                                       errors: *const c_char) -> *mut PyObject;
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_FromObject(obj: *mut PyObject) -> *mut PyObject;
     fn PyUnicodeUCS4_FromFormatV(arg1: *const c_char, ...) -> *mut PyObject;
     fn PyUnicodeUCS4_FromFormat(arg1: *const c_char, ...) -> *mut PyObject;
-    fn _PyUnicode_FormatAdvanced(obj: *mut PyObject,
+    fn _PyUnicode_FormatAdvanced(
-                                     format_spec: *mut Py_UNICODE,
+        obj: *mut PyObject,
-                                     format_spec_len: Py_ssize_t) -> *mut PyObject;
+        format_spec: *mut Py_UNICODE,
-    fn PyUnicodeUCS4_FromWideChar(w: *const wchar_t, size: Py_ssize_t)
+        format_spec_len: Py_ssize_t,
-                                  -> *mut PyObject;
+    ) -> *mut PyObject;
-    fn PyUnicodeUCS4_AsWideChar(unicode: *mut PyUnicodeObject,
+    fn PyUnicodeUCS4_FromWideChar(w: *const wchar_t, size: Py_ssize_t) -> *mut PyObject;
-                                w: *mut wchar_t, size: Py_ssize_t) -> Py_ssize_t;
+    fn PyUnicodeUCS4_AsWideChar(
+        unicode: *mut PyUnicodeObject,
+        w: *mut wchar_t,
+        size: Py_ssize_t,
+    ) -> Py_ssize_t;
     fn PyUnicodeUCS4_FromOrdinal(ordinal: c_int) -> *mut PyObject;
     fn PyUnicodeUCS4_ClearFreelist() -> c_int;
-    fn _PyUnicodeUCS4_AsDefaultEncodedString(arg1: *mut PyObject, arg2: *const c_char)
+    fn _PyUnicodeUCS4_AsDefaultEncodedString(
-                                             -> *mut PyObject;
+        arg1: *mut PyObject,
+        arg2: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_GetDefaultEncoding() -> *const c_char;
     fn PyUnicodeUCS4_SetDefaultEncoding(encoding: *const c_char) -> c_int;
-    fn PyUnicodeUCS4_Decode(s: *const c_char, size: Py_ssize_t,
+    fn PyUnicodeUCS4_Decode(
-                            encoding: *const c_char,
+        s: *const c_char,
-                            errors: *const c_char) -> *mut PyObject;
+        size: Py_ssize_t,
-    fn PyUnicodeUCS4_Encode(s: *const Py_UNICODE, size: Py_ssize_t,
+        encoding: *const c_char,
-                            encoding: *const c_char,
+        errors: *const c_char,
-                            errors: *const c_char) -> *mut PyObject;
+    ) -> *mut PyObject;
-    fn PyUnicodeUCS4_AsEncodedObject(unicode: *mut PyObject,
+    fn PyUnicodeUCS4_Encode(
-                                     encoding: *const c_char,
+        s: *const Py_UNICODE,
-                                     errors: *const c_char) -> *mut PyObject;
+        size: Py_ssize_t,
-    fn PyUnicodeUCS4_AsEncodedString(unicode: *mut PyObject,
+        encoding: *const c_char,
-                                     encoding: *const c_char,
+        errors: *const c_char,
-                                     errors: *const c_char) -> *mut PyObject;
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS4_AsEncodedObject(
+        unicode: *mut PyObject,
+        encoding: *const c_char,
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS4_AsEncodedString(
+        unicode: *mut PyObject,
+        encoding: *const c_char,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicode_BuildEncodingMap(string: *mut PyObject) -> *mut PyObject;
-    fn PyUnicode_DecodeUTF7(string: *const c_char,
+    fn PyUnicode_DecodeUTF7(
-                            length: Py_ssize_t,
+        string: *const c_char,
-                            errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicode_DecodeUTF7Stateful(string: *const c_char,
+        errors: *const c_char,
-                                    length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                    errors: *const c_char,
+    fn PyUnicode_DecodeUTF7Stateful(
-                                    consumed: *mut Py_ssize_t) -> *mut PyObject;
+        string: *const c_char,
-    fn PyUnicode_EncodeUTF7(data: *const Py_UNICODE, length: Py_ssize_t,
+        length: Py_ssize_t,
-                            base64SetO: c_int,
+        errors: *const c_char,
-                            base64WhiteSpace: c_int,
+        consumed: *mut Py_ssize_t,
-                            errors: *const c_char) -> *mut PyObject;
+    ) -> *mut PyObject;
-    fn PyUnicodeUCS4_DecodeUTF8(string: *const c_char,
+    fn PyUnicode_EncodeUTF7(
-                                length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS4_DecodeUTF8Stateful(string: *const c_char,
+        base64SetO: c_int,
-                                        length: Py_ssize_t,
+        base64WhiteSpace: c_int,
-                                        errors: *const c_char,
+        errors: *const c_char,
-                                        consumed: *mut Py_ssize_t) -> *mut PyObject;
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS4_DecodeUTF8(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS4_DecodeUTF8Stateful(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+        consumed: *mut Py_ssize_t,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_AsUTF8String(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_EncodeUTF8(data: *const Py_UNICODE,
+    fn PyUnicodeUCS4_EncodeUTF8(
-                                length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS4_DecodeUTF32(string: *const c_char,
+        errors: *const c_char,
-                                 length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                 errors: *const c_char,
+    fn PyUnicodeUCS4_DecodeUTF32(
-                                 byteorder: *mut c_int) -> *mut PyObject;
+        string: *const c_char,
-    fn PyUnicodeUCS4_DecodeUTF32Stateful(string: *const c_char,
+        length: Py_ssize_t,
-                                         length: Py_ssize_t,
+        errors: *const c_char,
-                                         errors: *const c_char,
+        byteorder: *mut c_int,
-                                         byteorder: *mut c_int,
+    ) -> *mut PyObject;
-                                         consumed: *mut Py_ssize_t) -> *mut PyObject;
+    fn PyUnicodeUCS4_DecodeUTF32Stateful(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+        byteorder: *mut c_int,
+        consumed: *mut Py_ssize_t,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_AsUTF32String(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_EncodeUTF32(data: *const Py_UNICODE,
+    fn PyUnicodeUCS4_EncodeUTF32(
-                                 length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                 errors: *const c_char,
+        length: Py_ssize_t,
-                                 byteorder: c_int) -> *mut PyObject;
+        errors: *const c_char,
-    fn PyUnicodeUCS4_DecodeUTF16(string: *const c_char,
+        byteorder: c_int,
-                                 length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                 errors: *const c_char,
+    fn PyUnicodeUCS4_DecodeUTF16(
-                                 byteorder: *mut c_int) -> *mut PyObject;
+        string: *const c_char,
-    fn PyUnicodeUCS4_DecodeUTF16Stateful(string: *const c_char,
+        length: Py_ssize_t,
-                                         length: Py_ssize_t,
+        errors: *const c_char,
-                                         errors: *const c_char,
+        byteorder: *mut c_int,
-                                         byteorder: *mut c_int,
+    ) -> *mut PyObject;
-                                         consumed: *mut Py_ssize_t) -> *mut PyObject;
+    fn PyUnicodeUCS4_DecodeUTF16Stateful(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+        byteorder: *mut c_int,
+        consumed: *mut Py_ssize_t,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_AsUTF16String(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_EncodeUTF16(data: *const Py_UNICODE,
+    fn PyUnicodeUCS4_EncodeUTF16(
-                                 length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                 errors: *const c_char,
+        length: Py_ssize_t,
-                                 byteorder: c_int) -> *mut PyObject;
+        errors: *const c_char,
-    fn PyUnicodeUCS4_DecodeUnicodeEscape(string: *const c_char,
+        byteorder: c_int,
-                                         length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                         errors: *const c_char) -> *mut PyObject;
+    fn PyUnicodeUCS4_DecodeUnicodeEscape(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_AsUnicodeEscapeString(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_EncodeUnicodeEscape(data: *const Py_UNICODE,
+    fn PyUnicodeUCS4_EncodeUnicodeEscape(
-                                         length: Py_ssize_t) -> *mut PyObject;
+        data: *const Py_UNICODE,
-    fn PyUnicodeUCS4_DecodeRawUnicodeEscape(string: *const c_char,
+        length: Py_ssize_t,
-                                            length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                            errors: *const c_char) -> *mut PyObject;
+    fn PyUnicodeUCS4_DecodeRawUnicodeEscape(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_AsRawUnicodeEscapeString(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_EncodeRawUnicodeEscape(data: *const Py_UNICODE,
+    fn PyUnicodeUCS4_EncodeRawUnicodeEscape(
-                                            length: Py_ssize_t) -> *mut PyObject;
+        data: *const Py_UNICODE,
-    fn _PyUnicode_DecodeUnicodeInternal(string: *const c_char,
+        length: Py_ssize_t,
-                                        length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                        errors: *const c_char) -> *mut PyObject;
+    fn _PyUnicode_DecodeUnicodeInternal(
-    fn PyUnicodeUCS4_DecodeLatin1(string: *const c_char,
+        string: *const c_char,
-                                  length: Py_ssize_t,
+        length: Py_ssize_t,
-                                  errors: *const c_char) -> *mut PyObject;
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS4_DecodeLatin1(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_AsLatin1String(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_EncodeLatin1(data: *const Py_UNICODE,
+    fn PyUnicodeUCS4_EncodeLatin1(
-                                  length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                  errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS4_DecodeASCII(string: *const c_char,
+        errors: *const c_char,
-                                 length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                 errors: *const c_char) -> *mut PyObject;
+    fn PyUnicodeUCS4_DecodeASCII(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_AsASCIIString(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_EncodeASCII(data: *const Py_UNICODE,
+    fn PyUnicodeUCS4_EncodeASCII(
-                                 length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                 errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS4_DecodeCharmap(string: *const c_char,
+        errors: *const c_char,
-                                   length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                   mapping: *mut PyObject,
+    fn PyUnicodeUCS4_DecodeCharmap(
-                                   errors: *const c_char) -> *mut PyObject;
+        string: *const c_char,
-    fn PyUnicodeUCS4_AsCharmapString(unicode: *mut PyObject,
+        length: Py_ssize_t,
-                                     mapping: *mut PyObject) -> *mut PyObject;
+        mapping: *mut PyObject,
-    fn PyUnicodeUCS4_EncodeCharmap(data: *const Py_UNICODE,
+        errors: *const c_char,
-                                   length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                   mapping: *mut PyObject,
+    fn PyUnicodeUCS4_AsCharmapString(
-                                   errors: *const c_char) -> *mut PyObject;
+        unicode: *mut PyObject,
-    fn PyUnicodeUCS4_TranslateCharmap(data: *const Py_UNICODE,
+        mapping: *mut PyObject,
-                                      length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                      table: *mut PyObject,
+    fn PyUnicodeUCS4_EncodeCharmap(
-                                      errors: *const c_char) -> *mut PyObject;
+        data: *const Py_UNICODE,
-    fn PyUnicodeUCS4_EncodeDecimal(s: *mut Py_UNICODE, length: Py_ssize_t,
+        length: Py_ssize_t,
-                                   output: *mut c_char,
+        mapping: *mut PyObject,
-                                   errors: *const c_char) -> c_int;
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS4_TranslateCharmap(
+        data: *const Py_UNICODE,
+        length: Py_ssize_t,
+        table: *mut PyObject,
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS4_EncodeDecimal(
+        s: *mut Py_UNICODE,
+        length: Py_ssize_t,
+        output: *mut c_char,
+        errors: *const c_char,
+    ) -> c_int;
     fn PyUnicodeUCS4_Concat(left: *mut PyObject, right: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_Split(s: *mut PyObject, sep: *mut PyObject,
+    fn PyUnicodeUCS4_Split(
-                           maxsplit: Py_ssize_t) -> *mut PyObject;
+        s: *mut PyObject,
+        sep: *mut PyObject,
+        maxsplit: Py_ssize_t,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_Splitlines(s: *mut PyObject, keepends: c_int) -> *mut PyObject;
     fn PyUnicodeUCS4_Partition(s: *mut PyObject, sep: *mut PyObject) -> *mut PyObject;
     fn PyUnicodeUCS4_RPartition(s: *mut PyObject, sep: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS4_RSplit(s: *mut PyObject, sep: *mut PyObject,
+    fn PyUnicodeUCS4_RSplit(
-                            maxsplit: Py_ssize_t) -> *mut PyObject;
+        s: *mut PyObject,
-    fn PyUnicodeUCS4_Translate(str: *mut PyObject, table: *mut PyObject, errors: *const c_char)
+        sep: *mut PyObject,
-                               -> *mut PyObject;
+        maxsplit: Py_ssize_t,
-    fn PyUnicodeUCS4_Join(separator: *mut PyObject, seq: *mut PyObject)
+    ) -> *mut PyObject;
-                          -> *mut PyObject;
+    fn PyUnicodeUCS4_Translate(
-    fn PyUnicodeUCS4_Tailmatch(str: *mut PyObject, substr: *mut PyObject,
+        str: *mut PyObject,
-                               start: Py_ssize_t, end: Py_ssize_t,
+        table: *mut PyObject,
-                               direction: c_int) -> Py_ssize_t;
+        errors: *const c_char,
-    fn PyUnicodeUCS4_Find(str: *mut PyObject, substr: *mut PyObject,
+    ) -> *mut PyObject;
-                          start: Py_ssize_t, end: Py_ssize_t,
+    fn PyUnicodeUCS4_Join(separator: *mut PyObject, seq: *mut PyObject) -> *mut PyObject;
-                          direction: c_int) -> Py_ssize_t;
+    fn PyUnicodeUCS4_Tailmatch(
-    fn PyUnicodeUCS4_Count(str: *mut PyObject, substr: *mut PyObject,
+        str: *mut PyObject,
-                           start: Py_ssize_t, end: Py_ssize_t) -> Py_ssize_t;
+        substr: *mut PyObject,
-    fn PyUnicodeUCS4_Replace(str: *mut PyObject, substr: *mut PyObject,
+        start: Py_ssize_t,
-                             replstr: *mut PyObject, maxcount: Py_ssize_t) -> *mut PyObject;
+        end: Py_ssize_t,
+        direction: c_int,
+    ) -> Py_ssize_t;
+    fn PyUnicodeUCS4_Find(
+        str: *mut PyObject,
+        substr: *mut PyObject,
+        start: Py_ssize_t,
+        end: Py_ssize_t,
+        direction: c_int,
+    ) -> Py_ssize_t;
+    fn PyUnicodeUCS4_Count(
+        str: *mut PyObject,
+        substr: *mut PyObject,
+        start: Py_ssize_t,
+        end: Py_ssize_t,
+    ) -> Py_ssize_t;
+    fn PyUnicodeUCS4_Replace(
+        str: *mut PyObject,
+        substr: *mut PyObject,
+        replstr: *mut PyObject,
+        maxcount: Py_ssize_t,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_Compare(left: *mut PyObject, right: *mut PyObject) -> c_int;
-    fn PyUnicodeUCS4_RichCompare(left: *mut PyObject,
+    fn PyUnicodeUCS4_RichCompare(
-                                 right: *mut PyObject, op: c_int) -> *mut PyObject;
+        left: *mut PyObject,
+        right: *mut PyObject,
+        op: c_int,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS4_Format(format: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
     fn PyUnicodeUCS4_Contains(container: *mut PyObject, element: *mut PyObject) -> c_int;
-    fn _PyUnicode_XStrip(_self: *mut PyUnicodeObject,
+    fn _PyUnicode_XStrip(
-                         striptype: c_int, sepobj: *mut PyObject) -> *mut PyObject;
+        _self: *mut PyUnicodeObject,
+        striptype: c_int,
+        sepobj: *mut PyObject,
+    ) -> *mut PyObject;
     fn _PyUnicodeUCS4_IsLowercase(ch: Py_UNICODE) -> c_int;
     fn _PyUnicodeUCS4_IsUppercase(ch: Py_UNICODE) -> c_int;
     fn _PyUnicodeUCS4_IsTitlecase(ch: Py_UNICODE) -> c_int;
@@ -255,192 +356,275 @@ pub const Py_UNICODE_REPLACEMENT_CHARACTER : Py_UNICODE = 0xFFFD;
 }
 
 #[allow(dead_code)]
-#[cfg(not(py_sys_config="Py_UNICODE_SIZE_4"))]
+#[cfg(not(py_sys_config = "Py_UNICODE_SIZE_4"))]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    fn PyUnicodeUCS2_FromUnicode(u: *const Py_UNICODE, size: Py_ssize_t)
+extern "C" {
-                                 -> *mut PyObject;
+    fn PyUnicodeUCS2_FromUnicode(u: *const Py_UNICODE, size: Py_ssize_t) -> *mut PyObject;
-    fn PyUnicodeUCS2_FromStringAndSize(u: *const c_char,
+    fn PyUnicodeUCS2_FromStringAndSize(u: *const c_char, size: Py_ssize_t) -> *mut PyObject;
-                                       size: Py_ssize_t) -> *mut PyObject;
+    fn PyUnicodeUCS2_FromString(u: *const c_char) -> *mut PyObject;
-    fn PyUnicodeUCS2_FromString(u: *const c_char)
-                                -> *mut PyObject;
     fn PyUnicodeUCS2_AsUnicode(unicode: *mut PyObject) -> *mut Py_UNICODE;
     fn PyUnicodeUCS2_GetSize(unicode: *mut PyObject) -> Py_ssize_t;
     fn PyUnicodeUCS2_GetMax() -> Py_UNICODE;
-    fn PyUnicodeUCS2_Resize(unicode: *mut *mut PyObject,
+    fn PyUnicodeUCS2_Resize(unicode: *mut *mut PyObject, length: Py_ssize_t) -> c_int;
-                                length: Py_ssize_t) -> c_int;
+    fn PyUnicodeUCS2_FromEncodedObject(
-    fn PyUnicodeUCS2_FromEncodedObject(obj: *mut PyObject,
+        obj: *mut PyObject,
-                                       encoding: *const c_char,
+        encoding: *const c_char,
-                                       errors: *const c_char) -> *mut PyObject;
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_FromObject(obj: *mut PyObject) -> *mut PyObject;
     fn PyUnicodeUCS2_FromFormatV(arg1: *const c_char, ...) -> *mut PyObject;
     fn PyUnicodeUCS2_FromFormat(arg1: *const c_char, ...) -> *mut PyObject;
-    fn _PyUnicode_FormatAdvanced(obj: *mut PyObject,
+    fn _PyUnicode_FormatAdvanced(
-                                 format_spec: *mut Py_UNICODE,
+        obj: *mut PyObject,
-                                 format_spec_len: Py_ssize_t) -> *mut PyObject;
+        format_spec: *mut Py_UNICODE,
-    fn PyUnicodeUCS2_FromWideChar(w: *const wchar_t, size: Py_ssize_t)
+        format_spec_len: Py_ssize_t,
-                                  -> *mut PyObject;
+    ) -> *mut PyObject;
-    fn PyUnicodeUCS2_AsWideChar(unicode: *mut PyUnicodeObject,
+    fn PyUnicodeUCS2_FromWideChar(w: *const wchar_t, size: Py_ssize_t) -> *mut PyObject;
-                                w: *mut wchar_t, size: Py_ssize_t)
+    fn PyUnicodeUCS2_AsWideChar(
-                                -> Py_ssize_t;
+        unicode: *mut PyUnicodeObject,
+        w: *mut wchar_t,
+        size: Py_ssize_t,
+    ) -> Py_ssize_t;
     fn PyUnicodeUCS2_FromOrdinal(ordinal: c_int) -> *mut PyObject;
     fn PyUnicodeUCS2_ClearFreelist() -> c_int;
-    fn _PyUnicodeUCS2_AsDefaultEncodedString(arg1: *mut PyObject,
+    fn _PyUnicodeUCS2_AsDefaultEncodedString(
-                                             arg2: *const c_char) -> *mut PyObject;
+        arg1: *mut PyObject,
+        arg2: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_GetDefaultEncoding() -> *const c_char;
     fn PyUnicodeUCS2_SetDefaultEncoding(encoding: *const c_char) -> c_int;
-    fn PyUnicodeUCS2_Decode(s: *const c_char, size: Py_ssize_t,
+    fn PyUnicodeUCS2_Decode(
-                                encoding: *const c_char,
+        s: *const c_char,
-                                errors: *const c_char) -> *mut PyObject;
+        size: Py_ssize_t,
-    fn PyUnicodeUCS2_Encode(s: *const Py_UNICODE, size: Py_ssize_t,
+        encoding: *const c_char,
-                            encoding: *const c_char,
+        errors: *const c_char,
-                            errors: *const c_char) -> *mut PyObject;
+    ) -> *mut PyObject;
-    fn PyUnicodeUCS2_AsEncodedObject(unicode: *mut PyObject,
+    fn PyUnicodeUCS2_Encode(
-                                     encoding: *const c_char,
+        s: *const Py_UNICODE,
-                                     errors: *const c_char) -> *mut PyObject;
+        size: Py_ssize_t,
-    fn PyUnicodeUCS2_AsEncodedString(unicode: *mut PyObject,
+        encoding: *const c_char,
-                                     encoding: *const c_char,
+        errors: *const c_char,
-                                     errors: *const c_char) -> *mut PyObject;
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS2_AsEncodedObject(
+        unicode: *mut PyObject,
+        encoding: *const c_char,
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS2_AsEncodedString(
+        unicode: *mut PyObject,
+        encoding: *const c_char,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicode_BuildEncodingMap(string: *mut PyObject) -> *mut PyObject;
-    fn PyUnicode_DecodeUTF7(string: *const c_char,
+    fn PyUnicode_DecodeUTF7(
-                            length: Py_ssize_t,
+        string: *const c_char,
-                            errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicode_DecodeUTF7Stateful(string: *const c_char,
+        errors: *const c_char,
-                                    length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                    errors: *const c_char,
+    fn PyUnicode_DecodeUTF7Stateful(
-                                    consumed: *mut Py_ssize_t) -> *mut PyObject;
+        string: *const c_char,
-    fn PyUnicode_EncodeUTF7(data: *const Py_UNICODE, length: Py_ssize_t,
+        length: Py_ssize_t,
-                            base64SetO: c_int,
+        errors: *const c_char,
-                            base64WhiteSpace: c_int,
+        consumed: *mut Py_ssize_t,
-                            errors: *const c_char)
+    ) -> *mut PyObject;
-                            -> *mut PyObject;
+    fn PyUnicode_EncodeUTF7(
-    fn PyUnicodeUCS2_DecodeUTF8(string: *const c_char,
+        data: *const Py_UNICODE,
-                                length: Py_ssize_t,
+        length: Py_ssize_t,
-                                errors: *const c_char)
+        base64SetO: c_int,
-                                -> *mut PyObject;
+        base64WhiteSpace: c_int,
-    fn PyUnicodeUCS2_DecodeUTF8Stateful(string: *const c_char,
+        errors: *const c_char,
-                                        length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                        errors: *const c_char,
+    fn PyUnicodeUCS2_DecodeUTF8(
-                                        consumed: *mut Py_ssize_t)
+        string: *const c_char,
-                                        -> *mut PyObject;
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS2_DecodeUTF8Stateful(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+        consumed: *mut Py_ssize_t,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_AsUTF8String(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS2_EncodeUTF8(data: *const Py_UNICODE,
+    fn PyUnicodeUCS2_EncodeUTF8(
-                                length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS2_DecodeUTF32(string: *const c_char,
+        errors: *const c_char,
-                                 length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                 errors: *const c_char,
+    fn PyUnicodeUCS2_DecodeUTF32(
-                                 byteorder: *mut c_int) -> *mut PyObject;
+        string: *const c_char,
-    fn PyUnicodeUCS2_DecodeUTF32Stateful(string: *const c_char,
+        length: Py_ssize_t,
-                                         length: Py_ssize_t,
+        errors: *const c_char,
-                                         errors: *const c_char,
+        byteorder: *mut c_int,
-                                         byteorder: *mut c_int,
+    ) -> *mut PyObject;
-                                         consumed: *mut Py_ssize_t) -> *mut PyObject;
+    fn PyUnicodeUCS2_DecodeUTF32Stateful(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+        byteorder: *mut c_int,
+        consumed: *mut Py_ssize_t,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_AsUTF32String(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS2_EncodeUTF32(data: *const Py_UNICODE,
+    fn PyUnicodeUCS2_EncodeUTF32(
-                                 length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                 errors: *const c_char,
+        length: Py_ssize_t,
-                                 byteorder: c_int) -> *mut PyObject;
+        errors: *const c_char,
-    fn PyUnicodeUCS2_DecodeUTF16(string: *const c_char,
+        byteorder: c_int,
-                                 length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                 errors: *const c_char,
+    fn PyUnicodeUCS2_DecodeUTF16(
-                                 byteorder: *mut c_int) -> *mut PyObject;
+        string: *const c_char,
-    fn PyUnicodeUCS2_DecodeUTF16Stateful(string: *const c_char,
+        length: Py_ssize_t,
-                                         length: Py_ssize_t,
+        errors: *const c_char,
-                                         errors: *const c_char,
+        byteorder: *mut c_int,
-                                         byteorder: *mut c_int,
+    ) -> *mut PyObject;
-                                         consumed: *mut Py_ssize_t) -> *mut PyObject;
+    fn PyUnicodeUCS2_DecodeUTF16Stateful(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+        byteorder: *mut c_int,
+        consumed: *mut Py_ssize_t,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_AsUTF16String(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS2_EncodeUTF16(data: *const Py_UNICODE,
+    fn PyUnicodeUCS2_EncodeUTF16(
-                                 length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                 errors: *const c_char,
+        length: Py_ssize_t,
-                                 byteorder: c_int) -> *mut PyObject;
+        errors: *const c_char,
-    fn PyUnicodeUCS2_DecodeUnicodeEscape(string: *const c_char,
+        byteorder: c_int,
-                                         length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                         errors: *const c_char) -> *mut PyObject;
+    fn PyUnicodeUCS2_DecodeUnicodeEscape(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_AsUnicodeEscapeString(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS2_EncodeUnicodeEscape(data: *const Py_UNICODE,
+    fn PyUnicodeUCS2_EncodeUnicodeEscape(
-                                         length: Py_ssize_t) -> *mut PyObject;
+        data: *const Py_UNICODE,
-    fn PyUnicodeUCS2_DecodeRawUnicodeEscape(string: *const c_char,
+        length: Py_ssize_t,
-                                            length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                            errors: *const c_char) -> *mut PyObject;
+    fn PyUnicodeUCS2_DecodeRawUnicodeEscape(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_AsRawUnicodeEscapeString(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS2_EncodeRawUnicodeEscape(data: *const Py_UNICODE,
+    fn PyUnicodeUCS2_EncodeRawUnicodeEscape(
-                                            length: Py_ssize_t) -> *mut PyObject;
+        data: *const Py_UNICODE,
-    fn _PyUnicode_DecodeUnicodeInternal(string: *const c_char,
+        length: Py_ssize_t,
-                                        length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                        errors: *const c_char) -> *mut PyObject;
+    fn _PyUnicode_DecodeUnicodeInternal(
-    fn PyUnicodeUCS2_DecodeLatin1(string: *const c_char,
+        string: *const c_char,
-                                  length: Py_ssize_t,
+        length: Py_ssize_t,
-                                  errors: *const c_char) -> *mut PyObject;
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS2_DecodeLatin1(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_AsLatin1String(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS2_EncodeLatin1(data: *const Py_UNICODE,
+    fn PyUnicodeUCS2_EncodeLatin1(
-                                  length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                  errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS2_DecodeASCII(string: *const c_char,
+        errors: *const c_char,
-                                 length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                 errors: *const c_char) -> *mut PyObject;
+    fn PyUnicodeUCS2_DecodeASCII(
+        string: *const c_char,
+        length: Py_ssize_t,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     fn PyUnicodeUCS2_AsASCIIString(unicode: *mut PyObject) -> *mut PyObject;
-    fn PyUnicodeUCS2_EncodeASCII(data: *const Py_UNICODE,
+    fn PyUnicodeUCS2_EncodeASCII(
-                                 length: Py_ssize_t,
+        data: *const Py_UNICODE,
-                                 errors: *const c_char) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS2_DecodeCharmap(string: *const c_char,
+        errors: *const c_char,
-                                   length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                   mapping: *mut PyObject,
+    fn PyUnicodeUCS2_DecodeCharmap(
-                                   errors: *const c_char) -> *mut PyObject;
+        string: *const c_char,
-    fn PyUnicodeUCS2_AsCharmapString(unicode: *mut PyObject,
+        length: Py_ssize_t,
-                                     mapping: *mut PyObject) -> *mut PyObject;
+        mapping: *mut PyObject,
-    fn PyUnicodeUCS2_EncodeCharmap(data: *const Py_UNICODE,
+        errors: *const c_char,
-                                   length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                   mapping: *mut PyObject,
+    fn PyUnicodeUCS2_AsCharmapString(
-                                   errors: *const c_char) -> *mut PyObject;
+        unicode: *mut PyObject,
-    fn PyUnicodeUCS2_TranslateCharmap(data: *const Py_UNICODE,
+        mapping: *mut PyObject,
-                                      length: Py_ssize_t,
+    ) -> *mut PyObject;
-                                      table: *mut PyObject,
+    fn PyUnicodeUCS2_EncodeCharmap(
-                                      errors: *const c_char) -> *mut PyObject;
+        data: *const Py_UNICODE,
-    fn PyUnicodeUCS2_EncodeDecimal(s: *mut Py_UNICODE, length: Py_ssize_t,
+        length: Py_ssize_t,
-                                   output: *mut c_char,
+        mapping: *mut PyObject,
-                                   errors: *const c_char) -> c_int;
+        errors: *const c_char,
-    fn PyUnicodeUCS2_Concat(left: *mut PyObject, right: *mut PyObject)
+    ) -> *mut PyObject;
-                            -> *mut PyObject;
+    fn PyUnicodeUCS2_TranslateCharmap(
-    fn PyUnicodeUCS2_Split(s: *mut PyObject, sep: *mut PyObject,
+        data: *const Py_UNICODE,
-                           maxsplit: Py_ssize_t) -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS2_Splitlines(s: *mut PyObject, keepends: c_int)
+        table: *mut PyObject,
-                                -> *mut PyObject;
+        errors: *const c_char,
-    fn PyUnicodeUCS2_Partition(s: *mut PyObject, sep: *mut PyObject)
+    ) -> *mut PyObject;
-                               -> *mut PyObject;
+    fn PyUnicodeUCS2_EncodeDecimal(
-    fn PyUnicodeUCS2_RPartition(s: *mut PyObject, sep: *mut PyObject)
+        s: *mut Py_UNICODE,
-                                -> *mut PyObject;
+        length: Py_ssize_t,
-    fn PyUnicodeUCS2_RSplit(s: *mut PyObject, sep: *mut PyObject,
+        output: *mut c_char,
-                            maxsplit: Py_ssize_t) -> *mut PyObject;
+        errors: *const c_char,
-    fn PyUnicodeUCS2_Translate(str: *mut PyObject, table: *mut PyObject,
+    ) -> c_int;
-                               errors: *const c_char)
+    fn PyUnicodeUCS2_Concat(left: *mut PyObject, right: *mut PyObject) -> *mut PyObject;
-                               -> *mut PyObject;
+    fn PyUnicodeUCS2_Split(
-    fn PyUnicodeUCS2_Join(separator: *mut PyObject, seq: *mut PyObject)
+        s: *mut PyObject,
-                          -> *mut PyObject;
+        sep: *mut PyObject,
-    fn PyUnicodeUCS2_Tailmatch(str: *mut PyObject, substr: *mut PyObject,
+        maxsplit: Py_ssize_t,
-                               start: Py_ssize_t, end: Py_ssize_t,
+    ) -> *mut PyObject;
-                               direction: c_int) -> Py_ssize_t;
+    fn PyUnicodeUCS2_Splitlines(s: *mut PyObject, keepends: c_int) -> *mut PyObject;
-    fn PyUnicodeUCS2_Find(str: *mut PyObject, substr: *mut PyObject,
+    fn PyUnicodeUCS2_Partition(s: *mut PyObject, sep: *mut PyObject) -> *mut PyObject;
-                          start: Py_ssize_t, end: Py_ssize_t,
+    fn PyUnicodeUCS2_RPartition(s: *mut PyObject, sep: *mut PyObject) -> *mut PyObject;
-                          direction: c_int) -> Py_ssize_t;
+    fn PyUnicodeUCS2_RSplit(
-    fn PyUnicodeUCS2_Count(str: *mut PyObject, substr: *mut PyObject,
+        s: *mut PyObject,
-                           start: Py_ssize_t, end: Py_ssize_t)
+        sep: *mut PyObject,
-                           -> Py_ssize_t;
+        maxsplit: Py_ssize_t,
-    fn PyUnicodeUCS2_Replace(str: *mut PyObject, substr: *mut PyObject,
+    ) -> *mut PyObject;
-                             replstr: *mut PyObject, maxcount: Py_ssize_t)
+    fn PyUnicodeUCS2_Translate(
-                             -> *mut PyObject;
+        str: *mut PyObject,
-    fn PyUnicodeUCS2_Compare(left: *mut PyObject, right: *mut PyObject)
+        table: *mut PyObject,
-                             -> c_int;
+        errors: *const c_char,
-    fn PyUnicodeUCS2_RichCompare(left: *mut PyObject,
+    ) -> *mut PyObject;
-                                 right: *mut PyObject, op: c_int)
+    fn PyUnicodeUCS2_Join(separator: *mut PyObject, seq: *mut PyObject) -> *mut PyObject;
-                                 -> *mut PyObject;
+    fn PyUnicodeUCS2_Tailmatch(
-    fn PyUnicodeUCS2_Format(format: *mut PyObject, args: *mut PyObject)
+        str: *mut PyObject,
-                            -> *mut PyObject;
+        substr: *mut PyObject,
-    fn PyUnicodeUCS2_Contains(container: *mut PyObject,
+        start: Py_ssize_t,
-                              element: *mut PyObject) -> c_int;
+        end: Py_ssize_t,
-    fn _PyUnicode_XStrip(_self: *mut PyUnicodeObject,
+        direction: c_int,
-                         striptype: c_int, sepobj: *mut PyObject)
+    ) -> Py_ssize_t;
-                         -> *mut PyObject;
+    fn PyUnicodeUCS2_Find(
+        str: *mut PyObject,
+        substr: *mut PyObject,
+        start: Py_ssize_t,
+        end: Py_ssize_t,
+        direction: c_int,
+    ) -> Py_ssize_t;
+    fn PyUnicodeUCS2_Count(
+        str: *mut PyObject,
+        substr: *mut PyObject,
+        start: Py_ssize_t,
+        end: Py_ssize_t,
+    ) -> Py_ssize_t;
+    fn PyUnicodeUCS2_Replace(
+        str: *mut PyObject,
+        substr: *mut PyObject,
+        replstr: *mut PyObject,
+        maxcount: Py_ssize_t,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS2_Compare(left: *mut PyObject, right: *mut PyObject) -> c_int;
+    fn PyUnicodeUCS2_RichCompare(
+        left: *mut PyObject,
+        right: *mut PyObject,
+        op: c_int,
+    ) -> *mut PyObject;
+    fn PyUnicodeUCS2_Format(format: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
+    fn PyUnicodeUCS2_Contains(container: *mut PyObject, element: *mut PyObject) -> c_int;
+    fn _PyUnicode_XStrip(
+        _self: *mut PyUnicodeObject,
+        striptype: c_int,
+        sepobj: *mut PyObject,
+    ) -> *mut PyObject;
     fn _PyUnicodeUCS2_IsLowercase(ch: Py_UNICODE) -> c_int;
     fn _PyUnicodeUCS2_IsUppercase(ch: Py_UNICODE) -> c_int;
     fn _PyUnicodeUCS2_IsTitlecase(ch: Py_UNICODE) -> c_int;
@@ -459,41 +643,45 @@ pub const Py_UNICODE_REPLACEMENT_CHARACTER : Py_UNICODE = 0xFFFD;
 }
 
 #[inline(always)]
-#[cfg(py_sys_config="Py_UNICODE_SIZE_4")]
+#[cfg(py_sys_config = "Py_UNICODE_SIZE_4")]
 pub unsafe fn PyUnicode_FromStringAndSize(u: *const c_char, size: Py_ssize_t) -> *mut PyObject {
     PyUnicodeUCS4_FromStringAndSize(u, size)
 }
 
 #[inline(always)]
-#[cfg(not(py_sys_config="Py_UNICODE_SIZE_4"))]
+#[cfg(not(py_sys_config = "Py_UNICODE_SIZE_4"))]
 pub unsafe fn PyUnicode_FromStringAndSize(u: *const c_char, size: Py_ssize_t) -> *mut PyObject {
     PyUnicodeUCS2_FromStringAndSize(u, size)
 }
 
 #[inline(always)]
-#[cfg(py_sys_config="Py_UNICODE_SIZE_4")]
+#[cfg(py_sys_config = "Py_UNICODE_SIZE_4")]
 pub unsafe fn PyUnicode_AsUTF8String(u: *mut PyObject) -> *mut PyObject {
     PyUnicodeUCS4_AsUTF8String(u)
 }
 
 #[inline(always)]
-#[cfg(not(py_sys_config="Py_UNICODE_SIZE_4"))]
+#[cfg(not(py_sys_config = "Py_UNICODE_SIZE_4"))]
 pub unsafe fn PyUnicode_AsUTF8String(u: *mut PyObject) -> *mut PyObject {
     PyUnicodeUCS2_AsUTF8String(u)
 }
 
 #[inline(always)]
-#[cfg(py_sys_config="Py_UNICODE_SIZE_4")]
+#[cfg(py_sys_config = "Py_UNICODE_SIZE_4")]
-pub unsafe fn PyUnicode_FromEncodedObject(obj: *mut PyObject,
+pub unsafe fn PyUnicode_FromEncodedObject(
-                                          encoding: *const c_char,
+    obj: *mut PyObject,
-                                          errors: *const c_char) -> *mut PyObject {
+    encoding: *const c_char,
+    errors: *const c_char,
+) -> *mut PyObject {
     PyUnicodeUCS4_FromEncodedObject(obj, encoding, errors)
 }
 
 #[inline(always)]
-#[cfg(not(py_sys_config="Py_UNICODE_SIZE_4"))]
+#[cfg(not(py_sys_config = "Py_UNICODE_SIZE_4"))]
-pub unsafe fn PyUnicode_FromEncodedObject(obj: *mut PyObject,
+pub unsafe fn PyUnicode_FromEncodedObject(
-                                          encoding: *const c_char,
+    obj: *mut PyObject,
-                                          errors: *const c_char) -> *mut PyObject {
+    encoding: *const c_char,
+    errors: *const c_char,
+) -> *mut PyObject {
     PyUnicodeUCS2_FromEncodedObject(obj, encoding, errors)
 }

src/ffi2/warnings.rs

@@ -1,16 +1,22 @@
-use std::os::raw::{c_char, c_int};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::PyObject;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyErr_WarnEx(category: *mut PyObject, msg: *const c_char,
+extern "C" {
-                        stacklevel: Py_ssize_t) -> c_int;
+    pub fn PyErr_WarnEx(
-    pub fn PyErr_WarnExplicit(arg1: *mut PyObject,
+        category: *mut PyObject,
-                              arg2: *const c_char,
+        msg: *const c_char,
-                              arg3: *const c_char,
+        stacklevel: Py_ssize_t,
-                              arg4: c_int,
+    ) -> c_int;
-                              arg5: *const c_char,
+    pub fn PyErr_WarnExplicit(
-                              arg6: *mut PyObject) -> c_int;
+        arg1: *mut PyObject,
+        arg2: *const c_char,
+        arg3: *const c_char,
+        arg4: c_int,
+        arg5: *const c_char,
+        arg6: *mut PyObject,
+    ) -> c_int;
 }
 
 #[inline]

src/ffi2/weakrefobject.rs

@@ -1,13 +1,13 @@
-use std::os::raw::{c_int, c_long};
-use ffi2::pyport::Py_ssize_t;
 use ffi2::object::*;
+use ffi2::pyport::Py_ssize_t;
+use std::os::raw::{c_int, c_long};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyWeakReference {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
@@ -15,10 +15,11 @@ pub struct PyWeakReference {
     pub wr_callback: *mut PyObject,
     pub hash: c_long,
     pub wr_prev: *mut PyWeakReference,
-    pub wr_next: *mut PyWeakReference
+    pub wr_next: *mut PyWeakReference,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     static mut _PyWeakref_RefType: PyTypeObject;
     static mut _PyWeakref_ProxyType: PyTypeObject;
     static mut _PyWeakref_CallableProxyType: PyTypeObject;
@@ -36,8 +37,8 @@ pub unsafe fn PyWeakref_CheckRefExact(op: *mut PyObject) -> c_int {
 
 #[inline(always)]
 pub unsafe fn PyWeakref_CheckProxy(op: *mut PyObject) -> c_int {
-    ((Py_TYPE(op) == &mut _PyWeakref_ProxyType) ||
+    ((Py_TYPE(op) == &mut _PyWeakref_ProxyType)
-         (Py_TYPE(op) == &mut _PyWeakref_CallableProxyType)) as c_int
+        || (Py_TYPE(op) == &mut _PyWeakref_CallableProxyType)) as c_int
 }
 
 #[inline(always)]
@@ -45,11 +46,10 @@ pub unsafe fn PyWeakref_Check(op: *mut PyObject) -> c_int {
     (PyWeakref_CheckRef(op) != 0 || PyWeakref_CheckProxy(op) != 0) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyWeakref_NewRef(ob: *mut PyObject, callback: *mut PyObject)
+extern "C" {
-     -> *mut PyObject;
+    pub fn PyWeakref_NewRef(ob: *mut PyObject, callback: *mut PyObject) -> *mut PyObject;
-    pub fn PyWeakref_NewProxy(ob: *mut PyObject, callback: *mut PyObject)
+    pub fn PyWeakref_NewProxy(ob: *mut PyObject, callback: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
     pub fn PyWeakref_GetObject(_ref: *mut PyObject) -> *mut PyObject;
 
     pub fn _PyWeakref_GetWeakrefCount(head: *mut PyWeakReference) -> Py_ssize_t;
@@ -59,6 +59,9 @@ pub unsafe fn PyWeakref_Check(op: *mut PyObject) -> c_int {
 #[inline(always)]
 pub unsafe fn PyWeakref_GET_OBJECT(_ref: *mut PyObject) -> *mut PyObject {
     let obj = (*(_ref as *mut PyWeakReference)).wr_object;
-    if Py_REFCNT(obj) > 0 { obj } else { Py_None() }
+    if Py_REFCNT(obj) > 0 {
+        obj
+    } else {
+        Py_None()
+    }
 }
-

src/ffi3/bltinmodule.rs

@@ -1,6 +1,7 @@
 use ffi3::object::PyTypeObject;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyFilter_Type: PyTypeObject;
     pub static mut PyMap_Type: PyTypeObject;
     pub static mut PyZip_Type: PyTypeObject;

src/ffi3/boolobject.rs

@@ -1,8 +1,9 @@
-use std::os::raw::{c_int, c_long};
-use ffi3::object::*;
 use ffi3::longobject::PyLongObject;
+use ffi3::object::*;
+use std::os::raw::{c_int, c_long};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyBool_Type: PyTypeObject;
     static mut _Py_FalseStruct: PyLongObject;
     static mut _Py_TrueStruct: PyLongObject;
@@ -10,7 +11,7 @@ use ffi3::longobject::PyLongObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyBool_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyBool_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyBool_Type) as c_int
 }
 
@@ -23,4 +24,3 @@ pub unsafe fn Py_False() -> *mut PyObject {
 pub unsafe fn Py_True() -> *mut PyObject {
     &mut _Py_TrueStruct as *mut PyLongObject as *mut PyObject
 }
-

src/ffi3/bytearrayobject.rs

@@ -1,31 +1,29 @@
-use std::os::raw::{c_char, c_int};
 use ffi3::object::*;
 use ffi3::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyByteArray_Type: PyTypeObject;
     pub static mut PyByteArrayIter_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyByteArray_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyByteArray_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyByteArray_Type)
 }
 
 #[inline(always)]
-pub unsafe fn PyByteArray_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyByteArray_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyByteArray_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyByteArray_FromObject(o: *mut PyObject) -> *mut PyObject;
-    pub fn PyByteArray_Concat(a: *mut PyObject, b: *mut PyObject)
+    pub fn PyByteArray_Concat(a: *mut PyObject, b: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyByteArray_FromStringAndSize(string: *const c_char, len: Py_ssize_t) -> *mut PyObject;
-    pub fn PyByteArray_FromStringAndSize(string: *const c_char,
-                                         len: Py_ssize_t) -> *mut PyObject;
     pub fn PyByteArray_Size(bytearray: *mut PyObject) -> Py_ssize_t;
     pub fn PyByteArray_AsString(bytearray: *mut PyObject) -> *mut c_char;
-    pub fn PyByteArray_Resize(bytearray: *mut PyObject, len: Py_ssize_t)
+    pub fn PyByteArray_Resize(bytearray: *mut PyObject, len: Py_ssize_t) -> c_int;
-     -> c_int;
 }
-

src/ffi3/bytesobject.rs

@@ -1,44 +1,46 @@
-use std::os::raw::{c_char, c_int};
 use ffi3::object::*;
 use ffi3::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyBytes_Type: PyTypeObject;
     pub static mut PyBytesIter_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyBytes_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyBytes_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_BYTES_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyBytes_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyBytes_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyBytes_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyBytes_FromStringAndSize(arg1: *const c_char,
+extern "C" {
-                                     arg2: Py_ssize_t) -> *mut PyObject;
+    pub fn PyBytes_FromStringAndSize(arg1: *const c_char, arg2: Py_ssize_t) -> *mut PyObject;
     pub fn PyBytes_FromString(arg1: *const c_char) -> *mut PyObject;
     pub fn PyBytes_FromObject(arg1: *mut PyObject) -> *mut PyObject;
     //pub fn PyBytes_FromFormatV(arg1: *const c_char, arg2: va_list)
     // -> *mut PyObject;
-    pub fn PyBytes_FromFormat(arg1: *const c_char, ...)
+    pub fn PyBytes_FromFormat(arg1: *const c_char, ...) -> *mut PyObject;
-     -> *mut PyObject;
     pub fn PyBytes_Size(arg1: *mut PyObject) -> Py_ssize_t;
     pub fn PyBytes_AsString(arg1: *mut PyObject) -> *mut c_char;
-    pub fn PyBytes_Repr(arg1: *mut PyObject, arg2: c_int)
+    pub fn PyBytes_Repr(arg1: *mut PyObject, arg2: c_int) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyBytes_Concat(arg1: *mut *mut PyObject, arg2: *mut PyObject) -> ();
-    pub fn PyBytes_Concat(arg1: *mut *mut PyObject, arg2: *mut PyObject)
+    pub fn PyBytes_ConcatAndDel(arg1: *mut *mut PyObject, arg2: *mut PyObject) -> ();
-     -> ();
+    pub fn PyBytes_DecodeEscape(
-    pub fn PyBytes_ConcatAndDel(arg1: *mut *mut PyObject, arg2: *mut PyObject)
+        arg1: *const c_char,
-     -> ();
+        arg2: Py_ssize_t,
-    pub fn PyBytes_DecodeEscape(arg1: *const c_char, arg2: Py_ssize_t,
+        arg3: *const c_char,
-                                arg3: *const c_char, arg4: Py_ssize_t,
+        arg4: Py_ssize_t,
-                                arg5: *const c_char) -> *mut PyObject;
+        arg5: *const c_char,
-    pub fn PyBytes_AsStringAndSize(obj: *mut PyObject,
+    ) -> *mut PyObject;
-                                   s: *mut *mut c_char,
+    pub fn PyBytes_AsStringAndSize(
-                                   len: *mut Py_ssize_t) -> c_int;
+        obj: *mut PyObject,
+        s: *mut *mut c_char,
+        len: *mut Py_ssize_t,
+    ) -> c_int;
 }
-

src/ffi3/ceval.rs

@@ -1,14 +1,16 @@
-use std::os::raw::{c_void, c_char, c_int};
-use ffi3::object::PyObject;
-use ffi3::pystate::PyThreadState;
 #[cfg(Py_3_6)]
 use ffi3::code::FreeFunc;
+use ffi3::object::PyObject;
+use ffi3::pystate::PyThreadState;
+use std::os::raw::{c_char, c_int, c_void};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyEval_CallObjectWithKeywords(func: *mut PyObject,
+extern "C" {
-                                         obj: *mut PyObject,
+    pub fn PyEval_CallObjectWithKeywords(
-                                         kwargs: *mut PyObject)
+        func: *mut PyObject,
-     -> *mut PyObject;
+        obj: *mut PyObject,
+        kwargs: *mut PyObject,
+    ) -> *mut PyObject;
 }
 
 #[inline]
@@ -16,20 +18,23 @@ pub unsafe fn PyEval_CallObject(func: *mut PyObject, arg: *mut PyObject) -> *mut
     PyEval_CallObjectWithKeywords(func, arg, ::std::ptr::null_mut())
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyEval_CallFunction(obj: *mut PyObject,
+extern "C" {
-                               format: *const c_char, ...)
+    pub fn PyEval_CallFunction(obj: *mut PyObject, format: *const c_char, ...) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyEval_CallMethod(
-    pub fn PyEval_CallMethod(obj: *mut PyObject,
+        obj: *mut PyObject,
-                             methodname: *const c_char,
+        methodname: *const c_char,
-                             format: *const c_char, ...)
+        format: *const c_char,
-     -> *mut PyObject;
+        ...
+    ) -> *mut PyObject;
     pub fn PyEval_GetBuiltins() -> *mut PyObject;
     pub fn PyEval_GetGlobals() -> *mut PyObject;
     pub fn PyEval_GetLocals() -> *mut PyObject;
     pub fn PyEval_GetFrame() -> *mut ::ffi3::PyFrameObject;
-    pub fn Py_AddPendingCall(func: Option<extern "C" fn(arg1: *mut c_void) -> c_int>,
+    pub fn Py_AddPendingCall(
-                             arg: *mut c_void) -> c_int;
+        func: Option<extern "C" fn(arg1: *mut c_void) -> c_int>,
+        arg: *mut c_void,
+    ) -> c_int;
     pub fn Py_MakePendingCalls() -> c_int;
     pub fn Py_SetRecursionLimit(arg1: c_int) -> ();
     pub fn Py_GetRecursionLimit() -> c_int;
@@ -42,24 +47,24 @@ pub unsafe fn PyEval_CallObject(func: *mut PyObject, arg: *mut PyObject) -> *mut
 #[cfg(Py_3_6)]
 pub type _PyFrameEvalFunction = extern "C" fn(*mut ::ffi3::PyFrameObject, c_int) -> *mut PyObject;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyEval_GetFuncName(arg1: *mut PyObject) -> *const c_char;
     pub fn PyEval_GetFuncDesc(arg1: *mut PyObject) -> *const c_char;
     pub fn PyEval_GetCallStats(arg1: *mut PyObject) -> *mut PyObject;
     pub fn PyEval_EvalFrame(arg1: *mut ::ffi3::PyFrameObject) -> *mut PyObject;
     #[cfg(Py_3_6)]
-    pub fn _PyEval_EvalFrameDefault(arg1: *mut ::ffi3::PyFrameObject,
+    pub fn _PyEval_EvalFrameDefault(arg1: *mut ::ffi3::PyFrameObject, exc: c_int) -> *mut PyObject;
-                                    exc: c_int) -> *mut PyObject;
     #[cfg(Py_3_6)]
     pub fn _PyEval_RequestCodeExtraIndex(func: FreeFunc) -> c_int;
-    pub fn PyEval_EvalFrameEx(f: *mut ::ffi3::PyFrameObject, exc: c_int)
+    pub fn PyEval_EvalFrameEx(f: *mut ::ffi3::PyFrameObject, exc: c_int) -> *mut PyObject;
-     -> *mut PyObject;
     pub fn PyEval_SaveThread() -> *mut PyThreadState;
     pub fn PyEval_RestoreThread(arg1: *mut PyThreadState) -> ();
 }
 
 #[cfg(py_sys_config = "WITH_THREAD")]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyEval_ThreadsInitialized() -> c_int;
     pub fn PyEval_InitThreads() -> ();
     pub fn PyEval_AcquireLock() -> ();
@@ -68,4 +73,3 @@ pub type _PyFrameEvalFunction = extern "C" fn(*mut ::ffi3::PyFrameObject, c_int)
     pub fn PyEval_ReleaseThread(tstate: *mut PyThreadState) -> ();
     pub fn PyEval_ReInitThreads() -> ();
 }
-

src/ffi3/code.rs

@@ -1,6 +1,6 @@
-use std::os::raw::{c_void, c_uchar, c_char, c_int};
-use ffi3::pyport::Py_ssize_t;
 use ffi3::object::*;
+use ffi3::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int, c_uchar, c_void};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -32,74 +32,93 @@ pub struct PyCodeObject {
 }
 
 impl Default for PyCodeObject {
-    #[inline] fn default() -> Self { unsafe { ::std::mem::zeroed() } }
+    #[inline]
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
 }
 
 /* Masks for co_flags */
-pub const CO_OPTIMIZED : c_int = 0x0001;
+pub const CO_OPTIMIZED: c_int = 0x0001;
-pub const CO_NEWLOCALS : c_int = 0x0002;
+pub const CO_NEWLOCALS: c_int = 0x0002;
-pub const CO_VARARGS : c_int = 0x0004;
+pub const CO_VARARGS: c_int = 0x0004;
-pub const CO_VARKEYWORDS : c_int = 0x0008;
+pub const CO_VARKEYWORDS: c_int = 0x0008;
-pub const CO_NESTED : c_int = 0x0010;
+pub const CO_NESTED: c_int = 0x0010;
-pub const CO_GENERATOR : c_int = 0x0020;
+pub const CO_GENERATOR: c_int = 0x0020;
 /* The CO_NOFREE flag is set if there are no free or cell variables.
    This information is redundant, but it allows a single flag test
    to determine whether there is any extra work to be done when the
    call frame it setup.
 */
-pub const CO_NOFREE : c_int = 0x0040;
+pub const CO_NOFREE: c_int = 0x0040;
 /* The CO_COROUTINE flag is set for coroutine functions (defined with
    ``async def`` keywords) */
-pub const CO_COROUTINE : c_int = 0x0080;
+pub const CO_COROUTINE: c_int = 0x0080;
-pub const CO_ITERABLE_COROUTINE : c_int = 0x0100;
+pub const CO_ITERABLE_COROUTINE: c_int = 0x0100;
-pub const CO_ASYNC_GENERATOR : c_int = 0x0200;
+pub const CO_ASYNC_GENERATOR: c_int = 0x0200;
 
-pub const CO_FUTURE_DIVISION : c_int = 0x2000;
+pub const CO_FUTURE_DIVISION: c_int = 0x2000;
-pub const CO_FUTURE_ABSOLUTE_IMPORT : c_int = 0x4000; /* do absolute imports by default */
+pub const CO_FUTURE_ABSOLUTE_IMPORT: c_int = 0x4000; /* do absolute imports by default */
-pub const CO_FUTURE_WITH_STATEMENT : c_int = 0x8000;
+pub const CO_FUTURE_WITH_STATEMENT: c_int = 0x8000;
-pub const CO_FUTURE_PRINT_FUNCTION : c_int = 0x1_0000;
+pub const CO_FUTURE_PRINT_FUNCTION: c_int = 0x1_0000;
-pub const CO_FUTURE_UNICODE_LITERALS : c_int = 0x2_0000;
+pub const CO_FUTURE_UNICODE_LITERALS: c_int = 0x2_0000;
-pub const CO_FUTURE_BARRY_AS_BDFL : c_int = 0x4_0000;
+pub const CO_FUTURE_BARRY_AS_BDFL: c_int = 0x4_0000;
-pub const CO_FUTURE_GENERATOR_STOP : c_int = 0x8_0000;
+pub const CO_FUTURE_GENERATOR_STOP: c_int = 0x8_0000;
 
 pub const CO_MAXBLOCKS: usize = 20;
 
 #[cfg(Py_3_6)]
 pub type FreeFunc = extern "C" fn(*mut c_void) -> c_void;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyCode_Type: PyTypeObject;
     #[cfg(Py_3_6)]
-    pub fn _PyCode_GetExtra(code: *mut PyObject, index: Py_ssize_t,
+    pub fn _PyCode_GetExtra(
-                            extra: *const *mut c_void) -> c_int;
+        code: *mut PyObject,
+        index: Py_ssize_t,
+        extra: *const *mut c_void,
+    ) -> c_int;
     #[cfg(Py_3_6)]
-    pub fn _PyCode_SetExtra(code: *mut PyObject, index: Py_ssize_t,
+    pub fn _PyCode_SetExtra(code: *mut PyObject, index: Py_ssize_t, extra: *mut c_void) -> c_int;
-                            extra: *mut c_void) -> c_int;
 
-    pub fn PyCode_New(arg1: c_int, arg2: c_int,
+    pub fn PyCode_New(
-                      arg3: c_int, arg4: c_int,
+        arg1: c_int,
-                      arg5: c_int, arg6: *mut PyObject,
+        arg2: c_int,
-                      arg7: *mut PyObject, arg8: *mut PyObject,
+        arg3: c_int,
-                      arg9: *mut PyObject, arg10: *mut PyObject,
+        arg4: c_int,
-                      arg11: *mut PyObject, arg12: *mut PyObject,
+        arg5: c_int,
-                      arg13: *mut PyObject, arg14: c_int,
+        arg6: *mut PyObject,
-                      arg15: *mut PyObject) -> *mut PyCodeObject;
+        arg7: *mut PyObject,
-    pub fn PyCode_NewEmpty(filename: *const c_char,
+        arg8: *mut PyObject,
-                           funcname: *const c_char,
+        arg9: *mut PyObject,
-                           firstlineno: c_int) -> *mut PyCodeObject;
+        arg10: *mut PyObject,
-    pub fn PyCode_Addr2Line(arg1: *mut PyCodeObject, arg2: c_int)
+        arg11: *mut PyObject,
-     -> c_int;
+        arg12: *mut PyObject,
-    pub fn PyCode_Optimize(code: *mut PyObject, consts: *mut PyObject,
+        arg13: *mut PyObject,
-                           names: *mut PyObject, lnotab: *mut PyObject)
+        arg14: c_int,
-     -> *mut PyObject;
+        arg15: *mut PyObject,
+    ) -> *mut PyCodeObject;
+    pub fn PyCode_NewEmpty(
+        filename: *const c_char,
+        funcname: *const c_char,
+        firstlineno: c_int,
+    ) -> *mut PyCodeObject;
+    pub fn PyCode_Addr2Line(arg1: *mut PyCodeObject, arg2: c_int) -> c_int;
+    pub fn PyCode_Optimize(
+        code: *mut PyObject,
+        consts: *mut PyObject,
+        names: *mut PyObject,
+        lnotab: *mut PyObject,
+    ) -> *mut PyObject;
 }
 
 #[inline]
-pub unsafe fn PyCode_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyCode_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyCode_Type) as c_int
 }
 
 #[inline]
-pub unsafe fn PyCode_GetNumFree(op : *mut PyCodeObject) -> Py_ssize_t {
+pub unsafe fn PyCode_GetNumFree(op: *mut PyCodeObject) -> Py_ssize_t {
     ::ffi3::tupleobject::PyTuple_GET_SIZE((*op).co_freevars)
 }

src/ffi3/codecs.rs

@@ -1,41 +1,45 @@
-use std::os::raw::{c_char, c_int};
 use ffi3::object::PyObject;
+use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyCodec_Register(search_function: *mut PyObject) -> c_int;
-    pub fn PyCodec_KnownEncoding(encoding: *const c_char)
+    pub fn PyCodec_KnownEncoding(encoding: *const c_char) -> c_int;
-     -> c_int;
+    pub fn PyCodec_Encode(
-    pub fn PyCodec_Encode(object: *mut PyObject,
+        object: *mut PyObject,
-                          encoding: *const c_char,
+        encoding: *const c_char,
-                          errors: *const c_char) -> *mut PyObject;
+        errors: *const c_char,
-    pub fn PyCodec_Decode(object: *mut PyObject,
+    ) -> *mut PyObject;
-                          encoding: *const c_char,
+    pub fn PyCodec_Decode(
-                          errors: *const c_char) -> *mut PyObject;
+        object: *mut PyObject,
+        encoding: *const c_char,
+        errors: *const c_char,
+    ) -> *mut PyObject;
     pub fn PyCodec_Encoder(encoding: *const c_char) -> *mut PyObject;
     pub fn PyCodec_Decoder(encoding: *const c_char) -> *mut PyObject;
-    pub fn PyCodec_IncrementalEncoder(encoding: *const c_char,
+    pub fn PyCodec_IncrementalEncoder(
-                                      errors: *const c_char)
+        encoding: *const c_char,
-     -> *mut PyObject;
+        errors: *const c_char,
-    pub fn PyCodec_IncrementalDecoder(encoding: *const c_char,
+    ) -> *mut PyObject;
-                                      errors: *const c_char)
+    pub fn PyCodec_IncrementalDecoder(
-     -> *mut PyObject;
+        encoding: *const c_char,
-    pub fn PyCodec_StreamReader(encoding: *const c_char,
+        errors: *const c_char,
-                                stream: *mut PyObject,
+    ) -> *mut PyObject;
-                                errors: *const c_char)
+    pub fn PyCodec_StreamReader(
-     -> *mut PyObject;
+        encoding: *const c_char,
-    pub fn PyCodec_StreamWriter(encoding: *const c_char,
+        stream: *mut PyObject,
-                                stream: *mut PyObject,
+        errors: *const c_char,
-                                errors: *const c_char)
+    ) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyCodec_StreamWriter(
-    pub fn PyCodec_RegisterError(name: *const c_char,
+        encoding: *const c_char,
-                                 error: *mut PyObject) -> c_int;
+        stream: *mut PyObject,
+        errors: *const c_char,
+    ) -> *mut PyObject;
+    pub fn PyCodec_RegisterError(name: *const c_char, error: *mut PyObject) -> c_int;
     pub fn PyCodec_LookupError(name: *const c_char) -> *mut PyObject;
     pub fn PyCodec_StrictErrors(exc: *mut PyObject) -> *mut PyObject;
     pub fn PyCodec_IgnoreErrors(exc: *mut PyObject) -> *mut PyObject;
     pub fn PyCodec_ReplaceErrors(exc: *mut PyObject) -> *mut PyObject;
-    pub fn PyCodec_XMLCharRefReplaceErrors(exc: *mut PyObject)
+    pub fn PyCodec_XMLCharRefReplaceErrors(exc: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyCodec_BackslashReplaceErrors(exc: *mut PyObject) -> *mut PyObject;
-    pub fn PyCodec_BackslashReplaceErrors(exc: *mut PyObject)
-     -> *mut PyObject;
 }
-

src/ffi3/compile.rs

@@ -1,8 +1,8 @@
-use std::os::raw::{c_char, c_int};
-use ffi3::object::PyObject;
-use ffi3::pythonrun::*;
 use ffi3::code::*;
+use ffi3::object::PyObject;
 use ffi3::pyarena::*;
+use ffi3::pythonrun::*;
+use std::os::raw::{c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -13,47 +13,55 @@ pub struct PyFutureFeatures {
 }
 
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_NESTED_SCOPES    : &str = "nested_scopes";
+pub const FUTURE_NESTED_SCOPES: &str = "nested_scopes";
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_GENERATORS       : &str = "generators";
+pub const FUTURE_GENERATORS: &str = "generators";
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_DIVISION         : &str = "division";
+pub const FUTURE_DIVISION: &str = "division";
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_ABSOLUTE_IMPORT  : &str = "absolute_import";
+pub const FUTURE_ABSOLUTE_IMPORT: &str = "absolute_import";
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_WITH_STATEMENT   : &str = "with_statement";
+pub const FUTURE_WITH_STATEMENT: &str = "with_statement";
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_PRINT_FUNCTION   : &str = "print_function";
+pub const FUTURE_PRINT_FUNCTION: &str = "print_function";
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_UNICODE_LITERALS : &str = "unicode_literals";
+pub const FUTURE_UNICODE_LITERALS: &str = "unicode_literals";
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_BARRY_AS_BDFL    : &str = "barry_as_FLUFL";
+pub const FUTURE_BARRY_AS_BDFL: &str = "barry_as_FLUFL";
 #[cfg(not(Py_LIMITED_API))]
-pub const FUTURE_GENERATOR_STOP   : &str = "generator_stop";
+pub const FUTURE_GENERATOR_STOP: &str = "generator_stop";
 
 #[cfg(not(Py_LIMITED_API))]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyNode_Compile(arg1: *mut _node, arg2: *const c_char) -> *mut PyCodeObject;
 
-    pub fn PyAST_CompileEx(_mod: *mut _mod,
+    pub fn PyAST_CompileEx(
-                           filename: *const c_char,
+        _mod: *mut _mod,
-                           flags: *mut PyCompilerFlags,
+        filename: *const c_char,
-                           optimize: c_int, arena: *mut PyArena) -> *mut PyCodeObject;
+        flags: *mut PyCompilerFlags,
+        optimize: c_int,
+        arena: *mut PyArena,
+    ) -> *mut PyCodeObject;
 
-    pub fn PyAST_CompileObject(_mod: *mut _mod,
+    pub fn PyAST_CompileObject(
-                               filename: *mut PyObject,
+        _mod: *mut _mod,
-                               flags: *mut PyCompilerFlags,
+        filename: *mut PyObject,
-                               optimize: c_int, arena: *mut PyArena) -> *mut PyCodeObject;
+        flags: *mut PyCompilerFlags,
+        optimize: c_int,
+        arena: *mut PyArena,
+    ) -> *mut PyCodeObject;
 
     pub fn PyFuture_FromAST(_mod: *mut _mod, filename: *const c_char) -> *mut PyFutureFeatures;
 
-    pub fn PyFuture_FromASTObject(_mod: *mut _mod, filename: *mut PyObject) -> *mut PyFutureFeatures;
+    pub fn PyFuture_FromASTObject(
+        _mod: *mut _mod,
+        filename: *mut PyObject,
+    ) -> *mut PyFutureFeatures;
 
-    pub fn PyCompile_OpcodeStackEffect(
+    pub fn PyCompile_OpcodeStackEffect(opcode: c_int, oparg: c_int) -> c_int;
-        opcode: c_int, oparg: c_int) -> c_int;
 }
 
 pub const Py_single_input: c_int = 256;
 pub const Py_file_input: c_int = 257;
 pub const Py_eval_input: c_int = 258;
-

src/ffi3/complexobject.rs

@@ -1,24 +1,24 @@
-use std::os::raw::{c_double, c_int};
 use ffi3::object::*;
+use std::os::raw::{c_double, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyComplex_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyComplex_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyComplex_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyComplex_Type)
 }
 
 #[inline(always)]
-pub unsafe fn PyComplex_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyComplex_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyComplex_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyComplex_FromDoubles(real: c_double,
+extern "C" {
-                                 imag: c_double) -> *mut PyObject;
+    pub fn PyComplex_FromDoubles(real: c_double, imag: c_double) -> *mut PyObject;
     pub fn PyComplex_RealAsDouble(op: *mut PyObject) -> c_double;
     pub fn PyComplex_ImagAsDouble(op: *mut PyObject) -> c_double;
 }
-

src/ffi3/descrobject.rs

@@ -1,11 +1,10 @@
-use std::ptr;
+use ffi3::methodobject::PyMethodDef;
-use std::os::raw::{c_void, c_char, c_int};
 use ffi3::object::{PyObject, PyTypeObject};
 use ffi3::structmember::PyMemberDef;
-use ffi3::methodobject::PyMethodDef;
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
 
-pub type getter =
+pub type getter = unsafe extern "C" fn(slf: *mut PyObject, closure: *mut c_void) -> *mut PyObject;
-    unsafe extern "C" fn(slf: *mut PyObject, closure: *mut c_void) -> *mut PyObject;
 
 pub type setter =
     unsafe extern "C" fn(slf: *mut PyObject, value: *mut PyObject, closure: *mut c_void) -> c_int;
@@ -20,7 +19,7 @@ pub struct PyGetSetDef {
     pub closure: *mut c_void,
 }
 
-pub const PyGetSetDef_INIT : PyGetSetDef = PyGetSetDef {
+pub const PyGetSetDef_INIT: PyGetSetDef = PyGetSetDef {
     name: ptr::null_mut(),
     get: None,
     set: None,
@@ -28,7 +27,8 @@ pub const PyGetSetDef_INIT : PyGetSetDef = PyGetSetDef {
     closure: ptr::null_mut(),
 };
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyClassMethodDescr_Type: PyTypeObject;
     pub static mut PyGetSetDescr_Type: PyTypeObject;
     pub static mut PyMemberDescr_Type: PyTypeObject;
@@ -37,8 +37,8 @@ pub const PyGetSetDef_INIT : PyGetSetDef = PyGetSetDef {
     pub static mut PyDictProxy_Type: PyTypeObject;
 
     pub fn PyDescr_NewMethod(arg1: *mut PyTypeObject, arg2: *mut PyMethodDef) -> *mut PyObject;
-    pub fn PyDescr_NewClassMethod(arg1: *mut PyTypeObject,
+    pub fn PyDescr_NewClassMethod(arg1: *mut PyTypeObject, arg2: *mut PyMethodDef)
-                                  arg2: *mut PyMethodDef) -> *mut PyObject;
+        -> *mut PyObject;
     pub fn PyDescr_NewMember(arg1: *mut PyTypeObject, arg2: *mut PyMemberDef) -> *mut PyObject;
     pub fn PyDescr_NewGetSet(arg1: *mut PyTypeObject, arg2: *mut PyGetSetDef) -> *mut PyObject;
     pub fn PyDictProxy_New(arg1: *mut PyObject) -> *mut PyObject;
@@ -46,5 +46,3 @@ pub const PyGetSetDef_INIT : PyGetSetDef = PyGetSetDef {
 
     pub static mut PyProperty_Type: PyTypeObject;
 }
-
-

src/ffi3/dictobject.rs

@@ -1,8 +1,9 @@
-use std::os::raw::{c_char, c_int};
-use ffi3::pyport::Py_ssize_t;
 use ffi3::object::*;
+use ffi3::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyDict_Type: PyTypeObject;
     pub static mut PyDictIterKey_Type: PyTypeObject;
     pub static mut PyDictIterValue_Type: PyTypeObject;
@@ -13,44 +14,49 @@ use ffi3::object::*;
 }
 
 #[inline(always)]
-pub unsafe fn PyDict_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyDict_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyDict_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyDict_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyDict_Type) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyDictKeys_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyDictKeys_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyDictKeys_Type) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyDictItems_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyDictItems_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyDictItems_Type) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyDictValues_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyDictValues_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyDictValues_Type) as c_int
 }
 
 #[inline(always)]
-pub unsafe fn PyDictViewSet_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyDictViewSet_Check(op: *mut PyObject) -> c_int {
     (PyDictKeys_Check(op) != 0 || PyDictItems_Check(op) != 0) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyDict_New() -> *mut PyObject;
     pub fn PyDict_GetItem(mp: *mut PyObject, key: *mut PyObject) -> *mut PyObject;
     pub fn PyDict_GetItemWithError(mp: *mut PyObject, key: *mut PyObject) -> *mut PyObject;
     pub fn PyDict_SetItem(mp: *mut PyObject, key: *mut PyObject, item: *mut PyObject) -> c_int;
     pub fn PyDict_DelItem(mp: *mut PyObject, key: *mut PyObject) -> c_int;
     pub fn PyDict_Clear(mp: *mut PyObject) -> ();
-    pub fn PyDict_Next(mp: *mut PyObject, pos: *mut Py_ssize_t,
+    pub fn PyDict_Next(
-                       key: *mut *mut PyObject, value: *mut *mut PyObject) -> c_int;
+        mp: *mut PyObject,
+        pos: *mut Py_ssize_t,
+        key: *mut *mut PyObject,
+        value: *mut *mut PyObject,
+    ) -> c_int;
     pub fn PyDict_Keys(mp: *mut PyObject) -> *mut PyObject;
     pub fn PyDict_Values(mp: *mut PyObject) -> *mut PyObject;
     pub fn PyDict_Items(mp: *mut PyObject) -> *mut PyObject;
@@ -61,7 +67,10 @@ pub unsafe fn PyDictViewSet_Check(op : *mut PyObject) -> c_int {
     pub fn PyDict_Merge(mp: *mut PyObject, other: *mut PyObject, _override: c_int) -> c_int;
     pub fn PyDict_MergeFromSeq2(d: *mut PyObject, seq2: *mut PyObject, _override: c_int) -> c_int;
     pub fn PyDict_GetItemString(dp: *mut PyObject, key: *const c_char) -> *mut PyObject;
-    pub fn PyDict_SetItemString(dp: *mut PyObject, key: *const c_char,
+    pub fn PyDict_SetItemString(
-                                item: *mut PyObject) -> c_int;
+        dp: *mut PyObject,
+        key: *const c_char,
+        item: *mut PyObject,
+    ) -> c_int;
     pub fn PyDict_DelItemString(dp: *mut PyObject, key: *const c_char) -> c_int;
 }

src/ffi3/enumobject.rs

@@ -1,7 +1,7 @@
 use ffi3::object::PyTypeObject;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyEnum_Type: PyTypeObject;
     pub static mut PyReversed_Type: PyTypeObject;
 }
-

src/ffi3/eval.rs

@@ -1,13 +1,24 @@
-use std::os::raw::c_int;
 use ffi3::object::PyObject;
+use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyEval_EvalCode(arg1: *mut PyObject, arg2: *mut PyObject,
+extern "C" {
-                           arg3: *mut PyObject) -> *mut PyObject;
+    pub fn PyEval_EvalCode(
-    pub fn PyEval_EvalCodeEx(co: *mut PyObject, globals: *mut PyObject,
+        arg1: *mut PyObject,
-                             locals: *mut PyObject, args: *mut *mut PyObject,
+        arg2: *mut PyObject,
-                             argc: c_int, kwds: *mut *mut PyObject,
+        arg3: *mut PyObject,
-                             kwdc: c_int, defs: *mut *mut PyObject,
+    ) -> *mut PyObject;
-                             defc: c_int, kwdefs: *mut PyObject,
+    pub fn PyEval_EvalCodeEx(
-                             closure: *mut PyObject) -> *mut PyObject;
+        co: *mut PyObject,
+        globals: *mut PyObject,
+        locals: *mut PyObject,
+        args: *mut *mut PyObject,
+        argc: c_int,
+        kwds: *mut *mut PyObject,
+        kwdc: c_int,
+        defs: *mut *mut PyObject,
+        defc: c_int,
+        kwdefs: *mut PyObject,
+        closure: *mut PyObject,
+    ) -> *mut PyObject;
 }

src/ffi3/fileobject.rs

@@ -1,25 +1,26 @@
-use std::os::raw::{c_char, c_int};
 use ffi3::object::PyObject;
+use std::os::raw::{c_char, c_int};
 
-pub const PY_STDIOTEXTMODE : &str = "b";
+pub const PY_STDIOTEXTMODE: &str = "b";
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyFile_FromFd(arg1: c_int, arg2: *const c_char,
+extern "C" {
-                         arg3: *const c_char, arg4: c_int,
+    pub fn PyFile_FromFd(
-                         arg5: *const c_char,
+        arg1: c_int,
-                         arg6: *const c_char,
+        arg2: *const c_char,
-                         arg7: *const c_char, arg8: c_int)
+        arg3: *const c_char,
-     -> *mut PyObject;
+        arg4: c_int,
-    pub fn PyFile_GetLine(arg1: *mut PyObject, arg2: c_int)
+        arg5: *const c_char,
-     -> *mut PyObject;
+        arg6: *const c_char,
-    pub fn PyFile_WriteObject(arg1: *mut PyObject, arg2: *mut PyObject,
+        arg7: *const c_char,
-                              arg3: c_int) -> c_int;
+        arg8: c_int,
-    pub fn PyFile_WriteString(arg1: *const c_char,
+    ) -> *mut PyObject;
-                              arg2: *mut PyObject) -> c_int;
+    pub fn PyFile_GetLine(arg1: *mut PyObject, arg2: c_int) -> *mut PyObject;
+    pub fn PyFile_WriteObject(arg1: *mut PyObject, arg2: *mut PyObject, arg3: c_int) -> c_int;
+    pub fn PyFile_WriteString(arg1: *const c_char, arg2: *mut PyObject) -> c_int;
 
     pub static mut Py_FileSystemDefaultEncoding: *const c_char;
     #[cfg(Py_3_6)]
     pub static mut Py_FileSystemDefaultEncodeErrors: *const c_char;
     pub static mut Py_HasFileSystemDefaultEncoding: c_int;
 }
-

src/ffi3/floatobject.rs

@@ -1,21 +1,23 @@
-use std::os::raw::{c_int, c_double};
 use ffi3::object::*;
+use std::os::raw::{c_double, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyFloat_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyFloat_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyFloat_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyFloat_Type)
 }
 
 #[inline(always)]
-pub unsafe fn PyFloat_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyFloat_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyFloat_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyFloat_GetMax() -> c_double;
     pub fn PyFloat_GetMin() -> c_double;
     pub fn PyFloat_GetInfo() -> *mut PyObject;
@@ -23,4 +25,3 @@ pub unsafe fn PyFloat_CheckExact(op : *mut PyObject) -> c_int {
     pub fn PyFloat_FromDouble(arg1: c_double) -> *mut PyObject;
     pub fn PyFloat_AsDouble(arg1: *mut PyObject) -> c_double;
 }
-

src/ffi3/frameobject.rs

@@ -1,64 +1,75 @@
-use std::os::raw::{c_char, c_int};
-use ffi3::object::*;
 use ffi3::code::{PyCodeObject, CO_MAXBLOCKS};
+use ffi3::object::*;
 use ffi3::pystate::PyThreadState;
+use std::os::raw::{c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyTryBlock {
-    pub b_type : c_int,
+    pub b_type: c_int,
-    pub b_handler : c_int,
+    pub b_handler: c_int,
-    pub b_level : c_int,
+    pub b_level: c_int,
 }
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyFrameObject {
     pub ob_base: PyVarObject,
-    pub f_back: *mut PyFrameObject,	/* previous frame, or NULL */
+    pub f_back: *mut PyFrameObject,       /* previous frame, or NULL */
-    pub f_code: *mut PyCodeObject,	/* code segment */
+    pub f_code: *mut PyCodeObject,        /* code segment */
-    pub f_builtins: *mut PyObject,	/* builtin symbol table (PyDictObject) */
+    pub f_builtins: *mut PyObject,        /* builtin symbol table (PyDictObject) */
-    pub f_globals: *mut PyObject,	/* global symbol table (PyDictObject) */
+    pub f_globals: *mut PyObject,         /* global symbol table (PyDictObject) */
-    pub f_locals: *mut PyObject,		/* local symbol table (any mapping) */
+    pub f_locals: *mut PyObject,          /* local symbol table (any mapping) */
-    pub f_valuestack: *mut *mut PyObject,	/* points after the last local */
+    pub f_valuestack: *mut *mut PyObject, /* points after the last local */
     /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
        Frame evaluation usually NULLs it, but a frame that yields sets it
        to the current stack top. */
     pub f_stacktop: *mut *mut PyObject,
-    pub f_trace: *mut PyObject,		/* Trace function */
+    pub f_trace: *mut PyObject, /* Trace function */
 
     pub f_exc_type: *mut PyObject,
     pub f_exc_value: *mut PyObject,
     pub f_exc_traceback: *mut PyObject,
     pub f_gen: *mut PyObject,
 
-    pub f_lasti: c_int,		/* Last instruction if called */
+    pub f_lasti: c_int, /* Last instruction if called */
     /* Call PyFrame_GetLineNumber() instead of reading this field
        directly.  As of 2.3 f_lineno is only valid when tracing is
        active (i.e. when f_trace is set).  At other times we use
        PyCode_Addr2Line to calculate the line from the current
       bytecode index. */
-    pub f_lineno: c_int,		/* Current line number */
+    pub f_lineno: c_int,                          /* Current line number */
-    pub f_iblock: c_int,		/* index in f_blockstack */
+    pub f_iblock: c_int,                          /* index in f_blockstack */
-    pub f_executing: c_char,    /* whether the frame is still executing */
+    pub f_executing: c_char,                      /* whether the frame is still executing */
     pub f_blockstack: [PyTryBlock; CO_MAXBLOCKS], /* for try and loop blocks */
-    pub f_localsplus: [*mut PyObject; 1]	/* locals+stack, dynamically sized */
+    pub f_localsplus: [*mut PyObject; 1],         /* locals+stack, dynamically sized */
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyFrame_Type: PyTypeObject;
 }
 
 #[inline]
 pub unsafe fn PyFrame_Check(op: *mut PyObject) -> c_int {
-     (Py_TYPE(op) == &mut PyFrame_Type) as c_int
+    (Py_TYPE(op) == &mut PyFrame_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyFrame_New(tstate: *mut PyThreadState, code: *mut PyCodeObject,
+extern "C" {
-        globals: *mut PyObject, locals: *mut PyObject) -> *mut PyFrameObject;
+    pub fn PyFrame_New(
+        tstate: *mut PyThreadState,
+        code: *mut PyCodeObject,
+        globals: *mut PyObject,
+        locals: *mut PyObject,
+    ) -> *mut PyFrameObject;
 
-    pub fn PyFrame_BlockSetup(f: *mut PyFrameObject, _type: c_int, handler: c_int, level: c_int) -> ();
+    pub fn PyFrame_BlockSetup(
+        f: *mut PyFrameObject,
+        _type: c_int,
+        handler: c_int,
+        level: c_int,
+    ) -> ();
     pub fn PyFrame_BlockPop(f: *mut PyFrameObject) -> *mut PyTryBlock;
 
     pub fn PyFrame_LocalsToFast(f: *mut PyFrameObject, clear: c_int) -> ();

src/ffi3/genobject.rs

@@ -1,43 +1,46 @@
-use std::os::raw::c_int;
-use ffi3::pyport::Py_ssize_t;
-use ffi3::object::*;
 use ffi3::frameobject::PyFrameObject;
+use ffi3::object::*;
+use ffi3::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyGenObject {
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_next: *mut PyObject,
-    #[cfg(py_sys_config="Py_TRACE_REFS")]
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
     pub _ob_prev: *mut PyObject,
     pub ob_refcnt: Py_ssize_t,
     pub ob_type: *mut PyTypeObject,
     pub gi_frame: *mut PyFrameObject,
     pub gi_running: c_int,
     pub gi_code: *mut PyObject,
-    pub gi_weakreflist: *mut PyObject
+    pub gi_weakreflist: *mut PyObject,
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyGen_Type: PyTypeObject;
 }
 
 #[inline(always)]
 pub unsafe fn PyGen_Check(op: *mut PyObject) -> c_int {
-     PyObject_TypeCheck(op, &mut PyGen_Type)
+    PyObject_TypeCheck(op, &mut PyGen_Type)
 }
 
 #[inline(always)]
 pub unsafe fn PyGen_CheckExact(op: *mut PyObject) -> c_int {
-     (Py_TYPE(op) == &mut PyGen_Type) as c_int
+    (Py_TYPE(op) == &mut PyGen_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyGen_New(frame: *mut PyFrameObject) -> *mut PyObject;
     pub fn PyGen_NeedsFinalizing(op: *mut PyGenObject) -> c_int;
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyCoro_Type: PyTypeObject;
 }
 
@@ -46,7 +49,8 @@ pub unsafe fn PyCoro_Check(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, &mut PyCoro_Type)
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut _PyCoroWrapper_Type: PyTypeObject;
 }
 
@@ -56,7 +60,8 @@ pub unsafe fn PyCoroWrapper_Check(op: *mut PyObject) -> c_int {
 }
 
 #[cfg(Py_3_6)]
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyAsyncGen_Type: PyTypeObject;
 }
 

src/ffi3/import.rs

@@ -1,68 +1,70 @@
-use std::os::raw::{c_char, c_int, c_long};
 use ffi3::object::PyObject;
+use std::os::raw::{c_char, c_int, c_long};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyImport_GetMagicNumber() -> c_long;
     pub fn PyImport_GetMagicTag() -> *const c_char;
-    pub fn PyImport_ExecCodeModule(name: *const c_char,
+    pub fn PyImport_ExecCodeModule(name: *const c_char, co: *mut PyObject) -> *mut PyObject;
-                                   co: *mut PyObject) -> *mut PyObject;
+    pub fn PyImport_ExecCodeModuleEx(
-    pub fn PyImport_ExecCodeModuleEx(name: *const c_char,
+        name: *const c_char,
-                                     co: *mut PyObject,
+        co: *mut PyObject,
-                                     pathname: *const c_char)
+        pathname: *const c_char,
-     -> *mut PyObject;
+    ) -> *mut PyObject;
-    pub fn PyImport_ExecCodeModuleWithPathnames(name: *const c_char,
+    pub fn PyImport_ExecCodeModuleWithPathnames(
-                                                co: *mut PyObject,
+        name: *const c_char,
-                                                pathname:
+        co: *mut PyObject,
-                                                    *const c_char,
+        pathname: *const c_char,
-                                                cpathname:
+        cpathname: *const c_char,
-                                                    *const c_char)
+    ) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyImport_ExecCodeModuleObject(
-    pub fn PyImport_ExecCodeModuleObject(name: *mut PyObject,
+        name: *mut PyObject,
-                                         co: *mut PyObject,
+        co: *mut PyObject,
-                                         pathname: *mut PyObject,
+        pathname: *mut PyObject,
-                                         cpathname: *mut PyObject)
+        cpathname: *mut PyObject,
-     -> *mut PyObject;
+    ) -> *mut PyObject;
     pub fn PyImport_GetModuleDict() -> *mut PyObject;
     pub fn PyImport_AddModuleObject(name: *mut PyObject) -> *mut PyObject;
     pub fn PyImport_AddModule(name: *const c_char) -> *mut PyObject;
-    pub fn PyImport_ImportModule(name: *const c_char)
+    pub fn PyImport_ImportModule(name: *const c_char) -> *mut PyObject;
-     -> *mut PyObject;
+    pub fn PyImport_ImportModuleNoBlock(name: *const c_char) -> *mut PyObject;
-    pub fn PyImport_ImportModuleNoBlock(name: *const c_char)
+    pub fn PyImport_ImportModuleLevel(
-     -> *mut PyObject;
+        name: *const c_char,
-    pub fn PyImport_ImportModuleLevel(name: *const c_char,
+        globals: *mut PyObject,
-                                      globals: *mut PyObject,
+        locals: *mut PyObject,
-                                      locals: *mut PyObject,
+        fromlist: *mut PyObject,
-                                      fromlist: *mut PyObject,
+        level: c_int,
-                                      level: c_int) -> *mut PyObject;
+    ) -> *mut PyObject;
-    pub fn PyImport_ImportModuleLevelObject(name: *mut PyObject,
+    pub fn PyImport_ImportModuleLevelObject(
-                                            globals: *mut PyObject,
+        name: *mut PyObject,
-                                            locals: *mut PyObject,
+        globals: *mut PyObject,
-                                            fromlist: *mut PyObject,
+        locals: *mut PyObject,
-                                            level: c_int)
+        fromlist: *mut PyObject,
-     -> *mut PyObject;
+        level: c_int,
+    ) -> *mut PyObject;
 }
 
 #[inline]
-pub unsafe fn PyImport_ImportModuleEx(name: *const c_char,
+pub unsafe fn PyImport_ImportModuleEx(
-                                      globals: *mut PyObject,
+    name: *const c_char,
-                                      locals: *mut PyObject,
+    globals: *mut PyObject,
-                                      fromlist: *mut PyObject)
+    locals: *mut PyObject,
-  -> *mut PyObject {
+    fromlist: *mut PyObject,
+) -> *mut PyObject {
     PyImport_ImportModuleLevel(name, globals, locals, fromlist, 0)
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyImport_GetImporter(path: *mut PyObject) -> *mut PyObject;
     pub fn PyImport_Import(name: *mut PyObject) -> *mut PyObject;
     pub fn PyImport_ReloadModule(m: *mut PyObject) -> *mut PyObject;
     pub fn PyImport_Cleanup() -> ();
-    pub fn PyImport_ImportFrozenModuleObject(name: *mut PyObject)
+    pub fn PyImport_ImportFrozenModuleObject(name: *mut PyObject) -> c_int;
-     -> c_int;
+    pub fn PyImport_ImportFrozenModule(name: *const c_char) -> c_int;
-    pub fn PyImport_ImportFrozenModule(name: *const c_char)
-     -> c_int;
 
-    pub fn PyImport_AppendInittab(name: *const c_char,
+    pub fn PyImport_AppendInittab(
-                                  initfunc: Option<extern "C" fn() -> *mut PyObject>)
+        name: *const c_char,
-     -> c_int;
+        initfunc: Option<extern "C" fn() -> *mut PyObject>,
+    ) -> c_int;
 }
-

src/ffi3/intrcheck.rs

@@ -1,8 +1,8 @@
 use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyOS_InterruptOccurred() -> c_int;
     pub fn PyOS_InitInterrupts() -> ();
     pub fn PyOS_AfterFork() -> ();
 }
-

src/ffi3/iterobject.rs

@@ -1,13 +1,13 @@
-use std::os::raw::c_int;
 use ffi3::object::*;
+use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PySeqIter_Type: PyTypeObject;
     pub static mut PyCallIter_Type: PyTypeObject;
 
     pub fn PySeqIter_New(arg1: *mut PyObject) -> *mut PyObject;
-    pub fn PyCallIter_New(arg1: *mut PyObject, arg2: *mut PyObject)
+    pub fn PyCallIter_New(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
-     -> *mut PyObject;
 }
 
 #[inline(always)]
@@ -19,5 +19,3 @@ pub unsafe fn PySeqIter_Check(op: *mut PyObject) -> c_int {
 pub unsafe fn PyCallIter_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyCallIter_Type) as c_int
 }
-
-

src/ffi3/listobject.rs

@@ -1,34 +1,43 @@
-use std::os::raw::c_int;
-use ffi3::pyport::Py_ssize_t;
 use ffi3::object::*;
+use ffi3::pyport::Py_ssize_t;
+use std::os::raw::c_int;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyList_Type: PyTypeObject;
     pub static mut PyListIter_Type: PyTypeObject;
     pub static mut PyListRevIter_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyList_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyList_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyList_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyList_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyList_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyList_New(size: Py_ssize_t) -> *mut PyObject;
     pub fn PyList_Size(arg1: *mut PyObject) -> Py_ssize_t;
     pub fn PyList_GetItem(arg1: *mut PyObject, arg2: Py_ssize_t) -> *mut PyObject;
     pub fn PyList_SetItem(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject) -> c_int;
     pub fn PyList_Insert(arg1: *mut PyObject, arg2: Py_ssize_t, arg3: *mut PyObject) -> c_int;
     pub fn PyList_Append(arg1: *mut PyObject, arg2: *mut PyObject) -> c_int;
-    pub fn PyList_GetSlice(arg1: *mut PyObject, arg2: Py_ssize_t,
+    pub fn PyList_GetSlice(
-                           arg3: Py_ssize_t) -> *mut PyObject;
+        arg1: *mut PyObject,
-    pub fn PyList_SetSlice(arg1: *mut PyObject, arg2: Py_ssize_t,
+        arg2: Py_ssize_t,
-                           arg3: Py_ssize_t, arg4: *mut PyObject) -> c_int;
+        arg3: Py_ssize_t,
+    ) -> *mut PyObject;
+    pub fn PyList_SetSlice(
+        arg1: *mut PyObject,
+        arg2: Py_ssize_t,
+        arg3: Py_ssize_t,
+        arg4: *mut PyObject,
+    ) -> c_int;
     pub fn PyList_Sort(arg1: *mut PyObject) -> c_int;
     pub fn PyList_Reverse(arg1: *mut PyObject) -> c_int;
     pub fn PyList_AsTuple(arg1: *mut PyObject) -> *mut PyObject;

src/ffi3/longobject.rs

@@ -1,36 +1,36 @@
-use libc::size_t;
-use std::os::raw::{
-    c_void, c_char, c_int, c_long, c_ulong, c_longlong, c_ulonglong, c_double, c_uchar
-};
 use ffi3::object::*;
 use ffi3::pyport::Py_ssize_t;
+use libc::size_t;
+use std::os::raw::{
+    c_char, c_double, c_int, c_long, c_longlong, c_uchar, c_ulong, c_ulonglong, c_void,
+};
 
 pub enum PyLongObject {}
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyLong_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyLong_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyLong_Check(op: *mut PyObject) -> c_int {
     PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS)
 }
 
 #[inline(always)]
-pub unsafe fn PyLong_CheckExact(op : *mut PyObject) -> c_int {
+pub unsafe fn PyLong_CheckExact(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyLong_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyLong_FromLong(arg1: c_long) -> *mut PyObject;
     pub fn PyLong_FromUnsignedLong(arg1: c_ulong) -> *mut PyObject;
     pub fn PyLong_FromSize_t(arg1: size_t) -> *mut PyObject;
     pub fn PyLong_FromSsize_t(arg1: Py_ssize_t) -> *mut PyObject;
     pub fn PyLong_FromDouble(arg1: c_double) -> *mut PyObject;
     pub fn PyLong_AsLong(arg1: *mut PyObject) -> c_long;
-    pub fn PyLong_AsLongAndOverflow(arg1: *mut PyObject,
+    pub fn PyLong_AsLongAndOverflow(arg1: *mut PyObject, arg2: *mut c_int) -> c_long;
-                                    arg2: *mut c_int)
-     -> c_long;
     pub fn PyLong_AsSsize_t(arg1: *mut PyObject) -> Py_ssize_t;
     pub fn PyLong_AsSize_t(arg1: *mut PyObject) -> size_t;
     pub fn PyLong_AsUnsignedLong(arg1: *mut PyObject) -> c_ulong;
@@ -40,25 +40,18 @@ pub unsafe fn PyLong_CheckExact(op : *mut PyObject) -> c_int {
     pub fn PyLong_FromVoidPtr(arg1: *mut c_void) -> *mut PyObject;
     pub fn PyLong_AsVoidPtr(arg1: *mut PyObject) -> *mut c_void;
     pub fn PyLong_FromLongLong(arg1: c_longlong) -> *mut PyObject;
-    pub fn PyLong_FromUnsignedLongLong(arg1: c_ulonglong)
+    pub fn PyLong_FromUnsignedLongLong(arg1: c_ulonglong) -> *mut PyObject;
-     -> *mut PyObject;
     pub fn PyLong_AsLongLong(arg1: *mut PyObject) -> c_longlong;
-    pub fn PyLong_AsUnsignedLongLong(arg1: *mut PyObject)
+    pub fn PyLong_AsUnsignedLongLong(arg1: *mut PyObject) -> c_ulonglong;
-     -> c_ulonglong;
+    pub fn PyLong_AsUnsignedLongLongMask(arg1: *mut PyObject) -> c_ulonglong;
-    pub fn PyLong_AsUnsignedLongLongMask(arg1: *mut PyObject)
+    pub fn PyLong_AsLongLongAndOverflow(arg1: *mut PyObject, arg2: *mut c_int) -> c_longlong;
-     -> c_ulonglong;
+    pub fn PyLong_FromString(
-    pub fn PyLong_AsLongLongAndOverflow(arg1: *mut PyObject,
+        arg1: *const c_char,
-                                        arg2: *mut c_int)
+        arg2: *mut *mut c_char,
-     -> c_longlong;
+        arg3: c_int,
-    pub fn PyLong_FromString(arg1: *const c_char,
+    ) -> *mut PyObject;
-                             arg2: *mut *mut c_char,
+    pub fn PyOS_strtoul(arg1: *const c_char, arg2: *mut *mut c_char, arg3: c_int) -> c_ulong;
-                             arg3: c_int) -> *mut PyObject;
+    pub fn PyOS_strtol(arg1: *const c_char, arg2: *mut *mut c_char, arg3: c_int) -> c_long;
-    pub fn PyOS_strtoul(arg1: *const c_char,
-                        arg2: *mut *mut c_char, arg3: c_int)
-     -> c_ulong;
-    pub fn PyOS_strtol(arg1: *const c_char,
-                       arg2: *mut *mut c_char, arg3: c_int)
-     -> c_long;
 }
 
 #[cfg(not(Py_LIMITED_API))]

src/ffi3/memoryobject.rs

@@ -1,22 +1,28 @@
-use std::os::raw::{c_int, c_char};
-use ffi3::pyport::Py_ssize_t;
 use ffi3::object::*;
+use ffi3::pyport::Py_ssize_t;
+use std::os::raw::{c_char, c_int};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyMemoryView_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyMemoryView_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyMemoryView_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyMemoryView_Type) as c_int
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyMemoryView_FromObject(base: *mut PyObject) -> *mut PyObject;
-    pub fn PyMemoryView_FromMemory(mem: *mut c_char, size: Py_ssize_t,
+    pub fn PyMemoryView_FromMemory(
-                                   flags: c_int) -> *mut PyObject;
+        mem: *mut c_char,
-    pub fn PyMemoryView_GetContiguous(base: *mut PyObject,
+        size: Py_ssize_t,
-                                      buffertype: c_int,
+        flags: c_int,
-                                      order: c_char) -> *mut PyObject;
+    ) -> *mut PyObject;
+    pub fn PyMemoryView_GetContiguous(
+        base: *mut PyObject,
+        buffertype: c_int,
+        order: c_char,
+    ) -> *mut PyObject;
 }
-

src/ffi3/methodobject.rs

@@ -1,41 +1,44 @@
+use ffi3::object::{PyObject, PyTypeObject, Py_TYPE};
 use std::os::raw::{c_char, c_int};
 use std::{mem, ptr};
-use ffi3::object::{PyObject, PyTypeObject, Py_TYPE};
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub static mut PyCFunction_Type: PyTypeObject;
 }
 
 #[inline(always)]
-pub unsafe fn PyCFunction_Check(op : *mut PyObject) -> c_int {
+pub unsafe fn PyCFunction_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == &mut PyCFunction_Type) as c_int
 }
 
 pub type PyCFunction =
-    unsafe extern "C" fn (slf: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
+    unsafe extern "C" fn(slf: *mut PyObject, args: *mut PyObject) -> *mut PyObject;
 
 #[cfg(all(Py_3_6, not(Py_LIMITED_API)))]
-pub type _PyCFunctionFast =
+pub type _PyCFunctionFast = unsafe extern "C" fn(
-    unsafe extern "C" fn (slf: *mut PyObject,
+    slf: *mut PyObject,
-                          args: *mut *mut PyObject,
+    args: *mut *mut PyObject,
-                          nargs: ::ffi3::pyport::Py_ssize_t,
+    nargs: ::ffi3::pyport::Py_ssize_t,
-                          kwnames: *mut PyObject) -> *mut PyObject;
+    kwnames: *mut PyObject,
+) -> *mut PyObject;
 
 pub type PyCFunctionWithKeywords =
-    unsafe extern "C" fn (slf: *mut PyObject,
+    unsafe extern "C" fn(slf: *mut PyObject, args: *mut PyObject, kwds: *mut PyObject)
-                          args: *mut PyObject,
+        -> *mut PyObject;
-                          kwds: *mut PyObject) -> *mut PyObject;
 
-pub type PyNoArgsFunction =
+pub type PyNoArgsFunction = unsafe extern "C" fn(slf: *mut PyObject) -> *mut PyObject;
-    unsafe extern "C" fn(slf: *mut PyObject) -> *mut PyObject;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyCFunction_GetFunction(f: *mut PyObject) -> Option<PyCFunction>;
     pub fn PyCFunction_GetSelf(f: *mut PyObject) -> *mut PyObject;
     pub fn PyCFunction_GetFlags(f: *mut PyObject) -> c_int;
-    pub fn PyCFunction_Call(f: *mut PyObject,
+    pub fn PyCFunction_Call(
-                            args: *mut PyObject,
+        f: *mut PyObject,
-                            kwds: *mut PyObject) -> *mut PyObject;
+        args: *mut PyObject,
+        kwds: *mut PyObject,
+    ) -> *mut PyObject;
 }
 
 #[repr(C)]
@@ -47,7 +50,7 @@ pub struct PyMethodDef {
     pub ml_doc: *const c_char,
 }
 
-pub const PyMethodDef_INIT : PyMethodDef = PyMethodDef {
+pub const PyMethodDef_INIT: PyMethodDef = PyMethodDef {
     ml_name: ::std::ptr::null(),
     ml_meth: None,
     ml_flags: 0,
@@ -55,7 +58,9 @@ pub const PyMethodDef_INIT : PyMethodDef = PyMethodDef {
 };
 
 impl Default for PyMethodDef {
-    fn default() -> PyMethodDef { unsafe { mem::zeroed() } }
+    fn default() -> PyMethodDef {
+        unsafe { mem::zeroed() }
+    }
 }
 
 #[inline(always)]
@@ -63,35 +68,39 @@ pub unsafe fn PyCFunction_New(ml: *mut PyMethodDef, slf: *mut PyObject) -> *mut
     PyCFunction_NewEx(ml, slf, ptr::null_mut())
 }
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
-    pub fn PyCFunction_NewEx(arg1: *mut PyMethodDef, arg2: *mut PyObject,
+extern "C" {
-                             arg3: *mut PyObject) -> *mut PyObject;
+    pub fn PyCFunction_NewEx(
+        arg1: *mut PyMethodDef,
+        arg2: *mut PyObject,
+        arg3: *mut PyObject,
+    ) -> *mut PyObject;
 }
 
 /* Flag passed to newmethodobject */
-pub const METH_VARARGS  : c_int = 0x0001;
+pub const METH_VARARGS: c_int = 0x0001;
-pub const METH_KEYWORDS : c_int = 0x0002;
+pub const METH_KEYWORDS: c_int = 0x0002;
 /* METH_NOARGS and METH_O must not be combined with the flags above. */
-pub const METH_NOARGS   : c_int = 0x0004;
+pub const METH_NOARGS: c_int = 0x0004;
-pub const METH_O        : c_int = 0x0008;
+pub const METH_O: c_int = 0x0008;
 
 /* METH_CLASS and METH_STATIC are a little different; these control
    the construction of methods for a class.  These cannot be used for
    functions in modules. */
-pub const METH_CLASS    : c_int = 0x0010;
+pub const METH_CLASS: c_int = 0x0010;
-pub const METH_STATIC   : c_int = 0x0020;
+pub const METH_STATIC: c_int = 0x0020;
 
 /* METH_COEXIST allows a method to be entered eventhough a slot has
    already filled the entry.  When defined, the flag allows a separate
    method, "__contains__" for example, to coexist with a defined
    slot like sq_contains. */
 
-pub const METH_COEXIST   : c_int = 0x0040;
+pub const METH_COEXIST: c_int = 0x0040;
 
 #[cfg(all(Py_3_6, not(Py_LIMITED_API)))]
-pub const METHOD_FASTCALL : c_int = 0x0080;
+pub const METHOD_FASTCALL: c_int = 0x0080;
 
-#[cfg_attr(windows, link(name="pythonXY"))] extern "C" {
+#[cfg_attr(windows, link(name = "pythonXY"))]
+extern "C" {
     pub fn PyCFunction_ClearFreeList() -> c_int;
 }
-