scroll/demo/editor.rs

1687 lines
39 KiB
Rust
Raw Normal View History

#![forbid(unsafe_code)]
//! Editor functionality
use crate::terminal_helpers::*;
use std::cmp::PartialEq;
use std::fs::File;
use std::io;
use std::io::prelude::*;
use std::io::BufReader;
use std::ops::Range;
use std::time::{Duration, Instant};
use self::KeyCode::*;
// ------------------------------------------------------------------------
// Defines
// ------------------------------------------------------------------------
const KILO_TAB_STOP: usize = 4;
const KILO_QUIT_TIMES: u8 = 3;
// ------------------------------------------------------------------------
// Data
// ------------------------------------------------------------------------
// Use an external package's macro to create a memory-safe
// bit flag alternative
bitflags! {
#[derive(Default)]
pub struct SyntaxFlags: u32 {
const HIGHLIGHT_NUMBERS = 0b00000001;
const HIGHLIGHT_STRINGS = 0b00000010;
}
}
/// Configuration for language syntax highlighting
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Syntax {
/// Language name, to be shown in status bar
file_type: String,
/// File extensions
file_match: Vec<&'static str>,
/// Keywords
keywords1: Vec<&'static str>,
/// Type and/or secondary keywords
keywords2: Vec<&'static str>,
/// How does a single line comment start?
singleline_comment_start: String,
/// How does a multline comment start?
multiline_comment_start: String,
/// How does a multiline comment end?
multiline_comment_end: String,
/// Options for what to highlight
flags: SyntaxFlags,
}
/// Syntax highlighting token types
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum Highlight {
/// No highlighting
Normal,
/// Single line comments
LineComment,
/// Multiple line comments
MultiLineComment,
/// Language keywords
Keyword1,
/// Language types/ secondary keywords
Keyword2,
/// Single-line strings
String,
/// Numbers
Number,
/// Search results
SearchMatch,
}
/// A representation of a line in the editor
#[derive(Clone, Debug, Default)]
pub struct Row {
/// The 'raw' representation of the original characters
chars: String,
/// The display characters for the editor
render: String,
/// The highlighting type for each character
highlight: Vec<Highlight>,
/// Are we currently highlighting a multi-line comment?
highlight_comment_start: bool,
}
/// Main structure for the editor
/// `EditorConfig` struct in C version
#[derive(Debug)]
pub struct Editor {
cursor_x: usize,
cursor_y: usize,
render_x: usize,
col_offset: usize,
row_offset: usize,
screen_cols: usize,
screen_rows: usize,
rows: Vec<Row>,
dirty: u64,
filename: String,
status_message: String,
status_message_time: Instant,
syntax: Option<Syntax>,
// Properties not present in C version
output_buffer: String,
quit_times: u8,
search_last_match: i32,
search_direction: i8,
search_last_line: usize,
search_last_hightlight: Vec<Highlight>,
}
/// Keycode mapping enum
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum KeyCode<T = char> {
Enter,
Escape,
Backspace,
ArrowLeft,
ArrowRight,
ArrowUp,
ArrowDown,
DeleteKey,
HomeKey,
EndKey,
PageUp,
PageDown,
Tab,
/// Control key chords
Ctrl(T),
/// Function keys (F1, etc.) T holds the index
Function(T),
/// Any other type of character
OtherKey(T),
}
impl Syntax {
pub fn new(
file_type: &str,
file_match: Vec<&'static str>,
keywords1: Vec<&'static str>,
keywords2: Vec<&'static str>,
single_line_comment_start: &str,
multi_line_comment_start: &str,
multi_line_comment_end: &str,
flags: SyntaxFlags,
) -> Self {
Syntax {
file_type: file_type.to_owned(),
file_match,
keywords1,
keywords2,
singleline_comment_start: single_line_comment_start.to_owned(),
multiline_comment_start: multi_line_comment_start.to_owned(),
multiline_comment_end: multi_line_comment_end.to_owned(),
flags,
}
}
}
impl Row {
pub fn new(chars: &str) -> Self {
let mut instance = Row::default();
instance.chars = chars.to_owned();
instance
}
}
impl KeyCode<char> {
pub fn unwrap(self) -> char {
match self {
self::Ctrl(val) => val,
self::Function(val) => val,
self::OtherKey(val) => val,
_ => panic!("called `KeyCode::unwrap()` on a `None` value"),
}
}
}
impl Default for Editor {
fn default() -> Self {
Editor {
cursor_x: 0,
cursor_y: 0,
render_x: 0,
col_offset: 0,
row_offset: 0,
screen_cols: 0,
screen_rows: 0,
rows: vec![],
dirty: 0,
filename: String::new(),
status_message: String::new(),
// This is the only reason I had to implement this method
// manually, instead of it being derived. Apparently an
// `Instant` struct has no default
status_message_time: Instant::now(),
syntax: None,
output_buffer: String::new(),
quit_times: KILO_QUIT_TIMES,
search_last_match: -1,
search_direction: 1,
search_last_line: 0,
search_last_hightlight: vec![],
}
}
}
impl Editor {
// ------------------------------------------------------------------------
// Init
// ------------------------------------------------------------------------
pub fn new() -> Self {
let size = Self::get_window_size();
Editor {
screen_cols: size.cols as usize,
screen_rows: (size.rows - 2) as usize,
..Editor::default()
}
}
// ------------------------------------------------------------------------
// Terminal
// ------------------------------------------------------------------------
/// Convert stdin to specific keypresses
fn read_key(&mut self) -> Option<KeyCode> {
// --------------------------------------------------------------------
// Match single character
// --------------------------------------------------------------------
let stdin = io::stdin();
let stdin = stdin.lock();
let mut br = BufReader::with_capacity(5, stdin);
let mut first_read = [0; 1];
match br.read_exact(&mut first_read) {
Ok(_) => (),
Err(e) => {
if e.kind() != io::ErrorKind::UnexpectedEof {
let error = format!("{:?}", e);
self.set_status_message(&error);
}
}
}
let first_str = String::from_utf8(first_read.to_vec());
if first_str.is_err() {
return None;
}
let first_str = first_str.unwrap();
// Read the first character, if it isn't escape, just return it
let mut chs = first_str.chars();
let ch = chs.next();
match ch {
Some(ch) => match ch {
'\0' => return None,
'\x1b' => (),
'\x08' => return Some(Backspace),
'\x7f' => return Some(Backspace),
'\r' => return Some(Enter),
'\t' => return Some(Tab),
ch => {
if ch.is_ascii_control() {
return Some(Ctrl(ctrl_to_letter(ch)));
}
return Some(OtherKey(ch));
}
},
None => return None,
}
// --------------------------------------------------------------------
// Match escape sequence
// --------------------------------------------------------------------
let mut seq = [0; 4];
let mut seq_handle = br.take(4);
match seq_handle.read(&mut seq) {
Ok(_) => (),
Err(e) => {
if e.kind() != io::ErrorKind::UnexpectedEof {
let error = format!("{:?}", e);
self.set_status_message(&error);
}
}
}
let seq_str = String::from_utf8(seq.to_vec());
// On error, just continue the input loop
if seq_str.is_err() {
return None;
}
let seq_str = seq_str.unwrap();
let mut input: Vec<KeyCode<char>> = vec![];
for ch in seq_str.chars() {
// Since the fixed array is always filled, there
// will be null characters. Ignore these.
if ch == '\0' {
continue;
}
input.push(match ch {
'\x1b' => Escape,
_ => OtherKey(ch),
});
}
// Since we matched Escape earlier, if the input is empty,
// this must be the escape key
if input.is_empty() {
return Some(Escape);
}
match input.len() {
4 => {
// Escape code of the form `^[[NM~`
if input[3].eq(&OtherKey('~')) {
let action = match (input[1].unwrap(), input[2].unwrap()) {
('1', '5') => Function('5'),
('1', '7') => Function('6'),
('1', '8') => Function('7'),
('1', '9') => Function('8'),
('2', '0') => Function('9'),
('2', '1') => Function('X'), // F10
('2', '4') => Function('T'), // F12
_ => Escape,
};
return Some(action);
}
}
3 => {
// Escape code of the form `^[[N~`
if input[2].eq(&OtherKey('~')) {
let action = match input[1].unwrap() {
'1' => HomeKey,
'3' => DeleteKey,
'4' => EndKey,
'5' => PageUp,
'6' => PageDown,
'7' => HomeKey,
'8' => EndKey,
_ => Escape,
};
return Some(action);
}
}
2 => {
match input[0] {
// Escape code of the form `^[[X`
OtherKey('[') => {
let action = match input[1].unwrap() {
'A' => ArrowUp,
'B' => ArrowDown,
'C' => ArrowRight,
'D' => ArrowLeft,
'H' => HomeKey,
'F' => EndKey,
// Eh, just return escape otherwise
_ => Escape,
};
return Some(action);
}
// Escape code of the form `^[OX`
OtherKey('O') => {
let action = match input[1].unwrap() {
'H' => HomeKey,
'F' => EndKey,
'P' => Function('1'),
'Q' => Function('2'),
'R' => Function('3'),
'S' => Function('4'),
_ => Escape,
};
return Some(action);
}
_ => return Some(Escape),
}
}
_ => return Some(input[0]),
}
// If the character doesn't match any escape sequences, just
// pass that character on
return Some(input[0]);
}
/// Get terminal size in rows and columns
fn get_window_size() -> TermSize {
match get_term_size() {
Some(size) => size,
None => get_cursor_position(),
}
}
// ------------------------------------------------------------------------
// Syntax Highlighting
// ------------------------------------------------------------------------
fn update_syntax(&mut self, index: usize) {
let rows = &mut self.rows;
let prev_row = if index > 0 {
// I shouldn't have to clone this, but the lifetime is
// different than the `row` variable above, so it
// can't be a immutable borrow. It also can't be a
// mutable borrow, because it would be considered a
// second mutable borrow...so a clone it is
Some((&mut rows[index - 1]).clone())
} else {
None
};
let row = &mut rows[index];
let render_len = row.render.len();
// Reset the highlighting of the row
row.highlight = vec![Highlight::Normal; render_len];
if self.syntax.is_none() {
return;
}
// This is dumb. This lets you get a reference to the item in
// the option, by turning Option<T> into Option<&T>,
// which can then be unwrapped.
let current_syntax = self.syntax.as_ref().unwrap();
let keywords1 = &current_syntax.keywords1;
let keywords2 = &current_syntax.keywords2;
let scs = &current_syntax.singleline_comment_start;
let mcs = &current_syntax.multiline_comment_start;
let mce = &current_syntax.multiline_comment_end;
let mut prev_separator = true;
let mut in_string = false;
let mut str_start = '\0';
let mut in_comment = prev_row.map_or(false, |row| row.highlight_comment_start);
let mut i = 0;
let bytes = row.render.clone().into_bytes();
while i < render_len {
let c = bytes[i] as char;
let prev_highlight = if i > 0 {
row.highlight[i - 1]
} else {
Highlight::Normal
};
// Single line comments
if scs.len() > 0 && !in_string && !in_comment {
let range = get_slice_range(i, scs.len(), render_len);
if &row.render[range] == scs {
// Pretty simple, highlight from the match to the end of the line
highlight_range(&mut row.highlight, i..render_len, Highlight::LineComment);
break;
}
}
// Multi-line comments
if mcs.len() > 0 && mce.len() > 0 && !in_string {
let mce_range = get_slice_range(i, mce.len(), render_len);
let mcs_range = get_slice_range(i, mcs.len(), render_len);
if in_comment {
row.highlight[i] = Highlight::MultiLineComment;
// End of a comment
if &row.render[mce_range.clone()] == mce {
highlight_range(&mut row.highlight, mce_range, Highlight::MultiLineComment);
i += mce.len();
in_comment = false;
prev_separator = true;
continue;
} else {
i += 1;
continue;
}
} else if &row.render[mcs_range.clone()] == mcs {
// Start of a multi-line comment
highlight_range(&mut row.highlight, mcs_range, Highlight::MultiLineComment);
i += mcs.len();
in_comment = true;
continue;
}
}
// Strings
if current_syntax
.flags
.contains(SyntaxFlags::HIGHLIGHT_STRINGS)
{
if in_string {
row.highlight[i] = Highlight::String;
// Don't end highlighting for a string on an escaped quote
if c == '\\' && i + 1 < render_len {
row.highlight[i + 1] = Highlight::String;
i += 2;
continue;
}
// End delimiter for the string
if c == str_start {
in_string = false;
str_start = '\0';
}
i += 1;
prev_separator = true;
continue;
} else {
if (c == '"' || c == '\'') && prev_separator {
in_string = true;
str_start = c;
row.highlight[i] = Highlight::String;
i += 1;
continue;
}
}
}
// Numbers
if current_syntax
.flags
.contains(SyntaxFlags::HIGHLIGHT_NUMBERS)
{
if (c.is_ascii_digit() && (prev_separator || prev_highlight == Highlight::Number))
|| (c == '.' && prev_highlight == Highlight::Number)
{
row.highlight[i] = Highlight::Number;
i += 1;
prev_separator = false;
continue;
}
}
// Keywords
if prev_separator {
for &keyword in keywords1 {
if i + keyword.len() >= render_len {
continue;
}
let search_range = get_slice_range(i, keyword.len(), render_len);
let next_char_offset = i + keyword.len();
let is_end_of_line = next_char_offset >= render_len;
let next_char = if is_end_of_line {
'\0'
} else {
bytes[next_char_offset] as char
};
if &row.render[search_range.clone()] == keyword && is_separator(next_char) {
highlight_range(&mut row.highlight, search_range, Highlight::Keyword1);
i += keyword.len() - 1;
}
}
for &keyword in keywords2 {
if i + keyword.len() >= render_len {
continue;
}
let search_range = get_slice_range(i, keyword.len(), render_len);
let next_char_offset = i + keyword.len();
let is_end_of_line = next_char_offset >= render_len;
let next_char = if is_end_of_line {
'\0'
} else {
bytes[next_char_offset] as char
};
if &row.render[search_range.clone()] == keyword && is_separator(next_char) {
highlight_range(&mut row.highlight, search_range, Highlight::Keyword2);
i += keyword.len() - 1;
}
}
}
prev_separator = is_separator(c);
i += 1;
}
let changed = row.highlight_comment_start != in_comment;
row.highlight_comment_start = in_comment;
// If a multi-line comment is opened or closed,
// update the next row as well.
if changed && index + 1 < self.rows.len() {
self.update_syntax(index + 1);
}
}
fn select_syntax_highlight(&mut self) {
if self.filename.is_empty() {
return;
}
let mut parts: Vec<&str> = self.filename.split('.').collect();
let file_ext = String::from(".")
+ match parts.pop() {
Some(ext) => ext,
None => return,
};
let languages = &get_syntax_db();
for language in languages {
let file_match = language.file_match.clone();
for ext in file_match {
if ext == file_ext {
self.syntax = Some(language.clone());
// Re-highlight file when the type is determined
for x in 0..self.rows.len() {
self.update_syntax(x);
}
return;
}
}
}
}
// ------------------------------------------------------------------------
// Input
// ------------------------------------------------------------------------
fn prompt(
&mut self,
prompt: &str,
cb: Option<&mut dyn Fn(&mut Self, &str, KeyCode<char>)>,
) -> String {
let mut buffer = String::new();
let default_cb = &mut Self::_noop_prompt_cb;
let cb = match cb {
Some(cb) => cb,
None => default_cb,
};
loop {
self.set_status_message(&format!("{} {}", prompt, buffer));
self.refresh_screen();
let ch = self.read_key();
if ch.is_some() {
let ch = ch.unwrap();
match ch {
Backspace => {
buffer.pop();
}
DeleteKey => {
buffer.pop();
}
Escape => {
self.set_status_message("");
cb(self, &String::from(""), ch);
return String::from("");
}
Enter => {
if buffer.len() != 0 {
self.set_status_message("");
cb(self, &buffer, ch);
return buffer;
}
}
OtherKey(ch) => {
if (!ch.is_ascii_control()) && (ch as u8) < 128 {
buffer.push(ch);
// continue;
}
}
_ => (),
};
cb(self, &buffer, ch);
}
}
}
fn _noop_prompt_cb(&mut self, _: &str, _: KeyCode<char>) {}
fn move_cursor(&mut self, key: &KeyCode<char>) {
let row = self.rows.get(self.cursor_y);
match key {
ArrowLeft => {
if self.cursor_x != 0 {
// Move cursor left
self.cursor_x -= 1;
} else if self.cursor_y > 0 {
// Move to the end of the previous line
self.cursor_y -= 1;
self.cursor_x = self.rows[self.cursor_y].chars.len();
}
}
ArrowRight => {
if row.is_some() && self.cursor_x < row.unwrap().chars.len() {
// Move cursor right
self.cursor_x += 1;
} else if row.is_some() && self.cursor_x == row.unwrap().chars.len() {
// Move to start of next line
self.cursor_y += 1;
self.cursor_x = 0;
}
}
ArrowUp => {
if self.cursor_y > 0 {
self.cursor_y -= 1;
}
}
ArrowDown => {
if self.cursor_y < self.rows.len() {
self.cursor_y += 1;
}
}
_ => (),
};
let row = self.rows.get(self.cursor_y);
let row_len = if row.is_some() {
row.unwrap().chars.len()
} else {
0
};
// Snap to end of line when scrolling down
if self.cursor_x > row_len {
self.cursor_x = row_len;
}
}
/// Route user input to the appropriate handler method
pub fn process_keypress(&mut self) -> Option<KeyCode<char>> {
let key = self.read_key();
if key.is_some() {
let ch = key.unwrap();
match ch {
Backspace => self._del_or_backspace(Backspace),
DeleteKey => self._del_or_backspace(DeleteKey),
Enter => self.insert_new_line(),
Escape => (),
ArrowUp => self.move_cursor(&ArrowUp),
ArrowDown => self.move_cursor(&ArrowDown),
ArrowLeft => self.move_cursor(&ArrowLeft),
ArrowRight => self.move_cursor(&ArrowRight),
PageUp => self._page_up_or_down(PageUp),
PageDown => self._page_up_or_down(PageDown),
HomeKey => {
self.cursor_x = 0;
}
EndKey => {
if self.cursor_y < self.rows.len() {
self.cursor_x = self.rows[self.cursor_y].chars.len();
}
}
Tab => self.insert_char('\t'),
Ctrl(c) => match c {
'f' => self.find(),
's' => {
// Save success/error message handled by save method
match self.save() {
Ok(_) => (),
Err(_) => (),
}
}
'q' => {
if self.dirty > 0 && self.quit_times > 0 {
self.set_status_message(&format!("WARNING!!! File has unsaved changes. Press Ctrl-Q {} more times to quit.", self.quit_times));
self.quit_times -= 1;
return Some(OtherKey('\0'));
}
print!("\x1b[2J");
print!("\x1b[H");
// Break out of the input loop
return None;
}
_ => (),
},
Function(_) => (),
OtherKey(c) => {
self.insert_char(c);
}
};
self.quit_times = KILO_QUIT_TIMES;
return key;
}
// Continue the main input loop
Some(OtherKey('\0'))
}
fn _del_or_backspace(&mut self, key: KeyCode<char>) {
if key == DeleteKey {
self.move_cursor(&ArrowRight);
}
self.delete_char();
}
fn _page_up_or_down(&mut self, key: KeyCode<char>) {
let mut times = self.screen_rows;
// Update the cursor position
match key {
PageUp => {
self.cursor_y = self.row_offset;
}
PageDown => {
self.cursor_y = self.row_offset + self.screen_rows - 1;
if self.cursor_y > self.rows.len() {
self.cursor_y = self.rows.len();
}
}
_ => (),
}
// Scroll the file up or down
while times > 1 {
times -= 1;
self.move_cursor(match key {
PageUp => &ArrowUp,
PageDown => &ArrowDown,
_ => &OtherKey('\0'),
})
}
}
// ------------------------------------------------------------------------
// Output
// ------------------------------------------------------------------------
/// Equivalent of the abAppend function
/// in the original tutorial, just appends
/// to the `output_buffer` String in the
/// editor struct.
fn append_out(&mut self, str: &str) {
self.output_buffer.push_str(str);
}
fn append_out_char(&mut self, ch: char) {
self.output_buffer.push(ch);
}
fn scroll(&mut self) {
self.render_x = 0;
if self.cursor_y < self.rows.len() {
self.render_x = self.row_cx_to_rx(self.cursor_y, self.cursor_x);
}
// Vertical scrolling
if self.cursor_y < self.row_offset {
self.row_offset = self.cursor_y;
}
if self.cursor_y >= self.row_offset + self.screen_rows {
self.row_offset = self.cursor_y - self.screen_rows + 1;
}
// Horizontal scrolling
if self.render_x < self.col_offset {
self.col_offset = self.render_x;
}
if self.render_x >= self.col_offset + self.screen_cols {
self.col_offset = self.render_x - self.screen_cols + 1;
}
}
fn draw_rows(&mut self) {
for y in 0..self.screen_rows {
let file_row = y + self.row_offset;
if file_row >= self.rows.len() {
if self.rows.is_empty() && y == (self.screen_rows / 3) {
let mut welcome = format!(
"Oxidized Kilo editor -- version {}",
env!("CARGO_PKG_VERSION")
);
if welcome.len() > self.screen_cols {
welcome.truncate(self.screen_cols)
}
// Center welcome message
let mut padding = (self.screen_cols - welcome.len()) / 2;
if padding > 0 {
self.append_out_char('~');
padding -= 1;
}
for _ in 0..padding {
self.append_out_char(' ');
}
self.append_out(&welcome);
} else {
self.append_out_char('~');
}
} else {
let output = self.rows[file_row].render.clone();
let mut current_color: i32 = -1;
for (x, ch) in output.char_indices() {
if ch.is_ascii_control() {
// Display unprintable characters in inverted colors
let sym = if ch as u8 <= 26 {
('@' as u8 + ch as u8) as char
} else {
'?'
};
self.append_out("\x1b[7m");
self.append_out_char(sym);
self.append_out("\x1b[m");
if current_color != -1 {
let code = format!("\x1b[{}m", current_color);
self.append_out(&code);
}
} else if self.rows[file_row].highlight[x] == Highlight::Normal {
if current_color != -1 {
self.append_out("\x1b[0m");
self.append_out("\x1b[39m");
current_color = -1;
}
self.append_out_char(ch);
} else {
let color = syntax_to_color(self.rows[file_row].highlight[x]);
if color != current_color {
current_color = color;
let code = format!("\x1b[{}m", color);
self.append_out("\x1b[0m");
self.append_out(&code);
}
self.append_out_char(ch);
}
}
self.append_out("\x1b[0m");
self.append_out("\x1b[39m");
}
self.append_out("\x1b[K");
self.append_out("\r\n");
}
}
fn draw_status_bar(&mut self) {
self.append_out("\x1b[7m");
let filename = if self.filename.is_empty() {
"[No Name]"
} else {
&self.filename
};
let modified = if self.dirty > 0 { "(modified)" } else { "" };
let mut left_message = format!("{:.80} - {} lines {}", filename, self.rows.len(), modified);
let file_type = match &self.syntax {
Some(s) => &s.file_type,
None => "no ft",
};
let right_message = format!("{} | {}/{}", file_type, self.cursor_y + 1, self.rows.len());
let mut len = left_message.len();
if len > self.screen_cols {
len = self.screen_cols;
left_message.truncate(len);
}
self.append_out(&left_message);
for x in len..self.screen_cols {
if self.screen_cols - x == right_message.len() {
self.append_out(&right_message);
break;
}
self.append_out(" ");
}
self.append_out("\x1b[m");
self.append_out("\r\n");
}
fn draw_message_bar(&mut self) {
self.append_out("\x1b[K");
let mut message = self.status_message.clone();
let message_len = message.len();
if message_len > self.screen_cols {
message.truncate(self.screen_cols);
}
let five_seconds = Duration::from_secs(5);
if message_len > 0 && self.status_message_time.elapsed() < five_seconds {
self.append_out(&message);
}
}
pub fn refresh_screen(&mut self) {
self.scroll();
self.output_buffer.clear();
// Hide cursor, reposition cursor
self.append_out("\x1b[?25l");
self.append_out("\x1b[H");
self.draw_rows();
self.draw_status_bar();
self.draw_message_bar();
// Move cursor to state position
let y = (self.cursor_y - self.row_offset) + 1;
let x = (self.render_x - self.col_offset) + 1;
let cursor_code = format!("\x1b[{};{}H", y, x);
self.append_out(&cursor_code.as_str());
// Show cursor
self.append_out("\x1b[?25h");
let stdout = io::stdout();
let mut handle = stdout.lock();
// If you can't write to stdout, you might as well just panic
handle.write_all(&self.output_buffer.as_bytes()).unwrap();
// Explicitly flush output so that the cursor actually appears correctly
io::stdout().flush().unwrap();
}
/// Set the status bar message
///
/// To avoid creating a macro that would just forward to
/// the `format!` macro, this method only accepts a pre-formatted
/// string.
///
/// # Example
///
/// ```no-run
/// # use rs-kilo::editor::Editor;
/// # let editor = Editor::new();
/// let message = format!("{} is {}", key, status);
/// editor.set_status_message(&message);
/// ```
pub fn set_status_message(&mut self, message: &str) {
self.status_message = message.to_owned();
self.status_message_time = Instant::now();
}
// ------------------------------------------------------------------------
// Row Operations
// ------------------------------------------------------------------------
/// Convert cursor x position to the rendered x position
fn row_cx_to_rx(&mut self, index: usize, cx: usize) -> usize {
let mut rx: usize = 0;
for (i, ch) in self.rows[index].chars.char_indices() {
if i == cx {
return rx;
}
if ch == '\t' {
rx += (KILO_TAB_STOP - 1) - (rx % KILO_TAB_STOP);
}
rx += 1;
}
rx
}
/// Convert rendered x position to cursor x position
fn row_rx_to_cx(&mut self, index: usize, rx: usize) -> usize {
let mut current_rx: usize = 0;
let mut cx: usize = 0;
for ch in self.rows[index].chars.chars() {
if ch == '\t' {
current_rx += (KILO_TAB_STOP - 1) - (current_rx % KILO_TAB_STOP);
}
current_rx += 1;
if current_rx > rx {
return cx;
}
cx += 1;
}
cx
}
/// Convert file characters to their display equivalents
fn update_row(&mut self, index: usize) {
let row = &mut self.rows[index];
let str = row.chars.clone();
// Cheat at rendering tabs as spaces
let str = str.replace('\t', " ");
row.render = str;
// Syntax highlighting
self.update_syntax(index);
}
fn insert_row(&mut self, at: usize, content: &str) {
if at > self.rows.len() {
return;
}
let row = Row::new(content);
self.rows.insert(at, row);
self.update_row(at);
self.dirty += 1;
}
fn delete_row(&mut self, row_index: usize) {
if row_index > self.rows.len() {
return;
}
self.rows.remove(row_index);
self.dirty += 1;
}
fn row_insert_char(&mut self, row_index: usize, char_index: usize, ch: char) {
let mut at = char_index;
let row = &mut self.rows[row_index];
if at > row.chars.len() {
at = row.chars.len();
}
row.chars.insert(at, ch);
self.update_row(row_index);
self.dirty += 1;
}
fn row_append_string(&mut self, row_index: usize, strng: &str) {
let row = &mut self.rows[row_index];
row.chars += strng;
self.update_row(row_index);
self.dirty += 1;
}
fn row_delete_char(&mut self, row_index: usize, char_index: usize) {
let row = &mut self.rows[row_index];
if char_index >= row.chars.len() {
return;
}
row.chars.remove(char_index);
self.update_row(row_index);
self.dirty += 1;
}
// ------------------------------------------------------------------------
// Editor Operations
// ------------------------------------------------------------------------
fn insert_char(&mut self, ch: char) {
if self.cursor_y == self.rows.len() {
self.insert_row(self.rows.len(), "");
}
self.row_insert_char(self.cursor_y, self.cursor_x, ch);
self.cursor_x += 1;
}
fn insert_new_line(&mut self) {
if self.cursor_x == 0 {
self.insert_row(self.cursor_y, "");
} else {
// Clone the contents of the current row
let row = &mut self.rows[self.cursor_y];
let row_chars = row.chars.clone();
// Truncate the original row up to the cursor
row.chars.truncate(self.cursor_x);
// Create the new row as a slice of the contents of the old
// row, from the cursor to the end of the line
let slice = &row_chars[self.cursor_x..];
self.insert_row(self.cursor_y + 1, slice);
self.update_row(self.cursor_y);
}
self.cursor_y += 1;
self.cursor_x = 0;
}
fn delete_char(&mut self) {
if self.cursor_y == self.rows.len() {
return;
}
if self.cursor_x == 0 && self.cursor_y == 0 {
return;
}
if self.cursor_x > 0 {
self.row_delete_char(self.cursor_y, self.cursor_x - 1);
self.cursor_x -= 1;
} else {
// When deleting the first character in the row, collapse that row into the previous one
self.cursor_x = self.rows[self.cursor_y - 1].chars.len();
self.row_append_string(self.cursor_y - 1, &self.rows[self.cursor_y].chars.clone());
self.delete_row(self.cursor_y);
self.cursor_y -= 1;
}
}
// ------------------------------------------------------------------------
// File I/O
// ------------------------------------------------------------------------
fn rows_to_string(&mut self) -> String {
let mut output = String::new();
for row in &self.rows {
// When the file is opened, newlines are stripped
// make sure to add them back when saving!
output += &row.chars;
output.push('\n');
}
output
}
/// Open a file for display
pub fn open(&mut self, filename: &str) -> io::Result<()> {
let file = File::open(filename);
match file {
Ok(_) => {
let buf_reader = BufReader::new(file.unwrap());
let lines = buf_reader.lines().map(|l| clean_unwrap(l));
for line in lines {
self.insert_row(self.rows.len(), &line);
}
// Make sure the whole file is loaded before
// showing the filename and selecting the syntax
// for highlighting
self.filename = filename.to_owned();
self.select_syntax_highlight();
self.dirty = 0;
},
// Gracefully handle errors opening a file
Err(e) => {
self.set_status_message(&e.to_string());
}
}
Ok(())
}
fn save(&mut self) -> io::Result<()> {
if self.filename.len() == 0 {
self.filename = self.prompt("Save as (ESC to cancel):", None);
if self.filename.len() == 0 {
self.set_status_message("Save aborted");
return Ok(());
}
self.select_syntax_highlight();
}
let mut file = File::create(&self.filename)?;
let data = &mut self.rows_to_string();
let res = file.write_all(data.as_bytes());
match res {
Ok(()) => {
self.dirty = 0;
self.set_status_message(&format!("{} bytes written to disk", data.len()));
}
Err(e) => self.set_status_message(&format!("Failed to save: {}", e.to_string())),
};
file.sync_all()?;
Ok(())
}
// ------------------------------------------------------------------------
// Find
// ------------------------------------------------------------------------
fn find_callback(&mut self, query: &str, key: KeyCode<char>) {
if !self.search_last_hightlight.is_empty() {
self.rows[self.search_last_line].highlight = self.search_last_hightlight.clone();
self.search_last_hightlight.clear();
}
if key == Enter || key == Escape {
self.search_last_match = -1;
self.search_direction = 1;
return;
} else if key == ArrowRight || key == ArrowDown {
self.search_direction = 1;
} else if key == ArrowLeft || key == ArrowUp {
self.search_direction = -1;
} else {
self.search_last_match = -1;
self.search_direction = 1;
}
if self.search_last_match == -1 {
self.search_direction = 1;
}
if query.is_empty() {
return;
}
let mut current = self.search_last_match;
for x in 0..self.rows.len() {
current += self.search_direction as i32;
if current == -1 {
current = self.rows.len() as i32 - 1;
} else if current == self.rows.len() as i32 {
current = 0;
}
match self.rows[current as usize].render.find(query) {
None => (),
Some(start) => {
self.search_last_match = current;
self.cursor_y = current as usize;
self.cursor_x = self.row_rx_to_cx(x, start);
self.row_offset = self.rows.len();
self.search_last_line = current as usize;
self.search_last_hightlight = self.rows[current as usize].highlight.clone();
// Highlight matching search result
let len = start + query.len();
highlight_range(
&mut self.rows[current as usize].highlight,
start..len,
Highlight::SearchMatch,
);
break;
}
}
}
}
fn find(&mut self) {
let saved_cx = self.cursor_x;
let saved_cy = self.cursor_y;
let saved_coloff = self.col_offset;
let saved_rowoff = self.row_offset;
let query = self.prompt(
"Search (Use ESC/Arrows/Enter):",
Some(&mut Self::find_callback),
);
if query.is_empty() {
self.cursor_x = saved_cx;
self.cursor_y = saved_cy;
self.col_offset = saved_coloff;
self.row_offset = saved_rowoff;
}
}
}
// ------------------------------------------------------------------------
// Functions
// ------------------------------------------------------------------------
/// Get the language highlighting config
fn get_syntax_db() -> Vec<Syntax> {
vec![
Syntax::new(
"C/C++",
vec![".c", ".h", ".cpp"],
vec![
"continue", "typedef", "switch", "return", "static", "while", "break", "struct",
"union", "class", "else", "enum", "for", "case", "if",
],
vec![
"#include", "unsigned", "#define", "#ifndef", "double", "signed", "#endif",
"#ifdef", "float", "#error", "#undef", "long", "char", "int", "void", "#if",
],
"//",
"/*",
"*/",
SyntaxFlags::HIGHLIGHT_NUMBERS | SyntaxFlags::HIGHLIGHT_STRINGS,
),
Syntax::new(
"Rust",
vec![".rs"],
vec![
"continue", "return", "static", "struct", "unsafe", "break", "const", "crate",
"extern", "match", "super", "trait", "where", "else", "enum", "false", "impl",
"loop", "move", "self", "type", "while", "for", "let", "mod", "pub", "ref", "true",
"use", "mut", "as", "fn", "if", "in",
],
vec![
"DoubleEndedIterator",
"ExactSizeIterator",
"IntoIterator",
"PartialOrd",
"PartialEq",
"Iterator",
"ToString",
"Default",
"ToOwned",
"Extend",
"FnOnce",
"Option",
"String",
"AsMut",
"AsRef",
"Clone",
"Debug",
"FnMut",
"Sized",
"Unpin",
"array",
"isize",
"usize",
"&str",
"Copy",
"Drop",
"From",
"Into",
"None",
"Self",
"Send",
"Some",
"Sync",
"Sync",
"bool",
"char",
"i128",
"u128",
"Box",
"Err",
"Ord",
"Vec",
"dyn",
"f32",
"f64",
"i16",
"i32",
"i64",
"str",
"u16",
"u32",
"u64",
"Eq",
"Fn",
"Ok",
"i8",
"u8",
],
"//",
"/*",
"*/",
SyntaxFlags::HIGHLIGHT_NUMBERS | SyntaxFlags::HIGHLIGHT_STRINGS,
),
Syntax::new(
"JavaScript/TypeScript",
vec![".js", ".mjs", ".jsx", ".ts", ".tsx"],
vec![
"instanceof",
"continue",
"debugger",
"function",
"default",
"extends",
"finally",
"delete",
"export",
"import",
"return",
"switch",
"typeof",
"break",
"catch",
"class",
"const",
"super",
"throw",
"while",
"yield",
"case",
"else",
"this",
"void",
"with",
"from",
"for",
"new",
"try",
"var",
"do",
"if",
"in",
"as",
],
vec![
"=>", "Number", "String", "Object", "Math", "JSON", "Boolean",
],
"//",
"/*",
"*/",
SyntaxFlags::HIGHLIGHT_NUMBERS | SyntaxFlags::HIGHLIGHT_STRINGS,
),
]
}
/// Convert Ctrl+letter chord to their
/// letter equivalent
fn ctrl_to_letter(c: char) -> char {
let key = c as u8;
if (!c.is_ascii_control()) || c == '\x7f' {
panic!("Only ascii control characters have associated letters")
}
// Shift forward to the letter equivalent
(key + 0x60) as char
}
/// Determine whether a character is one which separates tokens
/// in the language to highlight
fn is_separator(input_char: char) -> bool {
if input_char.is_ascii_whitespace() || input_char == '\0' {
return true;
}
let separator_chars = ",.()+-/*=~%<>[];";
for ch in separator_chars.chars() {
if input_char == ch {
return true;
}
}
false
}
/// Get the highlight color escape sequence for
/// the type of syntax
fn syntax_to_color(syntax_type: Highlight) -> i32 {
use Highlight::*;
match syntax_type {
Keyword1 => 33, // Yellow
Keyword2 => 32, // Green
LineComment => 36, // Cyan
MultiLineComment => 90, // Bright Black
Normal => 37, // White
Number => 31, // Red
SearchMatch => 7, // Reverse!
String => 35, // Magenta
}
}
/// Get a range for a slice of a string or vector, checking the length of the
/// string or vector to prevent panics on invalid access.
///
/// If `start` to `start + search_len`, is within the size of the search target (`haystack_len`)
/// that range is returned. Otherwise, the range is from `start` to `haystack_len`.
fn get_slice_range(start: usize, needle_len: usize, haystack_len: usize) -> Range<usize> {
let search_len = start + needle_len;
if search_len >= haystack_len {
start..haystack_len
} else {
start..search_len
}
}
/// Set the highlighting type for the specified range
/// Kind of similar to the C memset calls
fn highlight_range(vec: &mut Vec<Highlight>, range: Range<usize>, value: Highlight) {
for x in range {
vec[x] = value;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn select_syntax_highlight_selects_language() {
let langs = get_syntax_db();
let mut editor = Editor::new();
editor.filename = String::from("foo.c");
editor.select_syntax_highlight();
assert_eq!(editor.syntax.as_ref(), Some(&langs[0]));
}
#[test]
fn is_separator_works() {
// Check each explicit character
for ch in ",.()+-/*=~%<>[];".chars() {
assert_eq!(is_separator(ch), true);
}
// Check each whitespace character
for ch in " \t\n\r\x0c".chars() {
assert_eq!(
is_separator(ch),
true,
"Character {:#} should be a separator",
ch as u8
);
}
// Letters are not separators!
for ch in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_".chars() {
assert_eq!(is_separator(ch), false);
}
}
#[test]
fn ctrl_to_letter_() {
let a = ctrl_to_letter('\x01');
assert_eq!(a, 'a', "ctrl_to_letter gives letter from ctrl chord");
}
#[test]
#[should_panic]
fn ctrl_to_letter_panic() {
// Del code doesn't map to Ctrl+letter combo
ctrl_to_letter('\x7f');
}
}