Merge #19

19: Update software for edition 2018. r=posborne a=brandonedens



Co-authored-by: Brandon Edens <brandonedens@gmail.com>

Author: bors[bot]

.travis.yml

@@ -1,7 +1,7 @@
 language: rust
 sudo: false
 rust:
-  - 1.26.0  # MSRV
+  - 1.31.0  # MSRV
   - stable
   - beta
   - nightly

Cargo.toml

@@ -3,6 +3,7 @@
 name = "spidev"
 version = "0.4.0"
 authors = ["Paul Osborne <osbpau@gmail.com>"]
+edition = "2018"
 license = "MIT/Apache-2.0"
 repository = "https://github.com/rust-embedded/rust-spidev"
 homepage = "https://github.com/rust-embedded/rust-spidev"

README.md

@@ -76,7 +76,7 @@ The following features are implemented and planned for the library:
 
 ## Minimum Supported Rust Version (MSRV)
 
-This crate is guaranteed to compile on stable Rust 1.26 and up.  It *might*
+This crate is guaranteed to compile on stable Rust 1.31 and up.  It *might*
 compile with older versions but that may change in any new patch release.
 
 ## Cross Compiling

src/lib.rs

@@ -28,21 +28,21 @@
 //! use spidev::{Spidev, SpidevOptions, SpidevTransfer, SpiModeFlags};
 //!
 //! fn create_spi() -> io::Result<Spidev> {
-//!     let mut spi = try!(Spidev::open("/dev/spidev0.0"));
+//!     let mut spi = Spidev::open("/dev/spidev0.0")?;
 //!     let options = SpidevOptions::new()
 //!          .bits_per_word(8)
 //!          .max_speed_hz(20_000)
 //!          .mode(SpiModeFlags::SPI_MODE_0)
 //!          .build();
-//!     try!(spi.configure(&options));
+//!     spi.configure(&options)?;
 //!     Ok(spi)
 //! }
 //!
 //! /// perform half duplex operations using Read and Write traits
 //! fn half_duplex(spi: &mut Spidev) -> io::Result<()> {
 //!     let mut rx_buf = [0_u8; 10];
-//!     try!(spi.write(&[0x01, 0x02, 0x03]));
-//!     try!(spi.read(&mut rx_buf));
+//!     spi.write(&[0x01, 0x02, 0x03])?;
+//!     spi.read(&mut rx_buf)?;
 //!     println!("{:?}", rx_buf);
 //!     Ok(())
 //! }
@@ -55,7 +55,7 @@
 //!     let mut rx_buf = [0; 3];
 //!     {
 //!         let mut transfer = SpidevTransfer::read_write(&tx_buf, &mut rx_buf);
-//!         try!(spi.transfer(&mut transfer));
+//!         spi.transfer(&mut transfer)?;
 //!     }
 //!     println!("{:?}", rx_buf);
 //!     Ok(())
@@ -75,7 +75,7 @@ extern crate nix;
 extern crate bitflags;
 
 pub mod spidevioctl;
-pub use spidevioctl::SpidevTransfer;
+pub use crate::spidevioctl::SpidevTransfer;
 
 use std::io;
 use std::io::prelude::*;
@@ -243,16 +243,16 @@ impl Spidev {
         // overhead
         let fd = self.devfile.as_raw_fd();
         if let Some(bpw) = options.bits_per_word {
-            try!(spidevioctl::set_bits_per_word(fd, bpw));
+            spidevioctl::set_bits_per_word(fd, bpw)?;
         }
         if let Some(speed) = options.max_speed_hz {
-            try!(spidevioctl::set_max_speed_hz(fd, speed));
+            spidevioctl::set_max_speed_hz(fd, speed)?;
         }
         if let Some(lsb_first) = options.lsb_first {
-            try!(spidevioctl::set_lsb_first(fd, lsb_first));
+            spidevioctl::set_lsb_first(fd, lsb_first)?;
         }
         if let Some(spi_mode_flags) = options.spi_mode {
-            try!(spidevioctl::set_mode(fd, spi_mode_flags));
+            spidevioctl::set_mode(fd, spi_mode_flags)?;
         }
         Ok(())
     }

src/spidevioctl.rs

@@ -151,7 +151,7 @@ pub type SpidevTransfer<'a, 'b> = spi_ioc_transfer<'a, 'b>;
 
 pub fn get_mode(fd: RawFd) -> io::Result<u8> {
     let mut mode: u8 = 0;
-    try!(from_nix_result(unsafe { ioctl::get_mode_u8(fd, &mut mode) }));
+    from_nix_result(unsafe { ioctl::get_mode_u8(fd, &mut mode) })?;
     Ok(mode)
 }
 
@@ -161,17 +161,17 @@ pub fn set_mode(fd: RawFd, mode: SpiModeFlags) -> io::Result<()> {
     // added until later kernels.  This provides a reasonable story
     // for forwards and backwards compatibility
     if (mode.bits & 0xFFFFFF00) != 0 {
-        try!(from_nix_result(unsafe { ioctl::set_mode32(fd, &mode.bits) }));
+        from_nix_result(unsafe { ioctl::set_mode32(fd, &mode.bits) })?;
     } else {
         let bits: u8 = mode.bits as u8;
-        try!(from_nix_result(unsafe { ioctl::set_mode(fd, &bits) }));
+        from_nix_result(unsafe { ioctl::set_mode(fd, &bits) })?;
     }
     Ok(())
 }
 
 pub fn get_lsb_first(fd: RawFd) -> io::Result<u8> {
     let mut lsb_first: u8 = 0;
-    try!(from_nix_result(unsafe { ioctl::get_lsb_first(fd, &mut lsb_first) }));
+    from_nix_result(unsafe { ioctl::get_lsb_first(fd, &mut lsb_first) })?;
     Ok(lsb_first)
 }
 
@@ -181,42 +181,42 @@ pub fn set_lsb_first(fd: RawFd, lsb_first: bool) -> io::Result<()> {
     } else {
         0
     };
-    try!(from_nix_result(unsafe { ioctl::set_lsb_first(fd, &lsb_first_value) }));
+    from_nix_result(unsafe { ioctl::set_lsb_first(fd, &lsb_first_value) })?;
     Ok(())
 }
 
 pub fn get_bits_per_word(fd: RawFd) -> io::Result<u8> {
     let mut bits_per_word: u8 = 0;
-    try!(from_nix_result(unsafe { ioctl::get_bits_per_word(fd, &mut bits_per_word) }));
+    from_nix_result(unsafe { ioctl::get_bits_per_word(fd, &mut bits_per_word) })?;
     Ok(bits_per_word)
 }
 
 pub fn set_bits_per_word(fd: RawFd, bits_per_word: u8) -> io::Result<()> {
-    try!(from_nix_result(unsafe { ioctl::set_bits_per_word(fd, &bits_per_word) }));
+    from_nix_result(unsafe { ioctl::set_bits_per_word(fd, &bits_per_word) })?;
     Ok(())
 }
 
 pub fn get_max_speed_hz(fd: RawFd) -> io::Result<u32> {
     let mut max_speed_hz: u32 = 0;
-    try!(from_nix_result(unsafe { ioctl::get_max_speed_hz(fd, &mut max_speed_hz) }));
+    from_nix_result(unsafe { ioctl::get_max_speed_hz(fd, &mut max_speed_hz) })?;
     Ok(max_speed_hz)
 }
 
 pub fn set_max_speed_hz(fd: RawFd, max_speed_hz: u32) -> io::Result<()> {
-    try!(from_nix_result(unsafe { ioctl::set_max_speed_hz(fd, &max_speed_hz) }));
+    from_nix_result(unsafe { ioctl::set_max_speed_hz(fd, &max_speed_hz) })?;
     Ok(())
 }
 
 pub fn transfer(fd: RawFd, transfer: &mut SpidevTransfer) -> io::Result<()> {
     // The kernel will directly modify the rx_buf of the SpidevTransfer
     // rx_buf if present, so there is no need to do any additional work
-    try!(from_nix_result(unsafe { ioctl::spidev_transfer(fd, transfer) }));
+    from_nix_result(unsafe { ioctl::spidev_transfer(fd, transfer) })?;
     Ok(())
 }
 
 pub fn transfer_multiple(fd: RawFd, transfers: &mut [SpidevTransfer]) -> io::Result<()> {
-    try!(from_nix_result(unsafe {
+    from_nix_result(unsafe {
         ioctl::spidev_transfer_buf(fd, transfers)
-    }));
+    })?;
     Ok(())
 }