drop write macro in favor of IO objects + fmt::Write

closes #4
closes #5
closes #6
closes #7
closes #11

src/debug.rs

@@ -26,6 +26,8 @@
 
 /// This values are taken from section 5.5.2 of
 /// ADS Debug Target Guide (DUI0058).
+// TODO document
+#[allow(missing_docs)]
 pub enum Exception {
     // Hardware reason codes
     BranchThroughZero = 0x20000,

src/hio.rs

@@ -0,0 +1,78 @@
+//! Host I/O
+
+use core::{fmt, slice};
+use nr;
+
+/// Host's standard error
+pub struct HStderr {
+    fd: usize,
+}
+
+impl HStderr {
+    /// Attempts to write an entire `buffer` into this sink
+    pub fn write_all(&mut self, buffer: &[u8]) -> Result<(), ()> {
+        write_all(self.fd, buffer)
+    }
+}
+
+impl fmt::Write for HStderr {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write_all(s.as_bytes()).map_err(|_| fmt::Error)
+    }
+}
+
+/// Host's standard output
+pub struct HStdout {
+    fd: usize,
+}
+
+impl HStdout {
+    /// Attempts to write an entire `buffer` into this sink
+    pub fn write_all(&mut self, buffer: &[u8]) -> Result<(), ()> {
+        write_all(self.fd, buffer)
+    }
+}
+
+impl fmt::Write for HStdout {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write_all(s.as_bytes()).map_err(|_| fmt::Error)
+    }
+}
+
+/// Construct a new handle to the host's standard error.
+pub fn hstderr() -> Result<HStderr, ()> {
+    open(":tt\0", nr::open::W_APPEND).map(|fd| HStderr { fd })
+}
+
+/// Construct a new handle to the host's standard output.
+pub fn hstdout() -> Result<HStdout, ()> {
+    open(":tt\0", nr::open::W_TRUNC).map(|fd| HStdout { fd })
+}
+
+fn open(name: &str, mode: usize) -> Result<usize, ()> {
+    let name = name.as_bytes();
+    match unsafe { syscall!(OPEN, name.as_ptr(), mode, name.len() - 1) } as
+        isize {
+        -1 => Err(()),
+        fd => Ok(fd as usize),
+    }
+}
+
+fn write_all(fd: usize, mut buffer: &[u8]) -> Result<(), ()> {
+    while !buffer.is_empty() {
+        match unsafe { syscall!(WRITE, fd, buffer.as_ptr(), buffer.len()) } {
+            // Done
+            0 => return Ok(()),
+            // `n` bytes were not written
+            n if n <= buffer.len() => {
+                let offset = (buffer.len() - n) as isize;
+                buffer = unsafe {
+                    slice::from_raw_parts(buffer.as_ptr().offset(offset), n)
+                }
+            }
+            // Error
+            _ => return Err(()),
+        }
+    }
+    Ok(())
+}

src/io.rs

@@ -1,106 +0,0 @@
-//! Host I/O
-
-use core::{fmt, slice};
-use core::fmt::Write;
-use nr;
-
-/// Host's standard error
-pub struct Stderr {
-    fd: usize,
-}
-
-/// Construct a new handle to the host's standard error.
-pub fn stderr() -> Stderr {
-    Stderr { fd: open(":tt\0", nr::open::W_APPEND).unwrap() }
-}
-
-/// Host's standard output
-pub struct Stdout {
-    fd: usize,
-}
-
-/// Construct a new handle to the host's standard output.
-pub fn stdout() -> Stdout {
-    Stdout { fd: open(":tt\0", nr::open::W_TRUNC).unwrap() }
-}
-
-fn open(name: &str, mode: usize) -> Result<usize, ()> {
-    let name = name.as_bytes();
-    match unsafe { syscall!(OPEN, name.as_ptr(), mode, name.len() - 1) } as isize {
-        -1 => Err(()),
-        fd => Ok(fd as usize),
-    }
-}
-
-fn write_all(fd: usize, mut buffer: &[u8]) -> fmt::Result {
-    while !buffer.is_empty() {
-        match unsafe { syscall!(WRITE, fd, buffer.as_ptr(), buffer.len()) } {
-            // Done
-            0 => return Ok(()),
-            // `n` bytes were not written
-            n if n <= buffer.len() => {
-                let offset = (buffer.len() - n) as isize;
-                buffer = unsafe {
-                    slice::from_raw_parts(buffer.as_ptr().offset(offset), n)
-                }
-            }
-            // Error
-            _ => return Err(fmt::Error::default()),
-        }
-    }
-    Ok(())
-}
-
-impl Stderr {
-    fn write_all(&mut self, buffer: &[u8]) -> fmt::Result {
-        write_all(self.fd, buffer)
-    }
-}
-
-impl Stdout {
-    fn write_all(&mut self, buffer: &[u8]) -> fmt::Result {
-        write_all(self.fd, buffer)
-    }
-}
-
-impl Write for Stderr {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.write_all(s.as_bytes())
-    }
-}
-
-impl Write for Stdout {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.write_all(s.as_bytes())
-    }
-}
-
-/// Write a `buffer` to the host's stderr
-pub fn ewrite(buffer: &[u8]) {
-    stderr().write_all(buffer).ok();
-}
-
-/// Write `fmt::Arguments` to the host's stderr
-pub fn ewrite_fmt(args: fmt::Arguments) {
-    stderr().write_fmt(args).ok();
-}
-
-/// Write a `string` to the host's stderr
-pub fn ewrite_str(string: &str) {
-    stderr().write_all(string.as_bytes()).ok();
-}
-
-/// Write a `buffer` to the host's stdout
-pub fn write(buffer: &[u8]) {
-    stdout().write_all(buffer).ok();
-}
-
-/// Write `fmt::Arguments` to the host's stdout
-pub fn write_fmt(args: fmt::Arguments) {
-    stdout().write_fmt(args).ok();
-}
-
-/// Write a `string` to the host's stdout
-pub fn write_str(string: &str) {
-    stdout().write_all(string.as_bytes()).ok();
-}

src/lib.rs

@@ -34,7 +34,7 @@
 //!
 //! fn main() {
 //!     // File descriptor (on the host)
-//!     const STDOUT: usize = 1;
+//!     const STDOUT: usize = 1; // NOTE the host stdout may not always be fd 1
 //!     static MSG: &'static [u8] = b"Hello, world!\n";
 //!
 //!     // Signature: fn write(fd: usize, ptr: *const u8, len: usize) -> usize
@@ -107,15 +107,17 @@
 //!
 //! [pdf]: http://infocenter.arm.com/help/topic/com.arm.doc.dui0471e/DUI0471E_developing_for_arm_processors.pdf
 
+#![deny(missing_docs)]
+#![deny(warnings)]
 #![feature(asm)]
 #![no_std]
 
 #[macro_use]
 mod macros;
 
-pub mod io;
-pub mod nr;
 pub mod debug;
+pub mod hio;
+pub mod nr;
 
 /// Performs a semihosting operation, takes a pointer to an argument block
 #[inline(always)]

src/macros.rs

@@ -27,33 +27,3 @@ macro_rules! syscall1 {
         $crate::syscall1($crate::nr::$nr, $a1 as usize)
     };
 }
-
-/// Macro for printing to the **host's** standard stderr
-#[macro_export]
-macro_rules! ehprint {
-    ($s:expr) => ($crate::io::ewrite_str($s));
-    ($($arg:tt)*) => ($crate::io::ewrite_fmt(format_args!($($arg)*)));
-}
-
-/// Macro for printing to the **host's** standard error, with a newline.
-#[macro_export]
-macro_rules! ehprintln {
-    () => (ehprint!("\n"));
-    ($fmt:expr) => (ehprint!(concat!($fmt, "\n")));
-    ($fmt:expr, $($arg:tt)*) => (ehprint!(concat!($fmt, "\n"), $($arg)*));
-}
-
-/// Macro for printing to the **host's** standard output
-#[macro_export]
-macro_rules! hprint {
-    ($s:expr) => ($crate::io::write_str($s));
-    ($($arg:tt)*) => ($crate::io::write_fmt(format_args!($($arg)*)));
-}
-
-/// Macro for printing to the **host's** standard output, with a newline.
-#[macro_export]
-macro_rules! hprintln {
-    () => (hprint!("\n"));
-    ($fmt:expr) => (hprint!(concat!($fmt, "\n")));
-    ($fmt:expr, $($arg:tt)*) => (hprint!(concat!($fmt, "\n"), $($arg)*));
-}

src/nr.rs

@@ -1,5 +1,8 @@
 //! Semihosting operations
 
+// TODO document
+#![allow(missing_docs)]
+
 pub const CLOCK: usize = 0x10;
 pub const CLOSE: usize = 0x05;
 pub const ELAPSED: usize = 0x30;