diff options
Diffstat (limited to 'main.rs')
| -rw-r--r-- | main.rs | 536 |
1 files changed, 452 insertions, 84 deletions
@@ -1,22 +1,31 @@ -use std::cmp::{min, max}; -use std::io; +#![feature(slice_patterns)] +// eh, whatever, unstable features... + +//use std::cmp::{min, max}; +//use std::io::Write as IoWrite; +use std::fmt::Write as FmtWrite; use std::io::{Seek, SeekFrom}; use std::fs; -use std::fmt::Write; use std::io::Read; use std::env; +use std::iter::FromIterator; //use std::path::Path; extern crate termios; use termios::{Termios, TCSANOW, ECHO, ICANON, tcsetattr}; extern crate termion; -use termion::{color, input}; +//use termion::{color, input}; use termion::input::TermRead; use termion::event::{Event, Key}; +use termion::screen::AlternateScreen; +use termion::raw::IntoRawMode; +use termion::clear; +use termion::cursor; fn main() { - println!("hello"); +// println!("hello"); +// let (w, h) = try!(termion::terminal_size()); match termion::terminal_size() { Ok((w, h)) => { if let Some(arg1) = env::args().nth(1) { @@ -36,9 +45,164 @@ fn usage() { println!("usage: this_thing filename"); } -struct Program { - filename: String, +struct CachingFileView { + file: std::fs::File, filelen: u64, + cache_seek: u64, + cache_size: usize, + cache_len: usize, + cache: Vec<u8> +} + +impl FileView for CachingFileView { + fn get_bytes(&mut self, offset: u64, len: u64) -> Vec<u8> { + if len > self.cache_size as u64 { + panic!("Caching view does not support get_bytes() larger than cache size"); + } + // check if we have to update the cache + if offset <= self.cache_seek as u64 || offset + len > self.cache_seek + self.cache_len as u64 { + // we do... + self.cache.clear(); + self.cache.resize(self.cache_size as usize, 0); + // Seek such that the requested bytes are the middle of the cache, if possible + // theory is this is a decent compromise for not knowing which direction + // to predict motion towards + self.cache_seek = std::cmp::max(offset as i64 - (self.cache_size as i64 / 2), 0) as u64; + self.file.seek(SeekFrom::Start(self.cache_seek)).unwrap(); + self.file.read(&mut self.cache).unwrap(); + self.cache_len = self.cache.len(); + } + + // ok now that's ``cached``... + let cached_start = (offset - self.cache_seek) as usize; + let cached_end = cached_start + len as usize; + Vec::from_iter(self.cache[cached_start..cached_end].iter().cloned()) + } + fn size(&self) -> u64 { self.filelen } +} + +impl CachingFileView { + fn new(filepath: String) -> Result<CachingFileView, std::io::Error> { + let f = try!(fs::File::open(&filepath)); + let metadata = try!(f.metadata()); + // modified() is probably how we should check concurrent modifications + if metadata.permissions().readonly() { + return Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "File is read-only")); + } + + Ok(CachingFileView { + file: f, + filelen: metadata.len(), + cache_seek: 0, + cache_size: 64 * 1024, + cache_len: 0, + cache: Vec::with_capacity(64 * 1024) + }) + } +} + +struct NoCacheFileView { + file: std::fs::File, + filelen: u64 +} + +impl NoCacheFileView { + fn new(filepath: String) -> Result<NoCacheFileView, std::io::Error> { + let f = try!(fs::File::open(&filepath)); + let metadata = try!(f.metadata()); + // modified() is probably how we should check concurrent modifications + if metadata.permissions().readonly() { + return Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "File is read-only")); + } + +// let f2: &'a fs::File = &f; + + Ok(NoCacheFileView { + file: f, + filelen: metadata.len() + }) + } +} + +trait FileView { + fn get_bytes(&mut self, offset: u64, len: u64) -> Vec<u8>; + fn size(&self) -> u64; +} + +const modal_width: usize = 24; + +impl FileView for NoCacheFileView { + fn get_bytes(&mut self, offset: u64, len: u64) -> Vec<u8> { + let mut vec = Vec::with_capacity(len as usize); + vec.resize(len as usize, 0); + self.file.seek(SeekFrom::Start(offset)).unwrap(); + self.file.read(&mut vec).unwrap(); + vec + } + fn size(&self) -> u64 { self.filelen } +} + +struct Edits { + +} + +impl Edits { + fn new() -> Edits { + Edits { + } + } + fn remove(&mut self, cursor: u64, sub_elem: u8) { + + } + fn record(&mut self, cursor: u64, sub_elem: u8, value: u8) { + + } +} + +trait EditMode { + fn render_bytes(&self, start: u64, bytes: std::slice::Iter<u8>) -> String; + // translates from the width of the display (terminal) + // to the number of bytes this edit mode can display + fn element_width(&self, display_width: u16) -> u64; + fn dec_sub_elem(&mut self, amount: u64); + fn inc_sub_elem(&mut self, amount: u64); +} + +struct HexMode { + sub_elem_idx: u8 +} + +impl EditMode for HexMode { + fn render_bytes(&self, start: u64, bytes: std::slice::Iter<u8>) -> String { + let mut text = "".to_owned(); + let mut ascii_text = "".to_owned(); + let col_size = 4; + let mut i: usize = 0; + for b in bytes { + text.push_str(&format!("{:02x}", b)); + ascii_text.push_str(&format!("{}", ascii_or_dot(b.to_owned()) as char)); + if i % col_size == (col_size - 1) { + text.push_str(" "); + } else { + text.push_str(" "); + } + i = i + 1; + } + format!("0x{:08x}: {} {}", start, text, ascii_text).to_owned() + } + fn element_width(&self, display_width: u16) -> u64 { + (display_width as u64 - 13) / 17 * 4 + } + fn dec_sub_elem(&mut self, amount: u64) { + self.sub_elem_idx = self.sub_elem_idx - amount as u8; + } + fn inc_sub_elem(&mut self, amount: u64) { + self.sub_elem_idx = self.sub_elem_idx + amount as u8; + } +} + +struct Program<'a, 'b> { + filename: String, width: u16, row_size: u16, height: u16, @@ -46,13 +210,29 @@ struct Program { cursor: u64, old_term: Termios, new_term: Termios, - buf: Vec<u8> + screen: &'a mut std::io::Write, + view: &'b mut FileView, + input_buf: Vec<char>, + state: Mode, + sub_elem: u8, + edits: Edits, + status: String, + edit_views: Vec<&'b mut EditMode>, + current_edit_idx: usize + //screen: AlternateScreen<termion::raw::RawTerminal<std::io::Stdout>> } -impl Program { +impl <'a, 'b> Program<'a, 'b> { + fn lines_to_draw(&self) -> u64 { + self.view_byte_height() / (self.edit_views.len() as u64 + 1) + } + fn seek_to(&mut self, dest: u64) { + self.cursor = dest; + self.recalculate_seek(); + } fn inc_cursor(&mut self, amount: u64) { - if self.filelen - self.cursor < amount { - self.cursor = self.filelen - 1; + if self.view.size() - self.cursor < amount { + self.cursor = self.view.size() - 1; } else { self.cursor += amount; } @@ -66,25 +246,48 @@ impl Program { } self.recalculate_seek(); } + + fn view_interface_height(&self) -> u64 { + 2 + } + + fn view_byte_height(&self) -> u64 { + self.height as u64 - self.view_interface_height() + } + + fn view_byte_width(&self) -> u64 { + self.row_size as u64 + } + + fn bytes_per_line(&self) -> u64 { + let mut min = self.view_byte_width(); + for view in self.edit_views.iter() { + min = std::cmp::min(min, view.element_width(self.width)); + } + min + } + fn recalculate_seek(&mut self) { - let old_seek = self.seek; - let bufsize = self.height as u64 * self.width as u64; - let render_lim = (self.row_size as u64) * (self.height as u64 - 1); // this shouldn't be decided here... - if self.cursor + render_lim > self.seek + bufsize { // know a priori that buf size is height * width. TODO: fix. - println!("aaaa"); + /* + * + * file: + * xXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxXxX + * seek: + * |-----------------------| + * render_lim: | + * cursor: | + * + */ + let hex_view_height = self.lines_to_draw(); + let bytes_per_line = self.view_byte_width(); + let render_lim = bytes_per_line * hex_view_height; + if self.cursor >= self.seek + render_lim { // know a priori that buf size is height * width. TODO: fix. // we've sought past the end, so reset seek to what would have been the start of this // display and it'll all work out from here. - self.seek = self.cursor - (self.cursor % self.row_size as u64); + self.seek = self.cursor - (self.cursor % bytes_per_line) - render_lim + bytes_per_line; } else if self.cursor < self.seek { - println!("bbbb"); - // we've sought before the start, so reset seek to just before. ideally, populate a - // buffer for like 1k before, but lazy. - self.seek = self.cursor - (self.cursor % self.row_size as u64); - } - - // repopulate buf.. - if self.seek != old_seek { - self.buf = populate_buf(&self.filename, self.seek, bufsize); + // we've sought before the start, so reset seek to just before. + self.seek = self.cursor - (self.cursor % bytes_per_line); } } } @@ -100,11 +303,12 @@ fn launch_interface(w: u16, h: u16, filename: String) { // fix terminal to not echo, thanks new_termios.c_lflag &= !(ICANON | ECHO); - let initial_buf = populate_buf(&filename, 0, w as u64 * h as u64); + //let initial_buf = populate_buf(&filename, 0, w as u64 * h as u64); + + let mut hexmode = HexMode { sub_elem_idx: 0 }; let mut state = Program { - filename: filename, - filelen: fs_meta.len(), + filename: filename.to_string(), width: w, // let col_width = 4; // w = 10 + 1 + 1 + 4 * 3 * x + x + 1 + 4 * x @@ -116,12 +320,25 @@ fn launch_interface(w: u16, h: u16, filename: String) { new_term: new_termios, cursor: 0, seek: 0, - buf: initial_buf +// screen: &mut std::io::stdout(), + screen: &mut AlternateScreen::from(std::io::stdout().into_raw_mode().unwrap()), + view: &mut CachingFileView::new(filename).unwrap(), + state: Mode::Edit, + status: "".to_string(), + input_buf: Vec::with_capacity(0), + sub_elem: 0, + edits: Edits::new(), + edit_views: vec![ + &mut hexmode + ], + current_edit_idx: 0 }; tcsetattr(0, TCSANOW, &state.new_term).unwrap(); + print!("{}", termion::cursor::Hide); interface_loop(&mut state); + print!("{}", termion::cursor::Show); tcsetattr(0, TCSANOW, &state.old_term).unwrap(); }, @@ -130,40 +347,170 @@ fn launch_interface(w: u16, h: u16, filename: String) { } } +enum Mode { + Edit, + ReadAddress +} + fn interface_loop(state: &mut Program) { // let buffer = populate_buf(&state.filename, state.cursor, state.width as u64 * state.height as u64); // sw*h over-estimates by about a factor of.. 4? render_interface(state); - let stdin = io::stdin(); + let stdin = std::io::stdin(); // for input in KeyboardInput::from_stdin(&stdin.lock().bytes()) { for input in stdin.events() { - match input.unwrap() { - Event::Key(Key::Up) => { - let amount = state.row_size; // why can't this be inlined? - state.dec_cursor(amount as u64); - } - Event::Key(Key::Down) => { - let amount = state.row_size; - state.inc_cursor(amount as u64); - } - Event::Key(Key::Left) => { - state.dec_cursor(1); - } - Event::Key(Key::Right) => { - state.inc_cursor(1); - } - Event::Key(Key::PageDown) => { - let amount = (state.row_size as u64) * (state.height as u64 - 1); - state.inc_cursor(amount); - } - Event::Key(Key::PageUp) => { - let amount = (state.row_size as u64) * (state.height as u64 - 1); - state.dec_cursor(amount); + match state.state { + Mode::Edit => { + match input.unwrap() { + Event::Key(Key::Char('\n')) => { + state.state = Mode::ReadAddress; + } + Event::Key(Key::Up) => { + let amount = state.row_size; // why can't this be inlined? + state.dec_cursor(amount as u64); + } + Event::Key(Key::Down) => { + let amount = state.row_size; + state.inc_cursor(amount as u64); + } + Event::Key(Key::Left) => { + state.dec_cursor(1); + } + Event::Key(Key::Right) => { + state.inc_cursor(1); + } + Event::Key(Key::PageDown) => { + let amount = state.view_byte_width() * state.lines_to_draw(); + if state.view.size() - state.cursor < amount { + state.cursor = state.view.size() - 1; + state.seek = std::cmp::min( + state.view.size() - (state.view.size() % state.view_byte_width()), + state.seek + amount + ) + } else { + state.cursor += amount; + state.seek += amount; + } + } + Event::Key(Key::PageUp) => { + let amount = state.view_byte_width() * state.lines_to_draw(); + if state.cursor < amount { + state.cursor = 0; + state.seek = 0; + } else if state.seek < amount { + state.cursor -= amount; + state.seek = 0; + } else { + state.cursor -= amount; + state.seek -= amount; + } + } + Event::Key(Key::Char('q')) => { + break; + } + Event::Key(Key::Ctrl(x)) => { + state.status = format!("ctrl {}", x); + } + Event::Key(Key::Char('\t')) => { + // switch to next edit mode + } + // would prefer shift+t + Event::Key(Key::Ctrl('\t')) => { + // switch to previous edit mode + } + Event::Unsupported(vec) => { + if vec.len() == 3 && vec[0] == 0x1b && vec[1] == 0x4f { + match vec[2] { + 0x41 => { + state.status = "ctrl up".to_owned(); + state.edit_views[state.current_edit_idx].inc_sub_elem(1); + /* up */ + } + 0x42 => { + state.status = "ctrl down".to_owned(); + /* down */ + } + 0x43 => { + state.status = "ctrl right".to_owned(); + /* right */ + } + 0x44 => { + state.status = "ctrl left".to_owned(); + /* left */ + } + _ => { + state.status = format!("ctrl? {:?}", vec); + } + } + } else { + // thought shift+arrow would end up here, but.. nope + state.status = format!("ctrl? {:?}", vec); + } + } + Event::Key(Key::Char(x)) => { + // TODO: how does this work on non-US keyboards? keyboards without a-fA-F? + if (x >= '0' && x <= '9') || (x >= 'a' && x <= 'f') || (x >= 'A' && x <= 'F') { + state.edits.record(state.cursor, state.sub_elem, x as u8); + // edit the nibble under the cursor + } + } + Event::Key(Key::Backspace) => { + state.edits.remove(state.cursor, state.sub_elem); + state.dec_cursor(1); + } + _ => { } + } } - u => { - println!("Got {:?}", u); - break; + Mode::ReadAddress => { + match input.unwrap() { + Event::Key(Key::Char('\n')) => { + let buf_str = state.input_buf.iter().cloned().collect::<String>(); + if buf_str.len() == 0 { + state.input_buf = Vec::with_capacity(0); + state.state = Mode::Edit; + state.status = " ".to_string(); + continue; + } + let addr_str = u64::from_str_radix(&buf_str, 16); + match addr_str { + Ok(addr) => { + if addr >= 0 && addr < state.view.size() { + state.seek_to(addr); + state.input_buf = Vec::with_capacity(0); + state.state = Mode::Edit; + state.status = " ".to_string(); + } else { + state.status = format!("Address out of bounds: 0x{:x}", addr); + state.input_buf = Vec::with_capacity(0); + state.state = Mode::Edit; + } + } + Err(s) => { + state.status = format!("Unable to parse address '{}'", buf_str); + state.input_buf = Vec::with_capacity(0); + state.state = Mode::Edit; + } + } + } + Event::Key(Key::Esc) => { + state.input_buf = Vec::with_capacity(0); + state.state = Mode::Edit; + } + Event::Key(Key::Backspace) => { + if state.input_buf.len() > 0 { + state.input_buf.pop(); + } + } + Event::Key(Key::Char(x)) => { + if (x >= '0' && x <= '9') || (x >= 'a' && x <= 'f') || (x >= 'A' && x <= 'F') { + if state.input_buf.len() < modal_width - 6 { + state.input_buf.push(x); + } + } + } + _ => { } + } } } render_interface(state); @@ -218,22 +565,38 @@ fn ascii_or_dot(c: u8) -> u8 { } } -fn render_interface(state: &Program) { - println!("Dimensions: {}x{} Seek: {}, Cursor: {} - file: {}, {} bytes", state.width, state.height, state.seek, state.cursor, state.filename, state.filelen); +fn render_interface(state: &mut Program) { +// println!("{}", clear::All); + write!(state.screen, "{}{}", cursor::Goto(1, 1), clear::CurrentLine).unwrap(); + let bufsz = state.lines_to_draw() * state.view_byte_width(); + writeln!(state.screen, "Dimensions: {}x{} Seek: 0x{:x}, Cursor: 0x{:x} - file: {}, 0x{:x} bytes", state.width, state.height, state.seek, state.cursor, state.filename, state.view.size()).unwrap(); + if state.status.len() > 0 { + writeln!(state.screen, "{}{} {}", cursor::Goto(1, 2), clear::CurrentLine, state.status).unwrap(); + state.status = "".to_string(); + } +// writeln!(state.screen, "Read {} bytes at {} ", bufsz, state.seek).unwrap(); //let addr_width = 8; // let ascii = bytes_width * cols; - let buffer = &state.buf; + let buffer = state.view.get_bytes(state.seek, bufsz); // &state.buf; - let start = (state.cursor - state.seek) as usize; - let mut idx: usize = start; + // buffer is one screen of bytes, starting at seek. + + let start = (state.seek) as usize; + let mut idx: usize = 0; let col_width = 4; - for i in 1..(state.height-1) { + + let mut iface = String::new(); + + // +1 here is a total hack to intermix typical line rendering.. + let width = state.bytes_per_line(); + + for i in 0..state.lines_to_draw() { let mut hex_line = String::new(); let mut ascii_line = String::new(); - for _ in 0..(state.row_size / 4) { + for _ in 0..(state.view_byte_width() / col_width) { for _ in 0..col_width { - if idx < buffer.len() { + if idx < buffer.len() && ((idx + start) as u64) < state.view.size() { let chr = buffer[idx]; if idx as u64 + state.seek == state.cursor { write!(&mut hex_line, "\x1b[33m").unwrap(); @@ -254,31 +617,36 @@ fn render_interface(state: &Program) { write!(&mut hex_line, " ").unwrap(); } - let lineaddr = start as u64 + ((i as u64) - 1) * (state.row_size as u64); - let addr = if (lineaddr as usize) < buffer.len() { + let lineaddr = start as u64 + i * state.view_byte_width(); + let addr = if lineaddr < state.view.size() { format!("0x{:08x}:", lineaddr) } else { " ".to_string() }; - println!("{} {} {}", addr, hex_line, ascii_line); + write!(iface, "{} {} {}", addr, hex_line, ascii_line).unwrap(); + for view in state.edit_views.iter() { + let slice_start = (width * i); + let slice_end = slice_start + width; + write!(iface, "\n{}", view.render_bytes(start as u64 + slice_start, buffer[(slice_start as usize)..(slice_end as usize)].iter())); + } + if i < state.lines_to_draw() - 1 { + write!(iface, "\n").unwrap(); + } } -} - -fn populate_buf(arg: &String, seek: u64, count: u64) -> Vec<u8> { - match fs::File::open(&arg) { - Ok(mut fd) => { - /*..*/ - fd.seek(SeekFrom::Start(seek)).unwrap(); - fd - .bytes() - .take(count as usize) - .map(|r| r.unwrap()) // lazy - .collect() - }, - Err(_) => - { - println!("Failed to open {}", arg); - panic!(); + let height = state.view_interface_height() as u16; + write!(state.screen, "{}{}", cursor::Goto(1, height + 1), iface).unwrap(); + match state.state { + Mode::ReadAddress => { + let xmid = state.width as u16 / 2; + let ymid = state.height as u16 / 2; + write!(state.screen, "{}{:-^2$}", cursor::Goto(xmid-12, ymid-2), "", modal_width); + write!(state.screen, "{}|{: ^2$}|", cursor::Goto(xmid-12, ymid-1), "Enter new addresss", modal_width - 2); + write!(state.screen, "{}| >{:_^2$} |", cursor::Goto(xmid-12, ymid-0), "", modal_width - 6); + write!(state.screen, "{}|{: ^2$}|", cursor::Goto(xmid-12, ymid+1), "", modal_width - 2); + write!(state.screen, "{}{:-^2$}", cursor::Goto(xmid-12, ymid+2), "", modal_width); + write!(state.screen, "{}{}", cursor::Goto(xmid-9, ymid-0), state.input_buf.iter().cloned().collect::<String>()); } + _ => {} } + state.screen.flush().unwrap(); } |