Fix escape sequences decoding on Windows

Author: pvolok

src/term/input_parser.rs

@@ -21,11 +21,15 @@ impl InputParser {
     }
   }
 
-  pub fn parse_input<F>(&mut self, input: &[u8], is_raw_mode: bool, mut f: F)
-  where
+  pub fn parse_input<F>(
+    &mut self,
+    input: &[u8],
+    is_raw_mode: bool,
+    more: bool,
+    mut f: F,
+  ) where
     F: FnMut(E),
   {
-    let more = false;
     let mut i = 0;
     let mut consumed = 0;
 
@@ -123,7 +127,14 @@ impl InputParser {
                 }
               } else {
                 // Most of CSI
-                let len = parse_csi(&buf[i..], is_raw_mode, &mut f);
+                let len = if let Some(len) =
+                  parse_csi(&buf[i..], is_raw_mode, &mut f)
+                {
+                  len
+                } else {
+                  // Not enough input to complete CSI sequence.
+                  break;
+                };
                 i += len;
                 consumed = i;
               }
@@ -216,7 +227,8 @@ fn parse_char_key(
   Ok((i, Some(key)))
 }
 
-fn parse_csi<F>(buf: &[u8], is_raw_mode: bool, f: F) -> usize
+/// Returns `None` is there is not enough input.
+fn parse_csi<F>(buf: &[u8], is_raw_mode: bool, f: F) -> Option<usize>
 where
   F: FnMut(E),
 {
@@ -236,19 +248,19 @@ where
       buf[i - 1]
     } else {
       log::error!("TODO: CSI is incomplete.");
-      return i;
+      return Some(i);
     }
   } else {
-    log::error!("CSI sequence has wrong final.");
-    return i;
+    // Not enough input to complete CSI sequence.
+    return None;
   };
 
   match parse_csi_impl(buf, params, intermediates, final_, is_raw_mode, f) {
     Ok(()) => (),
     Err(err) => log::error!("CSI error: {}", err),
   }
 
-  i
+  Some(i)
 }
 
 fn parse_csi_impl<F>(

src/term/term_driver.rs

@@ -143,8 +143,9 @@ impl TermDriver {
               match rustix::io::read(stdin, Box::as_mut(&mut read_buf)) {
                 Ok(read_count) => {
                   let slice = &read_buf[..read_count];
-                  input_parser
-                    .parse_input(slice, true, |e| sender.send(e).log_ignore());
+                  input_parser.parse_input(slice, true, false, |e| {
+                    sender.send(e).log_ignore()
+                  });
                 }
                 Err(err) => log::error!("stdin(err): {:?}", err),
               }

src/term/windows.rs

@@ -90,23 +90,20 @@ impl WinVt {
 }
 
 fn decode_key_record<F: FnMut(InternalTermEvent)>(
-  input_parser: &mut InputParser,
   record: &KEY_EVENT_RECORD,
   f: &mut F,
 ) {
   use winapi::um::winuser::*;
 
+  let uchar = unsafe { *record.uChar.UnicodeChar() };
+
   let modifiers = modifiers_from_ctrl_key_state(record.dwControlKeyState);
   let virtual_key_code = record.wVirtualKeyCode as i32;
 
   // We normally ignore all key release events, but we will make an exception for an Alt key
   // release if it carries a u_char value, as this indicates an Alt code.
-  let is_alt_code = virtual_key_code == VK_MENU
-    && record.bKeyDown == 0
-    && *unsafe { record.uChar.UnicodeChar() } != 0;
-  if is_alt_code {
-    let utf16 = *unsafe { record.uChar.UnicodeChar() };
-    match utf16 {
+  if is_alt_code(record) {
+    match uchar {
       surrogate @ 0xD800..=0xDFFF => {
         log::error!("Unhandled surrogate key record.");
         return;
@@ -157,8 +154,7 @@ fn decode_key_record<F: FnMut(InternalTermEvent)>(
     VK_TAB if modifiers.contains(KeyModifiers::SHIFT) => Some(KeyCode::BackTab),
     VK_TAB => Some(KeyCode::Tab),
     _ => {
-      let utf16 = *unsafe { record.uChar.UnicodeChar() };
-      match utf16 {
+      match uchar {
         0x00..=0x1f => {
           // Some key combinations generate either no u_char value or generate control
           // codes. To deliver back a KeyCode::Char(...) event we want to know which
@@ -193,6 +189,12 @@ fn decode_key_record<F: FnMut(InternalTermEvent)>(
   }
 }
 
+fn is_alt_code(record: &KEY_EVENT_RECORD) -> bool {
+  record.wVirtualKeyCode as i32 == winapi::um::winuser::VK_MENU
+    && record.bKeyDown == 0
+    && unsafe { *record.uChar.UnicodeChar() } != 0
+}
+
 enum CharCase {
   LowerCase,
   UpperCase,
@@ -398,7 +400,30 @@ pub fn decode_input_records<F: FnMut(InternalTermEvent)>(
   for record in records {
     match record.EventType {
       KEY_EVENT => {
-        decode_key_record(input_parser, unsafe { record.Event.KeyEvent() }, f)
+        let record = unsafe { record.Event.KeyEvent() };
+        let uchar = unsafe { *record.uChar.UnicodeChar() };
+
+        if record.bKeyDown == 0 && !is_alt_code(record) {
+          // Ignore release events.
+          //
+          // If we want to support release key events on Windows we need to
+          // handle:
+          // - if the key is part of escape sequence: consume both press+release
+          //   events
+          // - otherwise emit both press and release
+        } else if (1..=0x7f).contains(&uchar)
+          && record.dwControlKeyState == 0
+          && record.bKeyDown == 1
+        {
+          let ch = uchar as u8 as char;
+          let mut buf = [0u8; 4];
+          let bytes = ch.encode_utf8(&mut buf).as_bytes();
+          for _ in 0..record.wRepeatCount {
+            input_parser.parse_input(bytes, true, true, &mut *f);
+          }
+        } else {
+          decode_key_record(record, f);
+        }
       }
       MOUSE_EVENT => decode_mouse_record(
         input_parser,
@@ -411,6 +436,9 @@ pub fn decode_input_records<F: FnMut(InternalTermEvent)>(
       _ => {}
     }
   }
+
+  // Process pending ESC character.
+  input_parser.parse_input(b"", true, false, f);
 }
 
 fn modifiers_from_ctrl_key_state(state: u32) -> KeyModifiers {