mirror of https://github.com/vinc/moros.git
389 lines
14 KiB
Rust
389 lines
14 KiB
Rust
use crate::{sys, usr};
|
|
use crate::api::{console, fs, io};
|
|
use crate::api::console::Style;
|
|
use alloc::format;
|
|
use alloc::string::{String, ToString};
|
|
use alloc::vec::Vec;
|
|
use core::cmp;
|
|
|
|
pub fn main(args: &[&str]) -> usr::shell::ExitCode {
|
|
if args.len() != 2 {
|
|
return usr::shell::ExitCode::CommandError;
|
|
}
|
|
|
|
let pathname = args[1];
|
|
let mut editor = Editor::new(pathname);
|
|
editor.run()
|
|
}
|
|
|
|
struct EditorConfig {
|
|
tab_size: usize,
|
|
}
|
|
|
|
pub struct Editor {
|
|
pathname: String,
|
|
lines: Vec<String>,
|
|
x: usize,
|
|
y: usize,
|
|
dx: usize, // Horizontal offset from the start
|
|
dy: usize, // Vertical offset from the top
|
|
config: EditorConfig,
|
|
}
|
|
|
|
impl Editor {
|
|
pub fn new(pathname: &str) -> Self {
|
|
let x = 0;
|
|
let y = 0;
|
|
let dx = 0;
|
|
let dy = 0;
|
|
let mut lines = Vec::new();
|
|
let config = EditorConfig { tab_size: 4 };
|
|
|
|
match fs::read_to_string(pathname) {
|
|
Ok(contents) => {
|
|
for line in contents.split('\n') {
|
|
lines.push(line.into());
|
|
}
|
|
},
|
|
Err(_) => {
|
|
lines.push(String::new());
|
|
}
|
|
};
|
|
|
|
let pathname = pathname.into();
|
|
|
|
Self { pathname, lines, x, y, dx, dy, config }
|
|
}
|
|
|
|
pub fn save(&mut self) -> usr::shell::ExitCode {
|
|
let mut contents = String::new();
|
|
let n = self.lines.len();
|
|
for i in 0..n {
|
|
contents.push_str(&self.lines[i]);
|
|
if i < n - 1 {
|
|
contents.push('\n');
|
|
}
|
|
}
|
|
|
|
if fs::write(&self.pathname, contents.as_bytes()).is_ok() {
|
|
let status = format!("Wrote {}L to '{}'", n, self.pathname);
|
|
self.print_status(&status, "Yellow");
|
|
usr::shell::ExitCode::CommandSuccessful
|
|
} else {
|
|
let status = format!("Could not write to '{}'", self.pathname);
|
|
self.print_status(&status, "LightRed");
|
|
usr::shell::ExitCode::CommandError
|
|
}
|
|
}
|
|
|
|
fn print_status(&mut self, status: &str, background: &str) {
|
|
let color = Style::color("Black").with_background(background);
|
|
let reset = Style::reset();
|
|
print!("\x1b[{};1H", self.rows() + 1); // Move cursor to the bottom of the screen
|
|
print!("{}{:cols$}{}", color, status, reset, cols = self.cols());
|
|
print!("\x1b[{};{}H", self.y + 1, self.x + 1); // Move cursor back
|
|
}
|
|
|
|
fn print_editing_status(&mut self) {
|
|
let max = 50;
|
|
let mut path = self.pathname.clone();
|
|
if self.pathname.chars().count() > max {
|
|
path.truncate(max - 3);
|
|
path.push_str("...");
|
|
}
|
|
let start = format!("Editing '{}'", path);
|
|
|
|
let x = self.dx + self.x + 1;
|
|
let y = self.dy + self.y + 1;
|
|
let n = y * 100 / self.lines.len();
|
|
let end = format!("{},{} {:3}%", y, x, n);
|
|
|
|
let width = self.cols() - start.chars().count();
|
|
let status = format!("{}{:>width$}", start, end, width = width);
|
|
|
|
self.print_status(&status, "LightGray");
|
|
}
|
|
|
|
fn print_screen(&mut self) {
|
|
let mut rows: Vec<String> = Vec::new();
|
|
let a = self.dy;
|
|
let b = self.dy + self.rows();
|
|
for y in a..b {
|
|
rows.push(self.render_line(y));
|
|
}
|
|
println!("\x1b[1;1H{}", rows.join("\n"));
|
|
}
|
|
|
|
fn render_line(&self, y: usize) -> String {
|
|
// Render line into a row of the screen, or an empty row when past eof
|
|
let line = if y < self.lines.len() { &self.lines[y] } else { "" };
|
|
|
|
let mut row: Vec<char> = format!("{:cols$}", line, cols = self.dx).chars().collect();
|
|
let n = self.dx + self.cols();
|
|
let after = if row.len() > n {
|
|
row.truncate(n - 1);
|
|
truncated_line_indicator()
|
|
} else {
|
|
" ".repeat(n - row.len())
|
|
};
|
|
row.extend(after.chars());
|
|
row[self.dx..].iter().collect()
|
|
}
|
|
|
|
fn render_char(&self, c: char) -> Option<String> {
|
|
match c {
|
|
'\t' => Some(" ".repeat(self.config.tab_size)),
|
|
c if console::is_printable(c) => Some(c.to_string()),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn run(&mut self) -> usr::shell::ExitCode {
|
|
print!("\x1b[2J\x1b[1;1H"); // Clear screen and move cursor to top
|
|
self.print_screen();
|
|
self.print_editing_status();
|
|
print!("\x1b[1;1H"); // Move cursor to the top of the screen
|
|
|
|
let mut escape = false;
|
|
let mut csi = false;
|
|
loop {
|
|
let c = io::stdin().read_char().unwrap_or('\0');
|
|
print!("\x1b[?25l"); // Disable cursor
|
|
match c {
|
|
'\x1B' => { // ESC
|
|
escape = true;
|
|
continue;
|
|
},
|
|
'[' if escape => {
|
|
csi = true;
|
|
continue;
|
|
},
|
|
'\0' => {
|
|
continue;
|
|
}
|
|
'\x11' => { // Ctrl Q
|
|
// TODO: Warn if modifications have not been saved
|
|
print!("\x1b[2J\x1b[1;1H"); // Clear screen and move cursor to top
|
|
print!("\x1b[?25h"); // Enable cursor
|
|
break;
|
|
},
|
|
'\x17' => { // Ctrl W
|
|
self.save();
|
|
print!("\x1b[?25h"); // Enable cursor
|
|
continue;
|
|
},
|
|
'\x18' => { // Ctrl X
|
|
let res = self.save();
|
|
print!("\x1b[2J\x1b[1;1H"); // Clear screen and move cursor to top
|
|
print!("\x1b[?25h"); // Enable cursor
|
|
return res;
|
|
},
|
|
'\n' => { // Newline
|
|
let y = self.dy + self.y;
|
|
let old_line = self.lines[y].clone();
|
|
let mut row: Vec<char> = old_line.chars().collect();
|
|
let new_line = row.split_off(self.dx + self.x).into_iter().collect();
|
|
self.lines[y] = row.into_iter().collect();
|
|
self.lines.insert(y + 1, new_line);
|
|
if self.y == self.rows() - 1 {
|
|
self.dy += 1;
|
|
} else {
|
|
self.y += 1;
|
|
}
|
|
self.x = 0;
|
|
self.dx = 0;
|
|
self.print_screen();
|
|
},
|
|
'A' if csi => { // Arrow up
|
|
if self.y > 0 {
|
|
self.y -= 1
|
|
} else if self.dy > 0 {
|
|
self.dy -= 1;
|
|
self.print_screen();
|
|
}
|
|
self.x = self.next_pos(self.x, self.y);
|
|
},
|
|
'B' if csi => { // Arrow down
|
|
let is_eof = self.dy + self.y == self.lines.len() - 1;
|
|
let is_bottom = self.y == self.rows() - 1;
|
|
if self.y < cmp::min(self.rows(), self.lines.len() - 1) {
|
|
if is_bottom || is_eof {
|
|
if !is_eof {
|
|
self.dy += 1;
|
|
self.print_screen();
|
|
}
|
|
} else {
|
|
self.y += 1;
|
|
}
|
|
self.x = self.next_pos(self.x, self.y);
|
|
}
|
|
},
|
|
'C' if csi => { // Arrow right
|
|
let line = &self.lines[self.dy + self.y];
|
|
if line.is_empty() || self.x + self.dx >= line.chars().count() {
|
|
print!("\x1b[?25h"); // Enable cursor
|
|
continue
|
|
} else if self.x == self.cols() - 1 {
|
|
self.x = self.dx;
|
|
self.dx += self.cols();
|
|
self.print_screen();
|
|
} else {
|
|
self.x += 1;
|
|
}
|
|
},
|
|
'D' if csi => { // Arrow left
|
|
if self.x + self.dx == 0 {
|
|
print!("\x1b[?25h"); // Enable cursor
|
|
continue;
|
|
} else if self.x == 0 {
|
|
self.x = self.dx - 1;
|
|
self.dx -= self.cols();
|
|
self.print_screen();
|
|
self.x = self.next_pos(self.x, self.y);
|
|
} else {
|
|
self.x -= 1;
|
|
}
|
|
},
|
|
'Z' if csi => { // Backtab (Shift + Tab)
|
|
// Do nothing
|
|
},
|
|
'\x14' => { // Ctrl T -> Go to top of file
|
|
self.x = 0;
|
|
self.y = 0;
|
|
self.dx = 0;
|
|
self.dy = 0;
|
|
self.print_screen();
|
|
},
|
|
'\x02' => { // Ctrl B -> Go to bottom of file
|
|
self.x = 0;
|
|
self.y = cmp::min(self.rows(), self.lines.len()) - 1;
|
|
self.dx = 0;
|
|
self.dy = self.lines.len() - 1 - self.y;
|
|
self.print_screen();
|
|
},
|
|
'\x01' => { // Ctrl A -> Go to beginning of line
|
|
self.x = 0;
|
|
self.dx = 0;
|
|
self.print_screen();
|
|
},
|
|
'\x05' => { // Ctrl E -> Go to end of line
|
|
let n = self.lines[self.dy + self.y].chars().count();
|
|
let w = self.cols();
|
|
self.x = n % w;
|
|
self.dx = w * (n / w);
|
|
self.print_screen();
|
|
},
|
|
'\x08' => { // Backspace
|
|
let y = self.dy + self.y;
|
|
if self.dx + self.x > 0 { // Remove char from line
|
|
|
|
let mut row: Vec<char> = self.lines[y].chars().collect();
|
|
row.remove(self.dx + self.x - 1);
|
|
self.lines[y] = row.into_iter().collect();
|
|
|
|
if self.x == 0 {
|
|
self.dx -= self.cols();
|
|
self.x = self.cols() - 1;
|
|
self.print_screen();
|
|
} else {
|
|
self.x -= 1;
|
|
let line = self.render_line(y);
|
|
print!("\x1b[2K\x1b[1G{}", line);
|
|
}
|
|
} else { // Remove newline from previous line
|
|
if self.y == 0 && self.dy == 0 {
|
|
print!("\x1b[?25h"); // Enable cursor
|
|
continue;
|
|
}
|
|
|
|
// Move cursor below the end of the previous line
|
|
let n = self.lines[y - 1].chars().count();
|
|
let w = self.cols();
|
|
self.x = n % w;
|
|
self.dx = w * (n / w);
|
|
|
|
// Move line to the end of the previous line
|
|
let line = self.lines.remove(y);
|
|
self.lines[y - 1].push_str(&line);
|
|
|
|
// Move cursor up to the previous line
|
|
if self.y > 0 {
|
|
self.y -= 1;
|
|
} else {
|
|
self.dy -= 1;
|
|
}
|
|
|
|
self.print_screen();
|
|
}
|
|
},
|
|
'\x7f' => { // Delete
|
|
let y = self.dy + self.y;
|
|
let n = self.lines[y].chars().count();
|
|
if self.dx + self.x >= n { // Remove newline from line
|
|
let line = self.lines.remove(y + 1);
|
|
self.lines[y].push_str(&line);
|
|
self.print_screen();
|
|
} else { // Remove char from line
|
|
self.lines[y].remove(self.dx + self.x);
|
|
let line = self.render_line(y);
|
|
print!("\x1b[2K\x1b[1G{}", line);
|
|
}
|
|
},
|
|
c => {
|
|
if let Some(s) = self.render_char(c) {
|
|
let y = self.dy + self.y;
|
|
let mut row: Vec<char> = self.lines[y].chars().collect();
|
|
for c in s.chars() {
|
|
row.insert(self.dx + self.x, c);
|
|
self.x += 1;
|
|
}
|
|
self.lines[y] = row.into_iter().collect();
|
|
if self.x >= self.cols() {
|
|
self.dx += self.cols();
|
|
self.x -= self.cols();
|
|
self.print_screen();
|
|
} else {
|
|
let line = self.render_line(self.dy + self.y);
|
|
print!("\x1b[2K\x1b[1G{}", line);
|
|
}
|
|
}
|
|
},
|
|
}
|
|
escape = false;
|
|
csi = false;
|
|
self.print_editing_status();
|
|
print!("\x1b[{};{}H", self.y + 1, self.x + 1);
|
|
print!("\x1b[?25h"); // Enable cursor
|
|
}
|
|
usr::shell::ExitCode::CommandSuccessful
|
|
}
|
|
|
|
// Move cursor past end of line to end of line or left of the screen
|
|
fn next_pos(&self, x: usize, y: usize) -> usize {
|
|
let eol = self.lines[self.dy + y].chars().count();
|
|
if eol <= self.dx + x {
|
|
if eol <= self.dx {
|
|
0
|
|
} else {
|
|
eol - 1
|
|
}
|
|
} else {
|
|
x
|
|
}
|
|
}
|
|
|
|
fn rows(&self) -> usize {
|
|
sys::console::rows() - 1 // Leave out one line for status line
|
|
}
|
|
|
|
fn cols(&self) -> usize {
|
|
sys::console::cols()
|
|
}
|
|
}
|
|
|
|
fn truncated_line_indicator() -> String {
|
|
let color = Style::color("Black").with_background("LightGray");
|
|
let reset = Style::reset();
|
|
format!("{}>{}", color, reset)
|
|
}
|