summaryrefslogtreecommitdiff
path: root/main.rs
diff options
context:
space:
mode:
Diffstat (limited to 'main.rs')
-rw-r--r--main.rs536
1 files changed, 452 insertions, 84 deletions
diff --git a/main.rs b/main.rs
index 1b935c8..80a2a1e 100644
--- a/main.rs
+++ b/main.rs
@@ -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();
}