wip: everything compiles now, so it must work

sethp · sethp · commit 9b9ac967523b · 2023-04-12T15:19:34.000-07:00
diff --git a/src/ansi.rs b/src/ansi.rs
@@ -55,7 +55,7 @@ use alloc::{
     vec,
     vec::Vec,
 };
-use core::{fmt::Debug, str::FromStr};
+use core::{fmt::Debug, marker::PhantomData, num::ParseIntError, str::FromStr};
 use nom::{IResult, Parser};
 
 const ESC: char = '\u{1B}';
@@ -119,25 +119,15 @@ type TextOpResult<'a> = IResult<&'a str, TextOp>;
 
 trait StrParseFnMut<'a, O> = FnMut(&'a str) -> IResult<&'a str, O>;
 
-fn start_with_char<'a, O, P: StrParser<'a, O>>(
-    start: char,
-    mut parser: P,
-) -> impl StrParseFnMut<'a, O> {
-    move |input: &'a str| {
-        nom::sequence::preceded(nom::character::streaming::char(start), |x: &'a str| {
-            parser.parse(x)
-        })
-        .parse(input)
-    }
+fn start_with_char<'a, O, P: StrParser<'a, O>>(start: char, parser: P) -> impl StrParser<'a, O> {
+    nom::sequence::preceded(nom::character::streaming::char(start), parser)
 }
 
 /// Recognize ESC, and then parses via the P parser. If P fails, this parser will return
 /// the Failure variant (by using nom `cut`). If the this parser does not recognize ESC
 /// it will return with the nom Error variant.
-fn start_with_esc<'a, O, P: StrParser<'a, O>>(mut parser: P) -> impl StrParseFnMut<'a, O> {
-    move |input: &'a str| {
-        start_with_char(ESC, nom::combinator::cut(|x: &'a str| parser.parse(x)))(input)
-    }
+fn start_with_esc<'a, O, P: StrParser<'a, O>>(parser: P) -> impl StrParser<'a, O> {
+    start_with_char(ESC, nom::combinator::cut(parser))
 }
 
 // This will parse "...P... <ending>" for some char ending and parsed sequence P
@@ -495,10 +485,10 @@ fn parse4<'a>(input: &'a str) -> OpResult {
         nom::combinator::map(Chars { req, rest }, f)
     }
 
-    parse! {
-        [ESC, ']', 'H'] => Op::MoveCursorAbs
-        [ESC, ']', (a,b) @ params::<(usize,usize)>, 'H'] => |a, b| Op::MoveCursorAbs
-    }
+    // parse! {
+    //     [ESC, ']', 'H'] => Op::MoveCursorAbs
+    //     [ESC, ']', (a,b) @ params::<(usize,usize)>, 'H'] => |a, b| Op::MoveCursorAbs
+    // }
 
     fn seqz<'a, O>(
         (s, p): (&'a [char], impl StrParser<'a, O>),
@@ -526,27 +516,34 @@ fn parse4<'a>(input: &'a str) -> OpResult {
         }
     }
 
-    trait Params<'a> {
+    trait Params<'a>: Sized {
         type O;
-        fn parse(input: &'a str) -> IResult<&'a str, Self::O>;
-        fn map(o: Self::O) -> Self;
+        type Err;
+        fn recognize(input: &'a str) -> IResult<&'a str, Self::O>;
+        fn map(o: Self::O) -> Result<Self, Self::Err>;
     }
     impl<'a> Params<'a> for (usize, usize) {
         type O = (&'a str, &'a str);
-        fn parse(input: &'a str) -> IResult<&'a str, (&'a str, &'a str)> {
-            todo!()
+        type Err = ParseIntError;
+
+        fn recognize(input: &'a str) -> IResult<&'a str, (&'a str, &'a str)> {
+            nom::sequence::separated_pair(
+                nom::character::streaming::digit1,
+                nom::character::streaming::char(';'),
+                nom::character::streaming::digit1,
+            )(input)
         }
 
-        fn map(o: (&'a str, &'a str)) -> Self {
-            todo!()
+        fn map((a, b): (&'a str, &'a str)) -> Result<Self, ParseIntError> {
+            Ok((usize::from_str(a)?, usize::from_str(b)?))
         }
     }
     // impl<'a> Params<'a> for isize {
 
     // }
 
     fn param<'a, P: Params<'a>, Any>(tail: impl StrParser<'a, Any>) -> impl StrParser<'a, P> {
-        nom::sequence::terminated(nom::combinator::map(P::parse, P::map), tail)
+        nom::sequence::terminated(nom::combinator::map_res(P::recognize, P::map), tail)
     }
 
     fn opt_param<'a, P: Params<'a>, Any>(
@@ -590,20 +587,19 @@ fn parse4<'a>(input: &'a str) -> OpResult {
     Err(nom::Err::Incomplete(nom::Needed::Unknown))
 }
 
+// fn parse7(input: &str) -> OpResult {
+//     static SEQUENCES = [
+//         "ESC [ <n> ; <n> ? H",
+//     ];
 
-fn parse7(input: &str) -> OpResult {
-    static SEQUENCES = [
-        "ESC [ <n> ; <n> ? H",
-    ];
-
-    fn make_parser(seq: &[&str]) -> impl FnMut() -> GenericSequence {
+//     fn make_parser(seq: &[&str]) -> impl FnMut() -> GenericSequence {
 
-    }
+//     }
 
-    // SEQUENCES
-}
+//     // SEQUENCES
+// }
 
-fn parse6(input: &str) -> OpResult {
+pub fn parse6(input: &str) -> Result<Op, String> {
     // ESC [ <n>;<n>? H
 
     // "ESC 7" -> Op::SaveCursorPos,
@@ -612,44 +608,160 @@ fn parse6(input: &str) -> OpResult {
 
     // generic parser:
     // s => ESC [ `[4, 6]` H
+    // enum GenSeq<'a> {
+    //     Lit(char)
+    //     Param()
+    // }
+    // let foo = [""; 6];
+
+    // let gen_parse = |input| start_with_esc(nom::multi::fold_many_m_n(0, 6, parse, init, fold));
+
+    fn gen_parse<'a, 'str, const M: usize>(
+        input: &'str str,
+        q: &'a mut [&'str str; M],
+    ) -> IResult<&'str str, &'a [&'str str]> {
+        let (input, start) = nom::combinator::cut(nom::combinator::recognize(
+            nom::character::streaming::one_of("\u{1b}\u{9b}"),
+        ))
+        .parse(input)?;
+
+        q[0] = start;
+        // c0
+        match nom::combinator::cond(
+            start == "\x1b",
+            nom::sequence::tuple((
+                nom::combinator::opt(nom::sequence::tuple((
+                    nom::combinator::recognize(nom::character::streaming::char('\x21')),
+                    nom::combinator::recognize(nom::character::streaming::char('\x40')),
+                ))),
+                nom::combinator::recognize(nom::character::streaming::satisfy(|ch| {
+                    '\x00' < ch && ch < '\x1f'
+                    // TODO: what set do these belong to ? any?
+                    || ch == '7' || ch == '8'
+                })),
+            )),
+        )
+        .parse(input)
+        {
+            // collapse the two intro sequences to one
+            Ok((rest, Some((Some(_), n)))) | Ok((rest, Some((None, n)))) => {
+                q[1] = n;
+                return Ok((rest, &q[..=1]));
+            }
+            Err(err @ nom::Err::Failure(_)) | Err(err @ nom::Err::Incomplete(_)) => {
+                return Err(err)
+            }
+            // We didn't match a c0 sequence, nothing to return yet
+            Err(nom::Err::Error(_)) | Ok((_, None)) => {}
+        };
+
+        // TODO: c1 set
+
+        // control sequences
+        let input = if start == "\x1b" {
+            let (input, _) = nom::character::streaming::char('[').parse(input)?;
+            // map everything to this particular CSI
+            q[0] = "\u{9b}";
+            input
+        } else {
+            input
+        };
+
+        // CSI P ... P I ... I F
+        //
+        // where
+        //    P ... P are Parameter Bytes, which, if present, consist of bit combinations from 03/00 (\x30) to 03/15 (\x3f)
+        //    I ... I are Intermediate Bytes, which, if present, consist of bit combinations from 02/00 (\x20) to 02/15 (\x2f)
+        //    F is the Final Byte; it consists of a bit combination from 04/00 (\x40) to 07/14 (\x7e)
+        //
+        // NB: the ECMA-43/48 standards use `nibble/nibble`, in decimal, to represent a 7- or 8-bit number.
+        // For example, `01/02` can be either 7- or 8-bit in their notation, and is equivalent to a more
+        // familiar hex notation `0x12`. Similarly, `15/15` (which is necessarily 8-bit) is equivalent to `0xff`.
+        //
+        // cf. https://www.ecma-international.org/wp-content/uploads/ECMA-48_5th_edition_june_1991.pdf#page=24
+        // and https://www.ecma-international.org/wp-content/uploads/ECMA-43_3rd_edition_december_1991.pdf#page=14
+
+        let params = nom::branch::alt((
+            nom::bytes::streaming::is_a("0123456789:;<=>?"),
+            nom::combinator::success(""),
+        ));
+        let intermediate = nom::branch::alt((
+            nom::bytes::streaming::is_a(concat!(" ", "!\"#$%&'()*+,/")),
+            nom::combinator::success(""),
+        ));
+        let fin = nom::combinator::recognize(nom::character::streaming::satisfy(|ch| {
+            '\x40' < ch && ch < '\x7e'
+        }));
+
+        let (rest, ((params, intermediate), fin)) =
+            params.and(intermediate).and(fin).parse(input)?;
 
-    let q = match todo!() {
-        [ESC, '7'] => Op::SaveCursorPos,
-        [ESC, '8'] => Op::RestoreCursorPos,
+        q[1] = params;
+        q[2] = intermediate;
+        q[3] = fin;
 
-        [ESC, '[', params, 'H'] => match params {
-            [] => Op::MoveCursorAbs { x: 0, y: 0 },
-            [a, b] => Op::MoveCursorAbs {
-                x: usize::from(b)?.saturating_sub(1),
-                y: usize::from(a)?.saturating_sub(1),
+        Ok((rest, &q[..=3]))
+    }
+
+    // TODO: other kinds of non-digit-y things?
+    fn sep<'a, 'str, const M: usize>(
+        input: &'str str,
+        q: &'a mut [&'str str; M],
+    ) -> Result<&'a [&'str str], nom::Err<nom::error::Error<&'str str>>> {
+        let (_, i) = nom::combinator::all_consuming(nom::multi::fold_many_m_n(
+            0,
+            M,
+            nom::sequence::terminated(
+                nom::bytes::complete::take_while1(nom::AsChar::is_dec_digit),
+                // TODO: this is wrong: it's not optional, unless it's in the last position
+                nom::combinator::opt(nom::character::complete::char(';')),
+            ),
+            || 0,
+            |i, p| {
+                q[i] = p;
+                i + 1
             },
-            _ => {
-                return Err(alloc::format!(
-                    "Bad number of params got {:?} wanted 0 or 2",
-                    params
-                ))
-            }
-        },
-    };
+        ))
+        .parse(input)?;
+
+        Ok(&q[..i])
+    }
+
+    const ESC: &str = "\u{1b}";
+    const CSI: &str = "\u{9b}";
 
-    let q = match todo!() {
-        [ESC, '7'] => Op::SaveCursorPos,
-        [ESC, '8'] => Op::RestoreCursorPos,
-
-        [ESC, '[', [], 'H'] => Op::MoveCursorAbs { x: 0, y: 0 },
-        [ESC, '[', [a, b], 'H'] => Op::MoveCursorAbs {
-            x: usize::from(b)?.saturating_sub(1),
-            y: usize::from(a)?.saturating_sub(1),
-        },
-        [ESC, '[', params, 'H'] => {
-            return Err(alloc::format!(
-                "Bad number of params got {:?} wanted 0 or 2",
-                params
-            ))
+    let z = match *gen_parse(input, &mut [""; 4])
+        .map_err(|e| alloc::format!("{:?}", e))?
+        .1
+    {
+        [ESC, "7"] => Op::SaveCursorPos,
+        [ESC, "8"] => Op::RestoreCursorPos,
+
+        [CSI, params, "", "H"] | [CSI, params, "", "f"] => {
+            esp_println::println!("{params:?}");
+            match *sep(params, &mut [""; 2]).map_err(|e| alloc::format!("{:?}", e))? {
+                [] => Op::MoveCursorAbs { x: 0, y: 0 },
+                [a, b] => Op::MoveCursorAbs {
+                    x: usize::from_str(b)
+                        .map_err(|e| alloc::format!("{:?}", e))?
+                        .saturating_sub(1),
+                    y: usize::from_str(a)
+                        .map_err(|e| alloc::format!("{:?}", e))?
+                        .saturating_sub(1),
+                },
+                _ => {
+                    return Err(alloc::format!(
+                        "Bad number of params got {:?} wanted 0 or 2",
+                        params
+                    ))
+                }
+            }
         }
+
+        _ => todo!(),
     };
 
-    Ok(q)
+    Ok(z)
 }
 
 fn parse3(input: &str) -> OpResult {
@@ -659,8 +771,10 @@ fn parse3(input: &str) -> OpResult {
     use nom::combinator::map;
 
     alt((
-        esc(map(ch('7'), |_| Op::SaveCursorPos)),
-        esc(map(ch('8'), |_| Op::RestoreCursorPos)),
+        alt((
+            esc(map(ch('7'), |_| Op::SaveCursorPos)),
+            esc(map(ch('8'), |_| Op::RestoreCursorPos)),
+        )),
         esc(nom::sequence::preceded(
             ch('['),
             map(ch('H'), |_| Op::MoveCursorAbs { x: 0, y: 0 }),
@@ -1052,7 +1166,12 @@ fn parse_all<'a>(input: &'a str) -> OpResult {
                         nom::sequence::terminated(
                             nom::multi::separated_list0(
                                 nom::character::streaming::char(';'),
-                                any_text_mode,
+                                nom::branch::alt((
+                                    set_basic_color_atom,
+                                    set_bg_256_color_atom,
+                                    set_fg_256_color_atom,
+                                    set_text_mode_atom,
+                                )),
                             ),
                             nom::character::streaming::char('m'),
                         )
@@ -1127,7 +1246,8 @@ fn parse(input: &str) -> OpResult {
                 reset_private_sequence,
             )),
         ),
-    )))(input)
+    )))
+    .parse(input)
 }
 
 pub enum OpChar {
