From 9f5512442177b1242e40c25c14b0ae5d8e6f5359 Mon Sep 17 00:00:00 2001 From: Rory Dudley Date: Mon, 30 Sep 2024 21:55:34 -0600 Subject: Slight refactor of getchar() and more handling for getline() The getchar() function was changed so that it is able to detect some ANSI escape sequences. To better handle this, getchar() now returns a value from the Key enum, indicating whether or not an escape sequence was found. Currently, the only escape sequences the function deals with are arrow keys. Handling of the left and right arrow keys were added to the getline() function, in order to allow a user to go back and edit their command inplace. Up and down arrow keys are also handled, but they are just ignored for now (i.e. they do not move the cursor around anymore). The local 'pos' variable became an Arc>, since it needs to be reset to 0 if ctrl-c is pressed (the handler for which is outside the scope of getline()). Signed-off-by: Rory Dudley --- src/buffer.rs | 148 ++++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 118 insertions(+), 30 deletions(-) (limited to 'src/buffer.rs') diff --git a/src/buffer.rs b/src/buffer.rs index eedb694..8668249 100644 --- a/src/buffer.rs +++ b/src/buffer.rs @@ -4,14 +4,47 @@ use std::sync::{Arc, Mutex}; // STDIN is file descriptor (fd) 0 on Linux and other UN*X-likes pub const STDIN: i32 = 0; +// Key input types from the user +enum Key { + Up, + Down, + Right, + Left, + Else(u8), + Ignored, +} + /// Retrieve a single byte of input /// /// Requires some setup beforehand (see beginning of repl()) -fn getchar() -> u8 { +fn getchar() -> Key { let mut b = [0; 1]; io::stdout().lock().flush().unwrap(); io::stdin().read_exact(&mut b).unwrap(); - b[0] + + // Might me an ASNI escape sequence + if b[0] == 27 { + io::stdin().read_exact(&mut b).unwrap(); + + if b[0] == 91 { + io::stdin().read_exact(&mut b).unwrap(); + + match b[0] { + // Arrow keys + 65 => return Key::Up, + 66 => return Key::Down, + 67 => return Key::Right, + 68 => return Key::Left, + + // Everything else + _ => return Key::Ignored, + } + } + + return Key::Ignored; + } + + Key::Else(b[0]) } /// Handle user input at the repl prompt @@ -23,46 +56,101 @@ fn getchar() -> u8 { /// means special cases for handling backspace, newlines, etc. Assumes /// that (ICANON and ECHO) are off. See the beginning of [crate::repl] /// for more details. -pub fn getline(buffer: &mut Arc>>) -> usize { - // Keep track of position for backspaces - let mut pos: usize = 0; - +pub fn getline(buffer: &mut Arc>>, pos: &mut Arc>) -> usize { // Loop over characters until there is a newline loop { let c = getchar(); match c { - // enter/return - b'\n' => break, - - // tab - b'\t' => { - pos += 1; - print!(" "); - buffer.lock().unwrap().push(b' '); + Key::Up => { + continue; } - - // ctrl-d - 4 => return 0, - - // backspace - 127 => { - if pos == 0 { + Key::Down => { + continue; + } + Key::Right => { + if *pos.lock().unwrap() >= buffer.lock().unwrap().len() { continue; } - pos -= 1; - buffer.lock().unwrap().pop(); - print!("\u{8} \u{8}"); + print!("\x1b[1C"); + *pos.lock().unwrap() += 1; } - - // everything else - _ => { - pos += 1; - print!("{}", c as char); - buffer.lock().unwrap().push(c); + Key::Left => { + if *pos.lock().unwrap() == 0 { + continue; + } + print!("\u{8}"); + *pos.lock().unwrap() -= 1; + } + Key::Ignored => { + continue; } + Key::Else(c) => match c { + // enter/return + b'\n' => break, + + // tab + b'\t' => { + *pos.lock().unwrap() += 1; + print!(" "); + buffer.lock().unwrap().push(b' '); + } + + // ctrl-d + 4 => return 0, + + // backspace + 127 => { + if *pos.lock().unwrap() == 0 { + continue; + } + *pos.lock().unwrap() -= 1; + + if *pos.lock().unwrap() == buffer.lock().unwrap().len() { + buffer.lock().unwrap().pop(); + print!("\u{8} \u{8}"); + } else { + buffer.lock().unwrap().remove(*pos.lock().unwrap()); + print!( + "\u{8}{} ", + String::from_utf8_lossy( + &buffer.lock().unwrap()[*pos.lock().unwrap()..] + ) + ); + for _ in *pos.lock().unwrap()..buffer.lock().unwrap().len() + 1 { + print!("\u{8}"); + } + } + } + + // everything else + _ => { + // Print out the character as the user is typing + print!("{}", c as char); + + // Insert the character onto the buffer at whatever *pos.lock().unwrap()ition the cursor is at + buffer.lock().unwrap().insert(*pos.lock().unwrap(), c); + + // Increment our *pos.lock().unwrap()ition + *pos.lock().unwrap() += 1; + + // Reprint the end of the buffer if inserting at the front or middle + if *pos.lock().unwrap() != buffer.lock().unwrap().len() { + print!( + "{}", + String::from_utf8_lossy( + &buffer.lock().unwrap()[*pos.lock().unwrap()..] + ) + ); + for _ in *pos.lock().unwrap()..buffer.lock().unwrap().len() { + print!("\u{8}"); + } + } + } + }, } } + *pos.lock().unwrap() = 0; println!(); buffer.lock().unwrap().push(b'\n'); buffer.lock().unwrap().len() -- cgit v1.2.3