src/libio/Cargo.toml

@@ -8,10 +8,9 @@ name = "io"
 path = "lib.rs"
 
 [dependencies]
-core_io = { version = "0.1", features = ["collections"] }
+failure = { version = "0.1", default-features = false }
+failure_derive = { version = "0.1", default-features = false }
 byteorder = { version = "1.0", default-features = false, optional = true }
 
-libsupport_zynq = { default-features = false, features = ["alloc_core"], git = "https://git.m-labs.hk/M-Labs/zynq-rs.git" }
-
 [features]
 alloc = []

src/libio/lib.rs

@@ -2,12 +2,12 @@
 #![feature(never_type)]
 #![cfg_attr(feature = "alloc", feature(alloc))]
 
-extern crate alloc;
-extern crate core_io;
-
+extern crate failure;
+#[macro_use]
+extern crate failure_derive;
 #[cfg(feature = "alloc")]
 #[macro_use]
-use alloc;
+extern crate alloc;
 #[cfg(feature = "byteorder")]
 extern crate byteorder;
 
@@ -21,9 +21,12 @@ pub use proto::{ProtoRead, ProtoWrite};
 #[cfg(all(feature = "byteorder", feature = "alloc"))]
 pub use proto::ReadStringError;
 
+#[derive(Fail, Debug, Clone, PartialEq)]
 pub enum Error<T> {
+    #[fail(display = "unexpected end of stream")]
     UnexpectedEnd,
-    Other(T)
+    #[fail(display = "{}", _0)]
+    Other(#[cause] T)
 }
 
 impl<T> From<T> for Error<T> {

src/libio/proto.rs

@@ -1,14 +1,15 @@
-use core::str::Utf8Error;
-use byteorder::{ByteOrder, NativeEndian};
-use alloc::vec;
-use alloc::string::String;
+#[cfg(feature = "alloc")]
+use {core::str::Utf8Error, alloc::String};
+use byteorder::{ByteOrder, NetworkEndian};
 
-use core_io::{Read, Write, Error as IoError};
+use ::{Read, Write, Error as IoError};
 
-#[allow(dead_code)]
-#[derive(Debug, Clone, PartialEq)]
+#[cfg(feature = "alloc")]
+#[derive(Fail, Debug, Clone, PartialEq)]
 pub enum ReadStringError<T> {
+    #[fail(display = "invalid UTF-8: {}", _0)]
     Utf8(Utf8Error),
+    #[fail(display = "{}", _0)]
     Other(T)
 }
 
@@ -28,21 +29,21 @@ pub trait ProtoRead {
     fn read_u16(&mut self) -> Result<u16, Self::ReadError> {
         let mut bytes = [0; 2];
         self.read_exact(&mut bytes)?;
-        Ok(NativeEndian::read_u16(&bytes))
+        Ok(NetworkEndian::read_u16(&bytes))
     }
 
     #[inline]
     fn read_u32(&mut self) -> Result<u32, Self::ReadError> {
         let mut bytes = [0; 4];
         self.read_exact(&mut bytes)?;
-        Ok(NativeEndian::read_u32(&bytes))
+        Ok(NetworkEndian::read_u32(&bytes))
     }
 
     #[inline]
     fn read_u64(&mut self) -> Result<u64, Self::ReadError> {
         let mut bytes = [0; 8];
         self.read_exact(&mut bytes)?;
-        Ok(NativeEndian::read_u64(&bytes))
+        Ok(NetworkEndian::read_u64(&bytes))
     }
 
     #[inline]
@@ -50,16 +51,18 @@ pub trait ProtoRead {
         Ok(self.read_u8()? != 0)
     }
 
+    #[cfg(feature = "alloc")]
     #[inline]
-    fn read_bytes(&mut self) -> Result<::alloc::vec::Vec<u8>, Self::ReadError> {
+    fn read_bytes(&mut self) -> Result<::alloc::Vec<u8>, Self::ReadError> {
         let length = self.read_u32()?;
         let mut value = vec![0; length as usize];
         self.read_exact(&mut value)?;
         Ok(value)
     }
 
+    #[cfg(feature = "alloc")]
     #[inline]
-    fn read_string(&mut self) -> Result<::alloc::string::String, ReadStringError<Self::ReadError>> {
+    fn read_string(&mut self) -> Result<::alloc::String, ReadStringError<Self::ReadError>> {
         let bytes = self.read_bytes().map_err(ReadStringError::Other)?;
         String::from_utf8(bytes).map_err(|err| ReadStringError::Utf8(err.utf8_error()))
     }
@@ -85,42 +88,42 @@ pub trait ProtoWrite {
     #[inline]
     fn write_u16(&mut self, value: u16) -> Result<(), Self::WriteError> {
         let mut bytes = [0; 2];
-        NativeEndian::write_u16(&mut bytes, value);
+        NetworkEndian::write_u16(&mut bytes, value);
         self.write_all(&bytes)
     }
 
     #[inline]
     fn write_i16(&mut self, value: i16) -> Result<(), Self::WriteError> {
         let mut bytes = [0; 2];
-        NativeEndian::write_i16(&mut bytes, value);
+        NetworkEndian::write_i16(&mut bytes, value);
         self.write_all(&bytes)
     }
 
     #[inline]
     fn write_u32(&mut self, value: u32) -> Result<(), Self::WriteError> {
         let mut bytes = [0; 4];
-        NativeEndian::write_u32(&mut bytes, value);
+        NetworkEndian::write_u32(&mut bytes, value);
         self.write_all(&bytes)
     }
 
     #[inline]
     fn write_i32(&mut self, value: i32) -> Result<(), Self::WriteError> {
         let mut bytes = [0; 4];
-        NativeEndian::write_i32(&mut bytes, value);
+        NetworkEndian::write_i32(&mut bytes, value);
         self.write_all(&bytes)
     }
 
     #[inline]
     fn write_u64(&mut self, value: u64) -> Result<(), Self::WriteError> {
         let mut bytes = [0; 8];
-        NativeEndian::write_u64(&mut bytes, value);
+        NetworkEndian::write_u64(&mut bytes, value);
         self.write_all(&bytes)
     }
 
     #[inline]
     fn write_i64(&mut self, value: i64) -> Result<(), Self::WriteError> {
         let mut bytes = [0; 8];
-        NativeEndian::write_i64(&mut bytes, value);
+        NetworkEndian::write_i64(&mut bytes, value);
         self.write_all(&bytes)
     }
 
@@ -142,7 +145,7 @@ pub trait ProtoWrite {
 }
 
 impl<T> ProtoRead for T where T: Read + ?Sized {
-    type ReadError = IoError;
+    type ReadError = IoError<T::ReadError>;
 
     fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::ReadError> {
         T::read_exact(self, buf)
@@ -150,7 +153,7 @@ impl<T> ProtoRead for T where T: Read + ?Sized {
 }
 
 impl<T> ProtoWrite for T where T: Write + ?Sized {
-    type WriteError = IoError;
+    type WriteError = IoError<T::WriteError>;
 
     fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::WriteError> {
         T::write_all(self, buf)

src/runtime/Cargo.toml

@@ -40,5 +40,4 @@ dyld = { path = "../libdyld" }
 dwarf = { path = "../libdwarf" }
 unwind = { path = "../libunwind" }
 libc = { path = "../libc" }
-io = { path = "../libio" }
 libboard_artiq = { path = "../libboard_artiq" }

src/runtime/src/main.rs

@@ -26,6 +26,7 @@ use libcortex_a9::l2c::enable_l2_cache;
 #[cfg(feature = "target_kasli_soc")]
 use libboard_artiq::{si5324, logger};
 
+mod proto_core_io;
 mod proto_async;
 mod comms;
 mod rpc;

src/runtime/src/proto_core_io.rs

@@ -0,0 +1,158 @@
+use core::str::Utf8Error;
+use byteorder::{ByteOrder, NativeEndian};
+use alloc::vec;
+use alloc::string::String;
+
+use core_io::{Read, Write, Error as IoError};
+
+#[allow(dead_code)]
+#[derive(Debug, Clone, PartialEq)]
+pub enum ReadStringError<T> {
+    Utf8(Utf8Error),
+    Other(T)
+}
+
+pub trait ProtoRead {
+    type ReadError;
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::ReadError>;
+
+    #[inline]
+    fn read_u8(&mut self) -> Result<u8, Self::ReadError> {
+        let mut bytes = [0; 1];
+        self.read_exact(&mut bytes)?;
+        Ok(bytes[0])
+    }
+
+    #[inline]
+    fn read_u16(&mut self) -> Result<u16, Self::ReadError> {
+        let mut bytes = [0; 2];
+        self.read_exact(&mut bytes)?;
+        Ok(NativeEndian::read_u16(&bytes))
+    }
+
+    #[inline]
+    fn read_u32(&mut self) -> Result<u32, Self::ReadError> {
+        let mut bytes = [0; 4];
+        self.read_exact(&mut bytes)?;
+        Ok(NativeEndian::read_u32(&bytes))
+    }
+
+    #[inline]
+    fn read_u64(&mut self) -> Result<u64, Self::ReadError> {
+        let mut bytes = [0; 8];
+        self.read_exact(&mut bytes)?;
+        Ok(NativeEndian::read_u64(&bytes))
+    }
+
+    #[inline]
+    fn read_bool(&mut self) -> Result<bool, Self::ReadError> {
+        Ok(self.read_u8()? != 0)
+    }
+
+    #[inline]
+    fn read_bytes(&mut self) -> Result<::alloc::vec::Vec<u8>, Self::ReadError> {
+        let length = self.read_u32()?;
+        let mut value = vec![0; length as usize];
+        self.read_exact(&mut value)?;
+        Ok(value)
+    }
+
+    #[inline]
+    fn read_string(&mut self) -> Result<::alloc::string::String, ReadStringError<Self::ReadError>> {
+        let bytes = self.read_bytes().map_err(ReadStringError::Other)?;
+        String::from_utf8(bytes).map_err(|err| ReadStringError::Utf8(err.utf8_error()))
+    }
+}
+
+pub trait ProtoWrite {
+    type WriteError;
+
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::WriteError>;
+
+    #[inline]
+    fn write_u8(&mut self, value: u8) -> Result<(), Self::WriteError> {
+        let bytes = [value; 1];
+        self.write_all(&bytes)
+    }
+
+    #[inline]
+    fn write_i8(&mut self, value: i8) -> Result<(), Self::WriteError> {
+        let bytes = [value as u8; 1];
+        self.write_all(&bytes)
+    }
+
+    #[inline]
+    fn write_u16(&mut self, value: u16) -> Result<(), Self::WriteError> {
+        let mut bytes = [0; 2];
+        NativeEndian::write_u16(&mut bytes, value);
+        self.write_all(&bytes)
+    }
+
+    #[inline]
+    fn write_i16(&mut self, value: i16) -> Result<(), Self::WriteError> {
+        let mut bytes = [0; 2];
+        NativeEndian::write_i16(&mut bytes, value);
+        self.write_all(&bytes)
+    }
+
+    #[inline]
+    fn write_u32(&mut self, value: u32) -> Result<(), Self::WriteError> {
+        let mut bytes = [0; 4];
+        NativeEndian::write_u32(&mut bytes, value);
+        self.write_all(&bytes)
+    }
+
+    #[inline]
+    fn write_i32(&mut self, value: i32) -> Result<(), Self::WriteError> {
+        let mut bytes = [0; 4];
+        NativeEndian::write_i32(&mut bytes, value);
+        self.write_all(&bytes)
+    }
+
+    #[inline]
+    fn write_u64(&mut self, value: u64) -> Result<(), Self::WriteError> {
+        let mut bytes = [0; 8];
+        NativeEndian::write_u64(&mut bytes, value);
+        self.write_all(&bytes)
+    }
+
+    #[inline]
+    fn write_i64(&mut self, value: i64) -> Result<(), Self::WriteError> {
+        let mut bytes = [0; 8];
+        NativeEndian::write_i64(&mut bytes, value);
+        self.write_all(&bytes)
+    }
+
+    #[inline]
+    fn write_bool(&mut self, value: bool) -> Result<(), Self::WriteError> {
+        self.write_u8(value as u8)
+    }
+
+    #[inline]
+    fn write_bytes(&mut self, value: &[u8]) -> Result<(), Self::WriteError> {
+        self.write_u32(value.len() as u32)?;
+        self.write_all(value)
+    }
+
+    #[inline]
+    fn write_string(&mut self, value: &str) -> Result<(), Self::WriteError> {
+        self.write_bytes(value.as_bytes())
+    }
+}
+
+impl<T> ProtoRead for T where T: Read + ?Sized {
+    type ReadError = IoError;
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::ReadError> {
+        T::read_exact(self, buf)
+    }
+}
+
+impl<T> ProtoWrite for T where T: Write + ?Sized {
+    type WriteError = IoError;
+
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::WriteError> {
+        T::write_all(self, buf)
+    }
+}

src/runtime/src/rpc.rs

@@ -10,7 +10,7 @@ use libasync::smoltcp::TcpStream;
 use alloc::boxed::Box;
 use async_recursion::async_recursion;
 
-use io::proto::ProtoWrite;
+use crate::proto_core_io::ProtoWrite;
 use crate::proto_async;
 use self::tag::{Tag, TagIterator, split_tag};