minor tweaks, notes, and docs

just a few things that I noticed while rummaging around in the codebase.
they don't really merit individial commits...

src/connection/mod.rs

@@ -1,6 +1,11 @@
 mod impls;
 
 /// A trait to perform bytewise I/O over a serial transport layer.
+///
+/// When the `std` feature is enabled, this trait is automatically implemented
+/// for [`TcpStream`](https://doc.rust-lang.org/std/net/struct.TcpStream.html)
+/// and [`UnixStream`](https://doc.rust-lang.org/std/os/unix/net/struct.UnixStream.html)
+/// (on unix systems).
 pub trait Connection {
     /// Transport-specific error type.
     type Error;

src/protocol/commands/_qSupported.rs

@@ -32,7 +32,7 @@ impl<'a> Features<'a> {
                     b'+' => FeatureSupported::Yes,
                     b'-' => FeatureSupported::No,
                     b'?' => FeatureSupported::Maybe,
-                    _ => unreachable!(),
+                    _ => return Err("invalid feature flag (must be +, -, or ?)"),
                 },
             }),
             Some(_) => {

src/protocol/console_output.rs

@@ -75,7 +75,7 @@ impl Drop for ConsoleOutput<'_> {
 macro_rules! output {
     ($console_output:expr, $($args:tt)*) => {{
         use std::fmt::Write;
-        writeln!($console_output, $($args)*).unwrap();
+        let _ = writeln!($console_output, $($args)*);
     }};
 }
 
@@ -85,14 +85,14 @@ macro_rules! output {
 #[macro_export]
 macro_rules! outputln {
     ($console_output:expr) => {{
-        use std::fmt::Write;
+        use core::fmt::Write;
         let _ = writeln!($console_output);
     }};
     ($console_output:expr,) => {
         outputln!($console_output)
     };
     ($console_output:expr, $($args:tt)*) => {{
-        use std::fmt::Write;
-        writeln!($console_output, $($args)*).unwrap();
+        use core::fmt::Write;
+        let _ = writeln!($console_output, $($args)*);
     }};
 }

src/protocol/response_writer.rs

@@ -2,6 +2,9 @@ use crate::internal::BeBytes;
 use crate::protocol::{IdKind, ThreadId};
 use crate::Connection;
 
+#[cfg(feature = "alloc")]
+use alloc::string::String;
+
 /// Newtype around a Connection error. Having a newtype allows implementing a
 /// `From<ResponseWriterError<C>> for crate::Error<T, C>`, which greatly
 /// simplifies some of the error handling in the main gdbstub.
@@ -14,8 +17,10 @@ pub struct ResponseWriter<'a, C: Connection + 'a> {
     inner: &'a mut C,
     started: bool,
     checksum: u8,
-    // buffer outgoing message, for logging purposes
-    #[cfg(feature = "std")]
+    // buffer outgoing message
+    // TODO: add `write_all` method to Connection, and allow user to optionally pass outgoing
+    // packet buffer? This could improve performance (instead of writing a single byte at a time)
+    #[cfg(feature = "alloc")]
     msg: String,
 }
 
@@ -26,7 +31,7 @@ impl<'a, C: Connection + 'a> ResponseWriter<'a, C> {
             inner,
             started: false,
             checksum: 0,
-            #[cfg(feature = "std")]
+            #[cfg(feature = "alloc")]
             msg: String::new(),
         }
     }
@@ -36,7 +41,7 @@ impl<'a, C: Connection + 'a> ResponseWriter<'a, C> {
         // don't include '#' in checksum calculation
         let checksum = self.checksum;
 
-        #[cfg(feature = "std")]
+        #[cfg(feature = "alloc")]
         trace!("--> ${}#{:02x?}", self.msg, checksum);
 
         self.write(b'#')?;
@@ -52,7 +57,7 @@ impl<'a, C: Connection + 'a> ResponseWriter<'a, C> {
 
     /// Write a single byte.
     pub fn write(&mut self, byte: u8) -> Result<(), Error<C::Error>> {
-        #[cfg(feature = "std")]
+        #[cfg(feature = "alloc")]
         self.msg.push(byte as char);
 
         if !self.started {