format, tidy

Author: tropicaaal

library/std/src/sys/fs/vexos.rs

@@ -194,7 +194,6 @@ impl OpenOptions {
 }
 
 impl File {
-    // TODO
     pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
         // Mount sdcard volume as FAT filesystem
         map_fresult(unsafe { vex_sdk::vexFileMountSD() })?;

library/std/src/sys/pal/vexos/mod.rs

@@ -5,9 +5,9 @@ pub mod pipe;
 pub mod thread;
 pub mod time;
 
-use crate::sys::stdio;
 use crate::arch::global_asm;
 use crate::ptr::{self, addr_of_mut};
+use crate::sys::stdio;
 use crate::time::{Duration, Instant};
 
 global_asm!(
@@ -60,8 +60,7 @@ pub unsafe fn cleanup() {
         vex_sdk::vexTasksRun();
 
         // If the buffer has been fully flushed, exit the loop
-        if vex_sdk::vexSerialWriteFree(stdio::STDIO_CHANNEL) == (stdio::STDOUT_BUF_SIZE as i32)
-        {
+        if vex_sdk::vexSerialWriteFree(stdio::STDIO_CHANNEL) == (stdio::STDOUT_BUF_SIZE as i32) {
             break;
         }
     }

library/std/src/sys/stdio/vexos.rs

@@ -14,7 +14,7 @@ impl Stdin {
 
 impl io::Read for Stdin {
     fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
-        let mut written = 0;
+        let mut count = 0;
 
         while let Some((out_byte, new_buf)) = buf.split_first_mut() {
             buf = new_buf;
@@ -25,10 +25,10 @@ impl io::Read for Stdin {
             }
 
             *out_byte = byte as u8;
-            written += 1;
+            count += 1;
         }
 
-        Ok(written)
+        Ok(count)
     }
 }
 
@@ -40,32 +40,48 @@ impl Stdout {
 
 impl io::Write for Stdout {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let mut count = 0;
+        let mut written = 0;
 
-        // HACK: VEXos holds an internal write buffer for serial that is flushed to USB1 roughly every
-        // millisecond by `vexTasksRun`. For writes larger than 2048 bytes, we must block until that buffer
-        // is flushed to USB1 before writing the rest of `buf`. In practice, this is fairly nonstandard for
-        // a `write` implementation but it avoids an guaranteed recursive panic when using macros such as
-        // `print!` to write large amounts of data to stdout at once.
+        // HACK: VEXos holds an internal ringbuffer for serial writes that is flushed to USB1
+        // roughly every millisecond by `vexTasksRun`. For writes larger than 2048 bytes, we
+        // must block until that buffer is flushed to USB1 before writing the rest of `buf`.
+        //
+        // This is fairly nonstandard for a `write` implementation, but it avoids a guaranteed
+        // recursive panic when using macros such as `print!` to write large amounts of data
+        // (buf.len() > 2048) to stdout at once.
         for chunk in buf.chunks(STDOUT_BUF_SIZE) {
             if unsafe { vex_sdk::vexSerialWriteFree(STDIO_CHANNEL) as usize } < chunk.len() {
                 self.flush().unwrap();
             }
 
-            count += unsafe { vex_sdk::vexSerialWriteBuffer(STDIO_CHANNEL, chunk.as_ptr(), chunk.len() as u32) };
-    
+            let count = unsafe {
+                vex_sdk::vexSerialWriteBuffer(STDIO_CHANNEL, chunk.as_ptr(), chunk.len() as u32)
+            };
             if count < 0 {
                 return Err(io::Error::new(
                     io::ErrorKind::Uncategorized,
                     "Internal write error occurred.",
                 ));
             }
+
+            written += count;
+
+            // This is a sanity check to ensure that we don't end up with non-contiguous
+            // buffer writes. e.g. a chunk gets only partially written, but we continue
+            // attempting to write the remaining chunks.
+            //
+            // In practice, this should never really occur since the previous flush ensures
+            // enough space in FIFO to write the entire chunk to vexSerialWriteBuffer.
+            if count != chunk.len() {
+                break;
+            }
         }
 
-        Ok(count as usize)
+        Ok(written as usize)
     }
 
     fn flush(&mut self) -> io::Result<()> {
+        // This may block for up to a millisecond.
         unsafe {
             while (vex_sdk::vexSerialWriteFree(STDIO_CHANNEL) as usize) != STDOUT_BUF_SIZE {
                 vex_sdk::vexTasksRun();