Try ugly approach

alacritty · Jan 2, 2025 · 32ea120 · 32ea120
1 parent be6c1f5
commit 32ea120
Show file tree

Hide file tree

Showing 3 changed files with 81 additions and 29 deletions.
diff --git a/examples/parselog.rs b/examples/parselog.rs
@@ -34,11 +34,18 @@ impl Perform for Log {
         println!("[osc_dispatch] params={:?} bell_terminated={}", params, bell_terminated);
     }
 
-    fn csi_dispatch(&mut self, params: &Params, intermediates: &[u8], ignore: bool, c: char) {
+    fn csi_dispatch(
+        &mut self,
+        params: &Params,
+        intermediates: &[u8],
+        ignore: bool,
+        c: char,
+    ) -> bool {
         println!(
             "[csi_dispatch] params={:#?}, intermediates={:?}, ignore={:?}, char={:?}",
             params, intermediates, ignore, c
         );
+        false
     }
 
     fn esc_dispatch(&mut self, intermediates: &[u8], ignore: bool, byte: u8) {
@@ -61,7 +68,12 @@ fn main() {
     loop {
         match handle.read(&mut buf) {
             Ok(0) => break,
-            Ok(n) => statemachine.advance(&mut performer, &buf[..n]),
+            Ok(n) => {
+                let mut processed = 0;
+                while processed < n {
+                    processed += statemachine.advance(&mut performer, &buf[processed..n]);
+                }
+            },
             Err(err) => {
                 println!("err: {}", err);
                 break;

diff --git a/src/ansi.rs b/src/ansi.rs
@@ -299,23 +299,27 @@ impl<T: Timeout> Processor<T> {
     where
         H: Handler,
     {
-        if self.state.sync_state.timeout.pending_timeout() {
-            self.advance_sync(handler, bytes);
-        } else {
-            let mut performer = Performer::new(&mut self.state, handler);
-            self.parser.advance(&mut performer, bytes);
+        let mut processed = 0;
+        while processed < bytes.len() {
+            let bytes = &bytes[processed..];
+            if self.state.sync_state.timeout.pending_timeout() {
+                processed += self.advance_sync(handler, bytes);
+            } else {
+                let mut performer = Performer::new(&mut self.state, handler);
+                processed += self.parser.advance(&mut performer, bytes);
+            }
         }
     }
 
     /// End a synchronized update.
-    pub fn stop_sync<H>(&mut self, handler: &mut H)
+    pub fn stop_sync<H>(&mut self, handler: &mut H) -> usize
     where
         H: Handler,
     {
         // Process all synchronized bytes.
         let buffer = mem::take(&mut self.state.sync_state.buffer);
         let mut performer = Performer::new(&mut self.state, handler);
-        self.parser.advance(&mut performer, &buffer);
+        let processed = self.parser.advance(&mut performer, &buffer);
         self.state.sync_state.buffer = buffer;
 
         // Report that update ended, since we could end due to timeout.
@@ -324,6 +328,8 @@ impl<T: Timeout> Processor<T> {
         // escapes.
         self.state.sync_state.buffer.clear();
         self.state.sync_state.timeout.clear_timeout();
+
+        processed
     }
 
     /// Number of bytes in the synchronization buffer.
@@ -334,7 +340,7 @@ impl<T: Timeout> Processor<T> {
 
     /// Process a new byte during a synchronized update.
     #[cold]
-    fn advance_sync<H>(&mut self, handler: &mut H, bytes: &[u8])
+    fn advance_sync<H>(&mut self, handler: &mut H, bytes: &[u8]) -> usize
     where
         H: Handler,
     {
@@ -345,15 +351,15 @@ impl<T: Timeout> Processor<T> {
 
             // Just parse the bytes normally.
             let mut performer = Performer::new(&mut self.state, handler);
-            self.parser.advance(&mut performer, bytes);
+            self.parser.advance(&mut performer, bytes)
         } else {
             self.state.sync_state.buffer.extend(bytes);
-            self.advance_sync_csi(handler, bytes.len());
+            self.advance_sync_csi(handler, bytes.len())
         }
     }
 
     /// Handle BSU/ESU CSI sequences during synchronized update.
-    fn advance_sync_csi<H>(&mut self, handler: &mut H, new_bytes: usize)
+    fn advance_sync_csi<H>(&mut self, handler: &mut H, new_bytes: usize) -> usize
     where
         H: Handler,
     {
@@ -375,10 +381,11 @@ impl<T: Timeout> Processor<T> {
             if escape == BSU_CSI {
                 self.state.sync_state.timeout.set_timeout(SYNC_UPDATE_TIMEOUT);
             } else if escape == ESU_CSI {
-                self.stop_sync(handler);
-                break;
+                return self.stop_sync(handler);
             }
         }
+
+        new_bytes
     }
 }
 
@@ -1490,7 +1497,7 @@ where
         intermediates: &[u8],
         has_ignored_intermediates: bool,
         action: char,
-    ) {
+    ) -> bool {
         macro_rules! unhandled {
             () => {{
                 debug!(
@@ -1502,7 +1509,7 @@ where
 
         if has_ignored_intermediates || intermediates.len() > 2 {
             unhandled!();
-            return;
+            return false;
         }
 
         let mut params_iter = params.iter();
@@ -1541,7 +1548,7 @@ where
                     3 => TabulationClearMode::All,
                     _ => {
                         unhandled!();
-                        return;
+                        return false;
                     },
                 };
 
@@ -1562,6 +1569,8 @@ where
                     // Handle sync updates opaquely.
                     if param == NamedPrivateMode::SyncUpdate as u16 {
                         self.state.sync_state.timeout.set_timeout(SYNC_UPDATE_TIMEOUT);
+                        handler.set_private_mode(PrivateMode::new(param));
+                        return true;
                     }
 
                     handler.set_private_mode(PrivateMode::new(param))
@@ -1576,7 +1585,7 @@ where
                     3 => ClearMode::Saved,
                     _ => {
                         unhandled!();
-                        return;
+                        return false;
                     },
                 };
 
@@ -1589,7 +1598,7 @@ where
                     2 => LineClearMode::All,
                     _ => {
                         unhandled!();
-                        return;
+                        return false;
                     },
                 };
 
@@ -1603,7 +1612,7 @@ where
                     2 => ScpCharPath::RTL,
                     _ => {
                         unhandled!();
-                        return;
+                        return false;
                     },
                 };
 
@@ -1613,7 +1622,7 @@ where
                     2 => ScpUpdateMode::PresentationToData,
                     _ => {
                         unhandled!();
-                        return;
+                        return false;
                     },
                 };
 
@@ -1643,7 +1652,10 @@ where
                     Some(0) => ModifyOtherKeys::Reset,
                     Some(1) => ModifyOtherKeys::EnableExceptWellDefined,
                     Some(2) => ModifyOtherKeys::EnableAll,
-                    _ => return unhandled!(),
+                    _ => {
+                        unhandled!();
+                        return false;
+                    },
                 };
                 handler.set_modify_other_keys(mode);
             },
@@ -1674,7 +1686,7 @@ where
                     5 | 6 => Some(CursorShape::Beam),
                     _ => {
                         unhandled!();
-                        return;
+                        return false;
                     },
                 };
                 let cursor_style =
@@ -1723,6 +1735,8 @@ where
             ('Z', []) => handler.move_backward_tabs(next_param_or(1)),
             _ => unhandled!(),
         }
+
+        false
     }
 
     #[inline]
@@ -2345,6 +2359,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn mixed_sync_escape() {
+        let mut parser = Processor::<TestSyncHandler>::new();
+        let mut handler = MockHandler::default();
+
+        assert_eq!(parser.state.sync_state.timeout.is_sync, 0);
+        assert!(handler.attr.is_none());
+
+        // Start synchronized update with immediate SGR.
+        parser.advance(&mut handler, b"\x1b[?2026h\x1b[31m");
+        assert_eq!(parser.state.sync_state.timeout.is_sync, 1);
+        assert!(handler.attr.is_none());
+
+        // Terminate synchronized update and check for SGR.
+        parser.advance(&mut handler, b"\x1b[?2026l");
+        assert_eq!(parser.state.sync_state.timeout.is_sync, 0);
+        assert!(handler.attr.is_some());
+    }
+
     #[test]
     #[cfg(not(feature = "no_std"))]
     fn contrast() {

diff --git a/src/lib.rs b/src/lib.rs
@@ -70,6 +70,7 @@ pub struct Parser<const OSC_RAW_BUF_SIZE: usize = MAX_OSC_RAW> {
     ignoring: bool,
     partial_utf8: [u8; 4],
     partial_utf8_len: usize,
+    terminated: bool,
 }
 
 impl Parser {
@@ -109,15 +110,17 @@ impl<const OSC_RAW_BUF_SIZE: usize> Parser<OSC_RAW_BUF_SIZE> {
     ///
     /// [`Perform`]: trait.Perform.html
     #[inline]
-    pub fn advance<P: Perform>(&mut self, performer: &mut P, bytes: &[u8]) {
+    pub fn advance<P: Perform>(&mut self, performer: &mut P, bytes: &[u8]) -> usize {
+        self.terminated = false;
+
         let mut i = 0;
 
         // Handle partial codepoints from previous calls to `advance`.
         if self.partial_utf8_len > 0 {
             i += self.advance_partial_utf8(performer, bytes);
         }
 
-        while i < bytes.len() {
+        while i < bytes.len() && !self.terminated {
             match self.state {
                 State::Ground => i += self.advance_ground(performer, &bytes[i..]),
                 _ => {
@@ -131,6 +134,8 @@ impl<const OSC_RAW_BUF_SIZE: usize> Parser<OSC_RAW_BUF_SIZE> {
                 },
             }
         }
+
+        i
     }
 
     #[inline]
@@ -249,7 +254,7 @@ impl<const OSC_RAW_BUF_SIZE: usize> Parser<OSC_RAW_BUF_SIZE> {
                     self.params.push(self.param);
                 }
 
-                performer.csi_dispatch(
+                self.terminated |= performer.csi_dispatch(
                     self.params(),
                     self.intermediates(),
                     self.ignoring,
@@ -521,7 +526,8 @@ pub trait Perform {
         _intermediates: &[u8],
         _ignore: bool,
         _action: char,
-    ) {
+    ) -> bool {
+        false
     }
 
     /// The final character of an escape sequence has arrived.
@@ -571,10 +577,11 @@ mod tests {
             self.dispatched.push(Sequence::Osc(params, bell_terminated));
         }
 
-        fn csi_dispatch(&mut self, params: &Params, intermediates: &[u8], ignore: bool, c: char) {
+        fn csi_dispatch(&mut self, params: &Params, intermediates: &[u8], ignore: bool, c: char) -> bool {
             let params = params.iter().map(|subparam| subparam.to_vec()).collect();
             let intermediates = intermediates.to_vec();
             self.dispatched.push(Sequence::Csi(params, intermediates, ignore, c));
+            false
         }
 
         fn esc_dispatch(&mut self, intermediates: &[u8], ignore: bool, byte: u8) {