[opentitanlib] small code style improvement

Reduce nesting level by 1.

Signed-off-by: Gary Guo <[email protected]>

Author: nbdd0121

sw/host/opentitantool/src/command/console.rs

@@ -58,13 +58,14 @@ const CTRL_B: u8 = 2;
 const CTRL_C: u8 = 3;
 
 /// Takes input from an input stream and send it to a console device. Breaks are handled.
-async fn process_input<T, R: AsyncRead + Unpin>(device: &T, stdin: &mut R) -> Result<()>
+async fn process_input<T, R>(device: &T, stdin: &mut R) -> Result<()>
 where
     T: Uart + ?Sized,
+    R: AsyncRead + Unpin,
 {
     let mut break_en = false;
+    let mut buf = [0u8; 256];
     loop {
-        let mut buf = [0u8; 256];
         let len = stdin.read(&mut buf).await?;
         if len == 1 {
             if buf[0] == CTRL_C {
@@ -84,9 +85,7 @@ where
                 continue;
             }
         }
-        if len > 0 {
-            device.write(&buf[..len])?;
-        }
+        device.write(&buf[..len])?;
     }
 }
 
@@ -99,6 +98,12 @@ impl CommandDispatch for Console {
         // We need the UART for the console command to operate.
         transport.capabilities()?.request(Capability::UART).ok()?;
 
+        let uart = self.params.create(transport)?;
+        if let Some(send) = self.send.as_ref() {
+            log::info!("Sending: {:?}", send);
+            uart.write(send.as_bytes())?;
+        }
+
         // Set up resources specified by the command line parameters.
         let mut console = UartConsole::new(
             self.timeout,
@@ -114,45 +119,45 @@ impl CommandDispatch for Console {
         console.logfile = self.logfile.as_ref().map(File::create).transpose()?;
         console.timestamp = self.timestamp;
 
-        let status = {
-            // Put the terminal into raw mode.  The tty guard will restore the
-            // console settings when it goes out of scope.
-            let mut stdin = if self.non_interactive {
-                None
-            } else {
-                Some(RawTty::new(tokio::io::stdin())?)
-            };
-            let mut stdout = std::io::stdout();
-
-            let uart = self.params.create(transport)?;
-            if let Some(send) = self.send.as_ref() {
-                log::info!("Sending: {:?}", send);
-                uart.write(send.as_bytes())?;
-            }
-            if !self.non_interactive {
-                eprint!("Starting interactive console\r\n");
-                eprint!("[CTRL+C] to exit.\r\n\r\n");
-            }
+        // Put the terminal into raw mode.  The tty guard will restore the
+        // console settings when it goes out of scope.
+        let mut stdin = if self.non_interactive {
+            None
+        } else {
+            Some(RawTty::new(tokio::io::stdin())?)
+        };
+
+        if !self.non_interactive {
+            eprint!("Starting interactive console\r\n");
+            eprint!("[CTRL+C] to exit.\r\n\r\n");
+        }
+
+        let status = transport.relinquish_exclusive_access(|| {
+            opentitanlib::util::runtime::block_on(async {
+                let tx = async {
+                    if let Some(stdin) = stdin.as_mut() {
+                        process_input(&*uart, stdin).await
+                    } else {
+                        std::future::pending().await
+                    }
+                };
+
+                let rx = async {
+                    console
+                        .interact_async(&*uart, Some(&mut std::io::stdout()))
+                        .await
+                };
 
-            transport.relinquish_exclusive_access(|| {
-                opentitanlib::util::runtime::block_on(async {
-                    let tx = async {
-                        if let Some(stdin) = stdin.as_mut() {
-                            process_input(&*uart, stdin).await
-                        } else {
-                            std::future::pending().await
-                        }
-                    };
-
-                    let rx = console.interact_async(&*uart, Some(&mut stdout));
-
-                    Result::<_>::Ok(tokio::select! {
-                        v = tx => Err(v?),
-                        v = rx => Ok(v?),
-                    })
+                Result::<_>::Ok(tokio::select! {
+                    v = tx => Err(v?),
+                    v = rx => Ok(v?),
                 })
-            })??
-        };
+            })
+        })??;
+
+        // Bring us out from raw mode early.
+        drop(stdin);
+
         if !self.non_interactive {
             eprintln!("\n\nExiting interactive console.");
         }