ansi: refactor OSC/DCS parsing, unify core loop

Author: khoek

src/ansi.rs

@@ -6,61 +6,114 @@ use core::{
     str::CharIndices,
 };
 
-fn consume_osc_end_exclusive(it: &mut Peekable<CharIndices<'_>>, start: usize) -> usize {
-    let mut end = start + 1;
-    let Some((idx, ']')) = it.next() else {
-        return end;
-    };
-    end = idx + 1;
+struct EscAction {
+    consume_next: bool,
+    end: bool,
+}
 
-    while let Some((idx, c)) = it.next() {
-        end = idx + c.len_utf8();
-        match c {
-            '\u{07}' | '\u{9c}' => return end,
-            '\u{1b}' => {
-                if let Some((next_idx, '\\')) = it.peek() {
-                    end = *next_idx + 1;
-                    it.next();
-                    return end;
-                }
+trait EscSequence {
+    const START_CHAR: char;
+    fn on_char(c: char) -> EscAction;
+    fn on_escape(next: Option<char>) -> EscAction;
+}
+
+#[derive(Clone, Copy, Debug)]
+struct OscSequence;
+
+impl EscSequence for OscSequence {
+    const START_CHAR: char = ']';
+
+    fn on_char(c: char) -> EscAction {
+        EscAction {
+            consume_next: false,
+            end: c == '\u{07}',
+        }
+    }
+
+    fn on_escape(next: Option<char>) -> EscAction {
+        if matches!(next, Some('\\')) {
+            EscAction {
+                consume_next: true,
+                end: true,
+            }
+        } else {
+            EscAction {
+                consume_next: false,
+                end: false,
             }
-            _ => {}
         }
     }
+}
 
-    end
+#[derive(Clone, Copy, Debug)]
+struct DcsSequence;
+
+impl EscSequence for DcsSequence {
+    const START_CHAR: char = 'P';
+
+    fn on_char(_c: char) -> EscAction {
+        EscAction {
+            consume_next: false,
+            end: false,
+        }
+    }
+
+    fn on_escape(next: Option<char>) -> EscAction {
+        match next {
+            Some('\\') => EscAction {
+                consume_next: true,
+                end: true,
+            },
+            None => EscAction {
+                consume_next: false,
+                end: true,
+            },
+            Some('\u{1b}') => EscAction {
+                consume_next: true,
+                end: false,
+            },
+            _ => EscAction {
+                consume_next: false,
+                end: false,
+            },
+        }
+    }
 }
 
-fn consume_dcs_end_exclusive(it: &mut Peekable<CharIndices<'_>>, start: usize) -> usize {
+fn consume_end_exclusive<S: EscSequence>(
+    it: &mut Peekable<CharIndices<'_>>,
+    start: usize,
+) -> usize {
     let mut end = start + 1;
-    let Some((idx, 'P')) = it.next() else {
+    let Some((idx, start_char)) = it.next() else {
         return end;
     };
+    if start_char != S::START_CHAR {
+        return end;
+    }
     end = idx + 1;
 
     while let Some((idx, c)) = it.next() {
         end = idx + c.len_utf8();
         match c {
             '\u{9c}' => return end,
             '\u{1b}' => {
-                let Some((next_idx, next)) = it.peek() else {
-                    return end;
-                };
-                match next {
-                    '\u{1b}' => {
-                        end = *next_idx + 1;
-                        it.next();
-                    }
-                    '\\' => {
+                let action = S::on_escape(it.peek().map(|(_, next)| *next));
+                if action.consume_next {
+                    if let Some((next_idx, _)) = it.peek() {
                         end = *next_idx + 1;
                         it.next();
-                        return end;
                     }
-                    _ => {}
+                }
+                if action.end {
+                    return end;
                 }
             }
             _ => {}
         }
+        if S::on_char(c).end {
+            return end;
+        }
     }
 
     end
@@ -231,8 +284,12 @@ fn find_ansi_code_exclusive(it: &mut Peekable<CharIndices>) -> Option<(usize, us
             '\u{1b}' => {
                 it.next();
                 match it.peek() {
-                    Some((_, ']')) => return Some((start, consume_osc_end_exclusive(it, start))),
-                    Some((_, 'P')) => return Some((start, consume_dcs_end_exclusive(it, start))),
+                    Some((_, OscSequence::START_CHAR)) => {
+                        return Some((start, consume_end_exclusive::<OscSequence>(it, start)))
+                    }
+                    Some((_, DcsSequence::START_CHAR)) => {
+                        return Some((start, consume_end_exclusive::<DcsSequence>(it, start)))
+                    }
                     _ => {
                         if let Some(end) = find_dfa_end_exclusive_after_entry(it) {
                             return Some((start, end));