implement get_cursor_pos

Merge branch 'feat/update-nom' into 'master'
Update nom to v8 See merge request davidbittner/ansi-parser!18
2025-07-08 12:15:21 -04:00 · 2025-05-06 22:59:25 +00:00 · 2025-04-22 22:06:44 +02:00 · 2024-05-17 17:33:40 +00:00 · 2024-05-16 11:02:54 +02:00 · 2024-05-15 19:10:49 +02:00
4 changed files with 236 additions and 282 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,21 +1,21 @@
 [package]
-name = "ansi-parser"
+authors = ["David Bittner <bittneradave@gmail.com>"]
 description = "A library using nom for parsing ANSI Escape Codes"
 homepage = "https://gitlab.com/DavidBittner/ansi-parser"
-authors = ["David Bittner <bittneradave@gmail.com>"]
+name = "ansi-parser"

-version = "0.8.0"
 license = "MPL-2.0"
+version = "0.9.1"

 edition = "2018"

 [dependencies]
-heapless = "0.5.6"
+heapless = "0.8.0"

 [dependencies.nom]
-version = "4.2.3"
 default-features = false
+version = "8.0.0"

 [features]
-std = ["nom/std"]
 default = ["std"]
+std = ["nom/std"]
--- a/src/enums.rs
+++ b/src/enums.rs
@@ -1,12 +1,13 @@
 #[cfg(test)]
 mod tests;

-use heapless::{consts::U5, Vec};
+use heapless::Vec;

 ///The following are the implemented ANSI escape sequences. More to be added.
 #[derive(Debug, PartialEq, Clone)]
 pub enum AnsiSequence {
    Escape,
+    GetCursorPos,
    CursorPos(u32, u32),
    CursorUp(u32),
    CursorDown(u32),
@@ -16,7 +17,7 @@ pub enum AnsiSequence {
    CursorRestore,
    EraseDisplay,
    EraseLine,
-    SetGraphicsMode(Vec<u8, U5>),
+    SetGraphicsMode(Vec<u8, 5>),
    SetMode(u8),
    ResetMode(u8),
    HideCursor,
@@ -65,6 +66,7 @@ impl Display for AnsiSequence {
        use AnsiSequence::*;
        match self {
            Escape => write!(formatter, "\u{1b}"),
+            GetCursorPos => write!(formatter, "[6n"),
            CursorPos(line, col) => write!(formatter, "[{};{}H", line, col),
            CursorUp(amt) => write!(formatter, "[{}A", amt),
            CursorDown(amt) => write!(formatter, "[{}B", amt),
--- a/src/parsers.rs
+++ b/src/parsers.rs
@@ -3,238 +3,186 @@ mod tests;

 use crate::AnsiSequence;

-use core::convert::TryInto;
 use heapless::Vec;
-use nom::*;
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::character::complete::{digit0, digit1};
+use nom::combinator::{map, map_res, opt, value};
+use nom::sequence::{delimited, preceded};
+use nom::IResult;
+use nom::Parser;

 macro_rules! tag_parser {
    ($sig:ident, $tag:expr, $ret:expr) => {
-        named!(
-            $sig<&str, AnsiSequence>,
-            do_parse!(
-                tag!($tag) >>
-                ($ret)
-            )
-        );
-    }
+        fn $sig(input: &str) -> IResult<&str, AnsiSequence> {
+            value($ret, tag($tag)).parse(input)
+        }
+    };
 }

-named!(
-    parse_int<&str, u32>,
-    map_res!(
-        nom::digit,
-        |s: &str| s.parse::<u32>()
-    )
-);
+fn parse_u32(input: &str) -> IResult<&str, u32> {
+    map_res(digit1, |s: &str| s.parse::<u32>()).parse(input)
+}
+
+fn parse_u8(input: &str) -> IResult<&str, u8> {
+    map_res(digit1, |s: &str| s.parse::<u8>()).parse(input)
+}

 // TODO kind of ugly, would prefer to pass in the default so we could use it for
 // all escapes with defaults (not just those that default to 1).
-named!(
-    parse_def_cursor_int<&str, u32>,
-    map!(
-        nom::digit0,
-        |s: &str| s.parse::<u32>().unwrap_or(1)
-    )
-);
+fn parse_def_cursor_int(input: &str) -> IResult<&str, u32> {
+    map(digit0, |s: &str| s.parse::<u32>().unwrap_or(1)).parse(input)
+}

-named!(
-    cursor_pos<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")               >>
-        x: parse_def_cursor_int >>
-        opt!(tag!(";"))         >>
-        y: parse_def_cursor_int >>
-        alt!(
-            tag!("H") |
-            tag!("f")
-        )               >>
-        (AnsiSequence::CursorPos(x, y))
+fn cursor_pos(input: &str) -> IResult<&str, AnsiSequence> {
+    map(
+        (
+            tag("["),
+            parse_def_cursor_int,
+            opt(tag(";")),
+            parse_def_cursor_int,
+            alt((tag("H"), tag("f"))),
+        ),
+        |(_, x, _, y, _)| AnsiSequence::CursorPos(x, y),
    )
-);
+    .parse(input)
+}

-named!(
-    escape<&str, AnsiSequence>,
-    do_parse!(
-        tag!("\u{1b}") >>
-        (AnsiSequence::Escape)
+fn escape(input: &str) -> IResult<&str, AnsiSequence> {
+    value(AnsiSequence::Escape, tag("\u{1b}")).parse(input)
+}
+
+fn cursor_up(input: &str) -> IResult<&str, AnsiSequence> {
+    map(delimited(tag("["), parse_def_cursor_int, tag("A")), |am| {
+        AnsiSequence::CursorUp(am)
+    })
+    .parse(input)
+}
+
+fn cursor_down(input: &str) -> IResult<&str, AnsiSequence> {
+    map(delimited(tag("["), parse_def_cursor_int, tag("B")), |am| {
+        AnsiSequence::CursorDown(am)
+    })
+    .parse(input)
+}
+
+fn cursor_forward(input: &str) -> IResult<&str, AnsiSequence> {
+    map(delimited(tag("["), parse_def_cursor_int, tag("C")), |am| {
+        AnsiSequence::CursorForward(am)
+    })
+    .parse(input)
+}
+
+fn cursor_backward(input: &str) -> IResult<&str, AnsiSequence> {
+    map(delimited(tag("["), parse_def_cursor_int, tag("D")), |am| {
+        AnsiSequence::CursorBackward(am)
+    })
+    .parse(input)
+}
+
+fn graphics_mode1(input: &str) -> IResult<&str, AnsiSequence> {
+    map(delimited(tag("["), parse_u8, tag("m")), |val| {
+        let mode =
+            Vec::from_slice(&[val]).expect("Vec::from_slice should allocate sufficient size");
+        AnsiSequence::SetGraphicsMode(mode)
+    })
+    .parse(input)
+}
+
+fn graphics_mode2(input: &str) -> IResult<&str, AnsiSequence> {
+    map(
+        (tag("["), parse_u8, tag(";"), parse_u8, tag("m")),
+        |(_, val1, _, val2, _)| {
+            let mode = Vec::from_slice(&[val1, val2])
+                .expect("Vec::from_slice should allocate sufficient size");
+            AnsiSequence::SetGraphicsMode(mode)
+        },
    )
-);
+    .parse(input)
+}

-named!(
-    cursor_up<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")                >>
-        am: parse_def_cursor_int >>
-        tag!("A")                >>
-        (AnsiSequence::CursorUp(am))
+fn graphics_mode3(input: &str) -> IResult<&str, AnsiSequence> {
+    map(
+        (
+            tag("["),
+            parse_u8,
+            tag(";"),
+            parse_u8,
+            tag(";"),
+            parse_u8,
+            tag("m"),
+        ),
+        |(_, val1, _, val2, _, val3, _)| {
+            let mode = Vec::from_slice(&[val1, val2, val3])
+                .expect("Vec::from_slice should allocate sufficient size");
+            AnsiSequence::SetGraphicsMode(mode)
+        },
    )
-);
+    .parse(input)
+}

-named!(
-    cursor_down<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")                >>
-        am: parse_def_cursor_int >>
-        tag!("B")                >>
-        (AnsiSequence::CursorDown(am))
+fn graphics_mode4(input: &str) -> IResult<&str, AnsiSequence> {
+    value(AnsiSequence::SetGraphicsMode(Vec::new()), tag("[m")).parse(input)
+}
+
+fn graphics_mode5(input: &str) -> IResult<&str, AnsiSequence> {
+    map(
+        (
+            tag("["),
+            parse_u8,
+            tag(";"),
+            parse_u8,
+            tag(";"),
+            parse_u8,
+            tag(";"),
+            parse_u8,
+            tag(";"),
+            parse_u8,
+            tag("m"),
+        ),
+        |(_, val1, _, val2, _, val3, _, val4, _, val5, _)| {
+            let mode = Vec::from_slice(&[val1, val2, val3, val4, val5])
+                .expect("Vec::from_slice should allocate sufficient size");
+            AnsiSequence::SetGraphicsMode(mode)
+        },
    )
-);
+    .parse(input)
+}

-named!(
-    cursor_forward<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")                >>
-        am: parse_def_cursor_int >>
-        tag!("C")                >>
-        (AnsiSequence::CursorForward(am))
+fn graphics_mode(input: &str) -> IResult<&str, AnsiSequence> {
+    alt((
+        graphics_mode1,
+        graphics_mode2,
+        graphics_mode3,
+        graphics_mode4,
+        graphics_mode5,
+    ))
+    .parse(input)
+}
+
+fn set_mode(input: &str) -> IResult<&str, AnsiSequence> {
+    map(delimited(tag("[="), parse_u8, tag("h")), |val| {
+        AnsiSequence::SetMode(val)
+    })
+    .parse(input)
+}
+
+fn reset_mode(input: &str) -> IResult<&str, AnsiSequence> {
+    map(delimited(tag("[="), parse_u8, tag("l")), |val| {
+        AnsiSequence::ResetMode(val)
+    })
+    .parse(input)
+}
+
+fn set_top_and_bottom(input: &str) -> IResult<&str, AnsiSequence> {
+    map(
+        (tag("["), parse_u32, tag(";"), parse_u32, tag("r")),
+        |(_, x, _, y, _)| AnsiSequence::SetTopAndBottom(x, y),
    )
-);
-
-named!(
-    cursor_backward<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")                >>
-        am: parse_def_cursor_int >>
-        tag!("D")                >>
-        (AnsiSequence::CursorBackward(am))
-    )
-);
-
-named!(
-    graphics_mode1<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")       >>
-        val: parse_int >>
-        tag!("m")      >>
-        val: expr_res!(val.try_into()) >>
-        conv: expr_res!(Vec::from_slice(&[val])) >>
-        (AnsiSequence::SetGraphicsMode(conv))
-    )
-);
-
-named!(
-    graphics_mode2<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")       >>
-        val1: parse_int >>
-        tag!(";")       >>
-        val2: parse_int >>
-        tag!("m")       >>
-        val1: expr_res!(val1.try_into()) >>
-        val2: expr_res!(val2.try_into()) >>
-        conv: expr_res!(Vec::from_slice(&[
-            val1,
-            val2,
-        ])) >>
-        (AnsiSequence::SetGraphicsMode(conv))
-    )
-);
-
-named!(
-    graphics_mode3<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")       >>
-        val1: parse_int >>
-        tag!(";")       >>
-        val2: parse_int >>
-        tag!(";")       >>
-        val3: parse_int >>
-        tag!("m")       >>
-        val1: expr_res!(val1.try_into()) >>
-        val2: expr_res!(val2.try_into()) >>
-        val3: expr_res!(val3.try_into()) >>
-        conv: expr_res!(Vec::from_slice(&[
-            val1,
-            val2,
-            val3,
-        ])) >>
-        (AnsiSequence::SetGraphicsMode(conv))
-    )
-);
-
-named!(
-    graphics_mode4<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[m") >>
-        (AnsiSequence::SetGraphicsMode(Vec::new()))
-    )
-);
-
-named!(
-    graphics_mode5<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")       >>
-        val1: parse_int >>
-        tag!(";")       >>
-        val2: parse_int >>
-        tag!(";")       >>
-        val3: parse_int >>
-        tag!(";")       >>
-        val4: parse_int >>
-        tag!(";")       >>
-        val5: parse_int >>
-        tag!("m")       >>
-        val1: expr_res!(val1.try_into()) >>
-        val2: expr_res!(val2.try_into()) >>
-        val3: expr_res!(val3.try_into()) >>
-        val4: expr_res!(val4.try_into()) >>
-        val5: expr_res!(val5.try_into()) >>
-        conv: expr_res!(Vec::from_slice(&[
-            val1,
-            val2,
-            val3,
-            val4,
-            val5,
-        ])) >>
-        (AnsiSequence::SetGraphicsMode(conv))
-    )
-);
-
-named!(
-    graphics_mode<&str, AnsiSequence>,
-    alt!(
-          graphics_mode1
-        | graphics_mode2
-        | graphics_mode3
-        | graphics_mode4
-        | graphics_mode5
-    )
-);
-
-named!(
-    set_mode<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[=")                       >>
-        mode: parse_int                  >>
-        conv: expr_res!(mode.try_into()) >>
-        tag!("h")                        >>
-        (AnsiSequence::SetMode(conv))
-    )
-);
-
-named!(
-    reset_mode<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[=")                       >>
-        mode: parse_int                  >>
-        conv: expr_res!(mode.try_into()) >>
-        tag!("l")                        >>
-        (AnsiSequence::ResetMode(conv))
-    )
-);
-
-named!(
-    set_top_and_bottom<&str, AnsiSequence>,
-    do_parse!(
-        tag!("[")    >>
-        x: parse_int >>
-        tag!(";")    >>
-        y: parse_int >>
-        tag!("r")    >>
-        (AnsiSequence::SetTopAndBottom(x, y))
-    )
-);
+    .parse(input)
+}

+tag_parser!(get_cursor_pos, "[6n", AnsiSequence::GetCursorPos);
 tag_parser!(cursor_save, "[s", AnsiSequence::CursorSave);
 tag_parser!(cursor_restore, "[u", AnsiSequence::CursorRestore);
 tag_parser!(erase_display, "[2J", AnsiSequence::EraseDisplay);
@@ -276,66 +224,69 @@ tag_parser!(set_g1_graph, ")2", AnsiSequence::SetG1AltAndSpecialGraph);
 tag_parser!(set_single_shift2, "N", AnsiSequence::SetSingleShift2);
 tag_parser!(set_single_shift3, "O", AnsiSequence::SetSingleShift3);

-named!(
-    combined<&str, AnsiSequence>,
-    alt!(
-          escape
-        | cursor_pos
-        | cursor_up
-        | cursor_down
-        | cursor_forward
-        | cursor_backward
-        | cursor_save
-        | cursor_restore
-        | erase_display
-        | erase_line
-        | graphics_mode
-        | set_mode
-        | reset_mode
-        | hide_cursor
-        | show_cursor
-        | cursor_to_app
-        | set_new_line_mode
-        | set_col_132
-        | set_smooth_scroll
-        | set_reverse_video
-        | set_origin_rel
-        | set_auto_wrap
-        | set_auto_repeat
-        | set_interlacing
-        | set_linefeed
-        | set_cursorkey
-        | set_vt52
-        | set_col80
-        | set_jump_scroll
-        | set_normal_video
-        | set_origin_abs
-        | reset_auto_wrap
-        | reset_auto_repeat
-        | reset_interlacing
-        | set_top_and_bottom
-        | set_alternate_keypad
-        | set_numeric_keypad
-        | set_uk_g0
-        | set_uk_g1
-        | set_us_g0
-        | set_us_g1
-        | set_g0_special
-        | set_g1_special
-        | set_g0_alternate
-        | set_g1_alternate
-        | set_g0_graph
-        | set_g1_graph
-        | set_single_shift2
-        | set_single_shift3
-    )
-);
+fn combined(input: &str) -> IResult<&str, AnsiSequence> {
+    // `alt` only supports up to 21 parsers, and nom doesn't seem to
+    // have an alternative with higher variability.
+    // So we simply nest them.
+    alt((
+        alt((
+            escape,
+            cursor_pos,
+            cursor_up,
+            cursor_down,
+            cursor_forward,
+            cursor_backward,
+            cursor_save,
+            cursor_restore,
+            erase_display,
+            erase_line,
+            graphics_mode,
+            set_mode,
+            reset_mode,
+            hide_cursor,
+            show_cursor,
+            cursor_to_app,
+            set_new_line_mode,
+            set_col_132,
+            set_smooth_scroll,
+            set_reverse_video,
+            set_origin_rel,
+        )),
+        alt((
+            set_auto_wrap,
+            set_auto_repeat,
+            set_interlacing,
+            set_linefeed,
+            set_cursorkey,
+            set_vt52,
+            set_col80,
+            set_jump_scroll,
+            set_normal_video,
+            set_origin_abs,
+            reset_auto_wrap,
+            reset_auto_repeat,
+            reset_interlacing,
+            set_top_and_bottom,
+            set_alternate_keypad,
+            set_numeric_keypad,
+            set_uk_g0,
+            set_uk_g1,
+            set_us_g0,
+            set_us_g1,
+            set_g0_special,
+        )),
+        set_g1_special,
+        set_g0_alternate,
+        set_g1_alternate,
+        set_g0_graph,
+        set_g1_graph,
+        set_single_shift2,
+        set_single_shift3,
+        get_cursor_pos,
+    ))
+    .parse(input)
+}

-named!(
-    pub parse_escape<&str, AnsiSequence>,
-    do_parse!(
-        tag!("\u{1b}")    >>
-        seq: combined     >>
-        (seq)
-    )
-);
+pub fn parse_escape(input: &str) -> IResult<&str, AnsiSequence> {
+    preceded(tag("\u{1b}"), combined).parse(input)
+}
--- a/src/parsers/tests.rs
+++ b/src/parsers/tests.rs
@@ -44,6 +44,7 @@ macro_rules! test_def_val_parser {
    };
 }

+test_parser!(get_cursor_pos, "\u{1b}[6n");
 test_def_val_parser!(cursor_pos_default, "\u{1b}[H");
 test_def_val_parser!(cursor_pos, "\u{1b}[10;5H");
 test_def_val_parser!(cursor_up_default, "\u{1b}[A");
Author	SHA1	Message	Date
mtgmonkey	e1082e47cb	implement get_cursor_pos	2025-07-08 12:15:21 -04:00
David Bittner	6b973008e0	Merge branch 'feat/update-nom' into 'master' Update nom to v8 See merge request davidbittner/ansi-parser!18	2025-05-06 22:59:25 +00:00
Lucas Schwiderski	7a31a7346b	Update nom to v8	2025-04-22 22:06:44 +02:00
David Bittner	a431fb31f8	Merge branch 'issue/outdated-heapless' into 'master' Update heapless to v0.8.0 See merge request davidbittner/ansi-parser!15	2024-05-17 17:33:40 +00:00
Lucas Schwiderski	bfcd268967	Bump version to v0.9.1	2024-05-16 11:02:54 +02:00
Lucas Schwiderski	af1951d169	Update heapless to v0.8.0	2024-05-15 19:10:49 +02:00
David Bittner	80b28ea6c4	Merge branch 'issue/outdated-nom' into 'master' Update to nom@7 See merge request davidbittner/ansi-parser!13	2024-01-16 18:57:53 +00:00
Lucas Schwiderski	27beb4bc1f	Update to nom@7	2023-11-07 16:46:25 +01:00
David Bittner	28001c3197	Merge branch 'master' into 'master' update heapless create version up. to 0.6.1 See merge request davidbittner/ansi-parser!12	2022-07-15 18:53:49 +00:00
blacknon	e512d4f0f1	update heapless create version up. to 0.6.1	2022-06-12 17:41:10 +09:00