a bunch of stuff: fixed a parse bug and added a new esc seq parse, parsing now is buffered on str instead of individual chars; added some small performance profiling, terminal is also str buffered, uart by default has software control flow turned on

Author: Eric Douglass

Cargo.lock

@@ -40,7 +40,7 @@ critical-section = "1.1.1"
 embedded-graphics = "0.7.1"
 embedded-hal = "0.2"
 esp-alloc = { version = "0.2.0", features = ["oom-handler"] }
-esp-println = { version = "0.4.0", features = ["esp32c3"] }
+esp-println = { version = "0.4.0", default-features = false, features = ["esp32c3", "jtag_serial"] }
 esp32c3-hal = { features = [
   "direct-boot",
 ], version = "*" }
@@ -51,15 +51,15 @@ nb = "1.1"
 nom = { version = "7.1.3", default-features = false, features = ["alloc"] }
 riscv = "0.10.1"
 unroll = "0.1.5"
-
-[dev-dependencies]
 esp-backtrace = { version = "0.6.0", features = [
   "esp32c3",
   "panic-handler",
   "exception-handler",
-  "print-uart",
+  "print-jtag-serial",
 ] }
 
+[dev-dependencies]
+
 
 [patch.crates-io]
 # TODO: automate these updates

Cargo.toml

@@ -30,7 +30,7 @@ At this point you are ready to build and upload
 
 2. Flash to the CPU
 
-`espflash /dev/ttyUSB0 target/riscv32imc-unknown-none-elf/debug/vgaterm --monitor --format direct-boot`
+`espflash flash /dev/ttyUSB0 target/riscv32imac-unknown-none-elf/debug/vgaterm --monitor --format direct-boot`
 
 Where `/dev/ttyUSB0` should be whatever serial port the esp32 is connected to. It's highly recommended that your user
 is added to the `dialout` group which will allow you to interact with `/dev/ttyUSB0` without using sudo.

README.md

@@ -13,7 +13,7 @@ use esp32c3_hal::{
 };
 use esp_println::{print, println};
 use riscv::asm::wfi;
-use vgaterm::ansi::{OpChar, TerminalEsc};
+use vgaterm::ansi;
 
 core::arch::global_asm!(".global _heap_size; _heap_size = 0x8000");
 
@@ -80,23 +80,34 @@ fn main() -> ! {
     init_heap();
 
     vgaterm::configure_timer0(peripherals.TIMG0, &clocks);
-    let mut rx = vgaterm::uart::configure0(peripherals.UART0);
+    let mut _rx = vgaterm::uart::configure0(peripherals.UART0);
     vgaterm::uart::interrupt_enable0(vgaterm::interrupt::Priority::Priority5);
 
     unsafe {
         riscv::interrupt::enable();
     }
 
-    let mut escape = TerminalEsc::new();
+
+    let r = ansi::parse_esc_str("abcd\u{1B}[XYZ\u{1B}[");
+    println!("{:?}", r);
+
+    // match escape.push_str("abcd\u{1B}[5") {
+    //     ParseRes::InSequence(s) => {
+    //         println!("string {}", s.escape_default());
+    //     },
+    //     ParseRes::OpStr(v) => {
+    //         println!("vec {:?}", v);
+    //     }
+    // }
 
     loop {
-        while let Some(c) = rx.recv() {
-            match escape.push(c) {
-                None => print!("{}", c.escape_default()),
-                Some(OpChar::Char(h)) => println!("> {h}"),
-                Some(OpChar::Op(p)) => println!("{c}\nOp: {p:?}"),
-            }
-        }
+        // while let Some(c) = rx.recv() {
+        //     match escape.push_str(c) {
+        //         None => print!("{}", c.escape_default()),
+        //         Some(OpChar::Char(h)) => println!("> {h}"),
+        //         Some(OpChar::Op(p)) => println!("{c}\nOp: {p:?}"),
+        //     }
+        // }
 
         unsafe {
             wfi();

examples/escape_seq.rs

@@ -49,7 +49,12 @@
 //! [Op(name), [Param(value)]]
 //!
 
-use alloc::{borrow::ToOwned, string::String, vec::Vec};
+use alloc::{
+    borrow::ToOwned,
+    string::{String, ToString},
+    vec,
+    vec::Vec,
+};
 use core::{fmt::Debug, str::FromStr};
 use nom::{IResult, Parser};
 
@@ -406,21 +411,21 @@ fn set_text_mode_atom(input: &str) -> TextOpResult {
     })(input)
 }
 
-/// ESC [ ? <anything> h
+/// ESC [ ? <numbers> h
 fn set_private_sequence(input: &str) -> OpResult {
     nom::sequence::tuple((
         nom::character::streaming::char('?'),
-        nom::bytes::streaming::take_till(|c| c == 'h'),
+        nom::character::streaming::digit0,
         nom::character::streaming::char('h'),
     ))(input)
     .map(|(rest, (_, b, _))| (rest, Op::DecPrivateSet(b.to_owned())))
 }
 
-/// ESC [ ? <anything> l
+/// ESC [ ? <numbers> l
 fn reset_private_sequence(input: &str) -> OpResult {
     nom::sequence::tuple((
         nom::character::streaming::char('?'),
-        nom::bytes::streaming::take_till(|c| c == 'l'),
+        nom::character::streaming::digit0,
         nom::character::streaming::char('l'),
     ))(input)
     .map(|(rest, (_, b, _))| (rest, Op::DecPrivateReset(b.to_owned())))
@@ -477,10 +482,29 @@ pub enum OpChar {
     Op(Op),
 }
 
+#[derive(Debug)]
 pub enum OpStr {
     Str(String),
     Op(Op),
-    InSequence,
+}
+
+#[derive(Debug)]
+pub struct ParseRes<'a> {
+    pub rest: &'a str,
+    pub opstr: Vec<OpStr>,
+}
+
+impl<'a> ParseRes<'a> {
+    fn from_ops(ops: Vec<OpStr>) -> ParseRes<'a> {
+        ParseRes {
+            rest: "",
+            opstr: ops,
+        }
+    }
+
+    fn new(ops: Vec<OpStr>, rest: &'a str) -> ParseRes<'a> {
+        ParseRes { rest, opstr: ops }
+    }
 }
 
 impl From<char> for OpChar {
@@ -489,58 +513,51 @@ impl From<char> for OpChar {
     }
 }
 
-pub struct TerminalEsc {
-    buffer: String,
+pub fn parse_esc_str(s: &str) -> ParseRes {
+    parse_esc_str_tail(s, vec![])
 }
 
 ///
-/// Future buffered version
+/// buffered version
 /// "hello" -> "hello" (nom returns Error)
 /// "ESC[","garbage" -> `InSequence`, "arbage" (nom returns Failure)
-/// "ESC[Ablah", "garbage" -> [Foo(Op), Foo("blah")], [Foo("garbage")],
+/// "ESC[Ablah", "garbage" -> [Foo(Op(A)), Foo("blah")], [Foo("garbage")],
+/// "garbageESC[Ablah" -> ["garbage", Op(A), "blah"]
+/// "garbageESC[Xblah" -> ["garbage", "blah"]
 ///
-impl TerminalEsc {
-    pub fn new() -> TerminalEsc {
-        TerminalEsc {
-            buffer: String::new(),
-        }
+pub fn parse_esc_str_tail(s: &str, mut current: Vec<OpStr>) -> ParseRes {
+    if s.is_empty() {
+        return ParseRes::from_ops(current);
     }
-
-    pub fn push(&mut self, c: char) -> Option<OpChar> {
-        self.buffer.push(c);
-
-        let seq = self.buffer.as_str();
-        match parse(seq) {
-            Err(nom::Err::Incomplete(_)) => {
-                // If we are incomplete, then do nothing
-                // print!("{}", c.escape_default());
-                None
-            }
-            Err(nom::Err::Error(_)) => {
-                // If we got an error, then we didn't recognize an esc seq at all
-                // So pop the char back off the buffer
-                self.buffer.pop().map(OpChar::from)
-                // h e l l o
-            }
-            Err(nom::Err::Failure(_)) => {
-                // And clear the buffer
-                // ESC [ 6 * ESC [ 6 * ESC [ 6 * h e l l o literally the word loop and then some returns
-
-                // If failure, then we were in a sequence but bombed out, and consume all the chars
-                self.buffer.clear();
-                None
-            }
-            Ok((_, op)) => {
-                // If we parsed an escape sequence, then clear the buffer and return the Op
-                self.buffer.clear();
-                Some(OpChar::Op(op))
-            }
+    match parse(s) {
+        Err(nom::Err::Incomplete(_)) => {
+            // If we are incomplete, then do nothing
+            // print!("{}", c.escape_default());
+            ParseRes::new(current, s)
         }
-    }
-}
+        Err(nom::Err::Error(_)) => {
+            // If we got an error, then we didn't recognize an esc seq at all
+            // So pop the char back off the buffer
+            let (rest, esc) = s.find(ESC).map_or((s, ""), |i| s.split_at(i));
+            // abcde,ESC[
+            current.push(OpStr::Str(rest.to_string()));
+            parse_esc_str_tail(esc, current)
+            // h e l l o
+        }
+        Err(nom::Err::Failure(e)) => {
+            // And clear the buffer
+            // ESC [ 6 * ESC [ 6 * ESC [ 6 * h e l l o literally the word loop and then some returns
+
+            // If failure, then we were in a sequence but bombed out, and consume all the chars
+            // ESC [ XYZ
+            let skip_index = e.input.ceil_char_boundary(1);
+            parse_esc_str_tail(&e.input[skip_index..], current)
+        }
+        Ok((rest, op)) => {
+            // If we parsed an escape sequence, then clear the buffer and return the Op
 
-impl Default for TerminalEsc {
-    fn default() -> Self {
-        TerminalEsc::new()
+            current.push(OpStr::Op(op));
+            parse_esc_str_tail(rest, current)
+        }
     }
 }