Make hprint macros unwrap any errors

Author: jonas-schievink

src/export.rs

@@ -8,44 +8,65 @@ use crate::hio::{self, HStderr, HStdout};
 
 static mut HSTDOUT: Option<HStdout> = None;
 
-pub fn hstdout_str(s: &str) -> Result<(), ()> {
-    interrupt::free(|_| unsafe {
+pub fn hstdout_str(s: &str) {
+    let result = interrupt::free(|_| unsafe {
         if HSTDOUT.is_none() {
             HSTDOUT = Some(hio::hstdout()?);
         }
 
         HSTDOUT.as_mut().unwrap().write_str(s).map_err(drop)
-    })
+    });
+
+    if result.is_err() {
+        error("hstdout");
+    }
 }
 
-pub fn hstdout_fmt(args: fmt::Arguments) -> Result<(), ()> {
-    interrupt::free(|_| unsafe {
+pub fn hstdout_fmt(args: fmt::Arguments) {
+    let result = interrupt::free(|_| unsafe {
         if HSTDOUT.is_none() {
             HSTDOUT = Some(hio::hstdout()?);
         }
 
         HSTDOUT.as_mut().unwrap().write_fmt(args).map_err(drop)
-    })
+    });
+
+    if result.is_err() {
+        error("hstdout");
+    }
 }
 
 static mut HSTDERR: Option<HStderr> = None;
 
-pub fn hstderr_str(s: &str) -> Result<(), ()> {
-    interrupt::free(|_| unsafe {
+pub fn hstderr_str(s: &str) {
+    let result = interrupt::free(|_| unsafe {
         if HSTDERR.is_none() {
             HSTDERR = Some(hio::hstderr()?);
         }
 
         HSTDERR.as_mut().unwrap().write_str(s).map_err(drop)
-    })
+    });
+
+    if result.is_err() {
+        error("hstderr");
+    }
 }
 
-pub fn hstderr_fmt(args: fmt::Arguments) -> Result<(), ()> {
-    interrupt::free(|_| unsafe {
+pub fn hstderr_fmt(args: fmt::Arguments) {
+    let result = interrupt::free(|_| unsafe {
         if HSTDERR.is_none() {
             HSTDERR = Some(hio::hstderr()?);
         }
 
         HSTDERR.as_mut().unwrap().write_fmt(args).map_err(drop)
-    })
+    });
+
+    if result.is_err() {
+        error("hstderr");
+    }
+}
+
+#[cold]
+fn error(label: &str) {
+    panic!("failed to print to {}", label);
 }

src/macros.rs

@@ -20,17 +20,18 @@ macro_rules! syscall {
     };
 }
 
-/// Macro version of `syscall1`
+/// Macro version of `syscall1`.
 #[macro_export]
 macro_rules! syscall1 {
     ($nr:ident, $a1:expr) => {
         $crate::syscall1($crate::nr::$nr, $a1 as usize)
     };
 }
 
-/// Macro for printing to the HOST standard output
+/// Macro for printing to the HOST standard output.
 ///
-/// This macro returns a `Result<(), ()>` value
+/// This is similar to the `print!` macro in the standard library. Both will panic on any failure to
+/// print.
 #[macro_export]
 macro_rules! hprint {
     ($s:expr) => {
@@ -43,7 +44,8 @@ macro_rules! hprint {
 
 /// Macro for printing to the HOST standard output, with a newline.
 ///
-/// This macro returns a `Result<(), ()>` value
+/// This is similar to the `println!` macro in the standard library. Both will panic on any failure to
+/// print.
 #[macro_export]
 macro_rules! hprintln {
     () => {
@@ -57,9 +59,10 @@ macro_rules! hprintln {
     };
 }
 
-/// Macro for printing to the HOST standard error
+/// Macro for printing to the HOST standard error.
 ///
-/// This macro returns a `Result<(), ()>` value
+/// This is similar to the `eprint!` macro in the standard library. Both will panic on any failure
+/// to print.
 #[macro_export]
 macro_rules! heprint {
     ($s:expr) => {
@@ -72,7 +75,8 @@ macro_rules! heprint {
 
 /// Macro for printing to the HOST standard error, with a newline.
 ///
-/// This macro returns a `Result<(), ()>` value
+/// This is similar to the `eprintln!` macro in the standard library. Both will panic on any failure
+/// to print.
 #[macro_export]
 macro_rules! heprintln {
     () => {
@@ -86,22 +90,23 @@ macro_rules! heprintln {
     };
 }
 
-/// Macro that prints and returns the value of a given expression
-/// for quick and dirty debugging. Works exactly like `dbg!` in
-/// the standard library, replacing `eprintln` with `heprintln`,
-/// which it unwraps.
+/// Macro that prints and returns the value of a given expression for quick and
+/// dirty debugging.
+///
+/// Works exactly like `dbg!` in the standard library, replacing `eprintln!`
+/// with `heprintln!`.
 #[macro_export]
 macro_rules! dbg {
     () => {
-        $crate::heprintln!("[{}:{}]", file!(), line!()).unwrap();
+        $crate::heprintln!("[{}:{}]", file!(), line!());
     };
     ($val:expr) => {
         // Use of `match` here is intentional because it affects the lifetimes
         // of temporaries - https://stackoverflow.com/a/48732525/1063961
         match $val {
             tmp => {
                 $crate::heprintln!("[{}:{}] {} = {:#?}",
-                    file!(), line!(), stringify!($val), &tmp).unwrap();
+                    file!(), line!(), stringify!($val), &tmp);
                 tmp
             }
         }