ansi: refactor OSC/DCS parsing, unify core loop

Author: khoek

src/ansi.rs

@@ -6,61 +6,89 @@ 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;
+enum EscStep {
+    Continue,
+    End,
+    ConsumeNext,
+}
 
-    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) -> EscStep;
+    fn on_escape(next: Option<char>) -> EscStep;
+}
+
+#[derive(Clone, Copy, Debug)]
+struct OscSequence;
+
+impl EscSequence for OscSequence {
+    const START_CHAR: char = ']';
+
+    fn on_char(c: char) -> EscStep {
+        if c == '\u{07}' {
+            EscStep::End
+        } else {
+            EscStep::Continue
         }
     }
 
-    end
+    fn on_escape(next: Option<char>) -> EscStep {
+        if matches!(next, Some('\\')) {
+            EscStep::End
+        } else {
+            EscStep::Continue
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct DcsSequence;
+
+impl EscSequence for DcsSequence {
+    const START_CHAR: char = 'P';
+
+    fn on_char(_c: char) -> EscStep {
+        EscStep::Continue
+    }
+
+    fn on_escape(next: Option<char>) -> EscStep {
+        match next {
+            Some('\\') | None => EscStep::End,
+            Some('\u{1b}') => EscStep::ConsumeNext,
+            _ => EscStep::Continue,
+        }
+    }
 }
 
-fn consume_dcs_end_exclusive(it: &mut Peekable<CharIndices<'_>>, start: usize) -> usize {
+fn consume_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();
-                    }
-                    '\\' => {
+            '\u{1b}' => match S::on_escape(it.peek().map(|(_, next)| *next)) {
+                EscStep::End => return end,
+                EscStep::ConsumeNext => {
+                    if let Some((next_idx, _)) = it.peek() {
                         end = *next_idx + 1;
                         it.next();
-                        return end;
                     }
-                    _ => {}
                 }
-            }
+                EscStep::Continue => {}
+            },
             _ => {}
         }
+        if matches!(S::on_char(c), EscStep::End) {
+            return end;
+        }
     }
 
     end
@@ -231,8 +259,18 @@ 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((_, ']')) => {
+                        return Some((
+                            start,
+                            consume_exclusive::<OscSequence>(it, start),
+                        ))
+                    }
+                    Some((_, 'P')) => {
+                        return Some((
+                            start,
+                            consume_exclusive::<DcsSequence>(it, start),
+                        ))
+                    }
                     _ => {
                         if let Some(end) = find_dfa_end_exclusive_after_entry(it) {
                             return Some((start, end));