Minor cleanup

src/entrypoint/mod.rs

@@ -0,0 +1,13 @@
+
+
+// Select main script for target system
+cfg_if::cfg_if! {
+	if #[cfg(target_family = "unix")] {
+		mod unix;
+		pub use unix::main as main_e;
+	} else {
+		pub fn main_e() -> Result<(), std::io::Error> {
+			unimplemented!("Not yet implemented.");
+		}
+	}
+}

src/entrypoint/unix/mod.rs

@@ -0,0 +1,3 @@
+mod unix;
+mod promptbuffer;
+pub use self::unix::main;

src/entrypoint/unix/promptbuffer.rs

@@ -0,0 +1,213 @@
+use std::collections::VecDeque;
+use std::io::Write;
+use termion::raw::RawTerminal;
+use termion::color;
+use termion::style;
+use crate::parser::substitute_cursor;
+use crate::context::Context;
+
+#[derive(Debug)]
+pub struct PromptBuffer {
+	// History
+	hist: VecDeque<String>,
+	hist_maxlen: usize,
+
+	// Counts from back of hist.
+	// 0 means "not on history",
+	// 1 means "on last item of history"
+	hist_cursor: usize,
+
+	buffer: String,
+	buffer_changed: bool,
+	cursor: usize,
+	last_print_len: usize
+}
+
+impl PromptBuffer {
+	pub fn new(maxlen: usize) -> PromptBuffer {
+		return PromptBuffer {
+			hist: VecDeque::with_capacity(maxlen/2),
+			hist_maxlen: maxlen,
+			hist_cursor: 0,
+			buffer: String::with_capacity(64),
+			buffer_changed: false,
+			cursor: 0,
+			last_print_len: 0,
+		};
+	}
+
+	// Same as write_primpt, but pretends there is no cursor
+	pub fn write_prompt_nocursor(&mut self, stdout: &mut RawTerminal<std::io::Stdout>, context: &Context) -> Result<(), std::io::Error> {
+		// Draw prettyprinted expression
+		let (_, s) = substitute_cursor(&self.get_contents(), self.buffer.chars().count(), context);
+
+		write!(
+			stdout, "\r{}{}==>{}{} {}",
+			style::Bold,
+			color::Fg(color::Blue),
+			color::Fg(color::Reset),
+			style::Reset,
+			s
+		)?;
+
+		// If this string is shorter, clear the remaining old one.
+		if s.chars().count() < self.last_print_len {
+			write!(
+				stdout, "{}{}",
+				" ".repeat(self.last_print_len - s.chars().count()),
+				termion::cursor::Left((self.last_print_len - s.chars().count()) as u16)
+			)?;
+		}
+
+		self.last_print_len = s.chars().count();
+		stdout.flush()?;
+		return Ok(());
+	}
+
+	pub fn write_prompt(&mut self, stdout: &mut RawTerminal<std::io::Stdout>, context: &Context) -> Result<(), std::io::Error> {
+		let l = self.buffer.chars().count();
+		let i = if l == 0 {0} else {l - self.cursor};
+
+		// Draw prettyprinted expression
+		let (display_cursor, s) = substitute_cursor(&self.get_contents(), i, context);
+
+		write!(
+			stdout, "\r{}{}==>{}{} {}",
+			style::Bold,
+			color::Fg(color::Blue),
+			color::Fg(color::Reset),
+			style::Reset,
+			s
+		)?;
+
+		// If this string is shorter, clear the remaining old one.
+		if s.chars().count() < self.last_print_len {
+			write!(
+				stdout, "{}{}",
+				" ".repeat(self.last_print_len - s.chars().count()),
+				termion::cursor::Left((self.last_print_len - s.chars().count()) as u16)
+			)?;
+		}
+
+
+		// Move cursor to correct position
+		if display_cursor != 0 {
+			write!(
+				stdout, "{}",
+				termion::cursor::Left(display_cursor as u16)
+			)?;
+			stdout.flush()?;
+		}
+		self.last_print_len = s.chars().count();
+
+		stdout.flush()?;
+
+		return Ok(());
+	}
+
+	// Prompt methods
+	pub fn get_contents(&self) -> &String {&self.buffer}
+
+	pub fn enter(&mut self) -> String {
+		// Don't trim input string so that linelocations are correct
+		//let s = String::from(self.buffer.trim());
+		let s = self.buffer.clone();
+		self.buffer.clear();
+		self.hist_cursor = 0;
+		self.cursor = 0;
+		self.buffer_changed = false;
+
+		if s != "" { self.hist.push_back(s.clone()); }
+		while self.hist.len() > self.hist_maxlen {
+			self.hist.pop_front();
+		}
+
+		return s;
+	}
+
+	// Buffer manipulation
+	pub fn add_char(&mut self, c: char) {
+		self.buffer_changed = true;
+
+		if self.cursor == 0 {
+			self.buffer.push(c);
+		} else {
+			let l = self.buffer.chars().count();
+			let i = l - self.cursor;
+			self.buffer.insert(i, c);
+		}
+	}
+	pub fn backspace(&mut self) {
+		if self.buffer.len() == 0 { return }
+		self.buffer_changed = true;
+		let l = self.buffer.chars().count();
+
+		if self.cursor == 0 {
+			self.buffer.pop();
+		} else if self.cursor != l {
+			let i = l - self.cursor;
+			self.buffer.remove(i-1);
+
+			if self.cursor >= l {
+				self.cursor = l-1;
+			}
+		}
+	}
+
+	pub fn delete(&mut self) {
+		if self.cursor != 0 {
+			self.cursor -= 1;
+			self.backspace();
+		}
+	}
+
+
+	// Cursor manipulation
+	pub fn cursor_left(&mut self) {
+		let l = self.buffer.chars().count();
+		if self.cursor < l {
+			self.cursor += 1;
+		}
+	}
+
+	pub fn cursor_right(&mut self) {
+		if self.cursor > 0 {
+			self.cursor -= 1;
+		}
+	}
+
+	// History manipulation
+	pub fn hist_up(&mut self) {
+		if self.buffer_changed && self.buffer.len() != 0 { return; }
+
+		if self.hist_cursor < self.hist.len() {
+			if self.buffer.len() != 0 || !self.buffer_changed {
+				self.hist_cursor += 1;
+			}
+
+			self.buffer_changed = false;
+			if self.hist_cursor == 0 {
+				self.buffer.clear();
+			} else {
+				self.buffer = self.hist[self.hist.len() - self.hist_cursor].clone();
+			}
+		}
+	}
+	pub fn hist_down(&mut self) {
+		if self.buffer_changed && self.buffer.len() != 0 { return; }
+
+		if self.hist_cursor > 0 {
+			self.hist_cursor -= 1;
+
+			self.buffer_changed = false;
+			if self.hist_cursor == 0 {
+				self.buffer.clear();
+			} else {
+				self.buffer = self.hist[self.hist.len() - self.hist_cursor].clone();
+			}
+		} else {
+			self.buffer.clear();
+		}
+	}
+
+}

src/entrypoint/unix/unix.rs

@@ -0,0 +1,88 @@
+use std::io::Write;
+use std::io::stdout;
+use std::io::stdin;
+use std::env;
+
+use termion::{
+	event::Key,
+	input::TermRead,
+	raw::IntoRawMode
+};
+
+use super::promptbuffer::PromptBuffer;
+use crate::command;
+use crate::context::Context;
+
+
+#[inline(always)]
+pub fn main() -> Result<(), std::io::Error> {
+	let mut stdout = stdout().into_raw_mode().unwrap();
+	let mut pb: PromptBuffer = PromptBuffer::new(64);
+	let mut context: Context = Context::new();
+
+
+	// Handle command-line arguments
+	let args: Vec<String> = env::args().collect();
+	if args.iter().any(|s| s == "--help") {
+		let t = command::do_command(&String::from("help"), &mut context);
+		t.write(&mut stdout)?;
+		return Ok(());
+	} else if args.iter().any(|s| s == "--version") {
+		write!(stdout, "Daisy v{}\r\n", env!("CARGO_PKG_VERSION"))?;
+		return Ok(());
+	}
+
+	'outer: loop {
+
+		pb.write_prompt(&mut stdout, &context)?;
+
+		let stdin = stdin();
+		for c in stdin.keys() {
+			if let Key::Char(q) = c.as_ref().unwrap() {
+				match q {
+					'\n' => {
+						// Print again without cursor, in case we pressed enter
+						// while inside a substitution
+						pb.write_prompt_nocursor(&mut stdout, &context)?;
+						let in_str = pb.enter();
+						write!(stdout, "\r\n")?;
+						if in_str == "" { break; }
+
+						if in_str.trim() == "quit" {
+							break 'outer;
+						} else {
+							let r = crate::do_string(&in_str, &mut context);
+
+							match r {
+								Ok(t) | Err(t) => {
+									t.write(&mut stdout).unwrap();
+								}
+							}
+						}
+
+						break;
+					},
+					_ => { pb.add_char(*q); }
+				};
+			} else {
+				match c.unwrap() {
+					Key::Backspace => { pb.backspace(); },
+					Key::Delete => { pb.delete(); },
+					Key::Left => { pb.cursor_left(); },
+					Key::Right => { pb.cursor_right(); },
+					Key::Up => { pb.hist_up(); },
+					Key::Down => { pb.hist_down(); },
+
+					Key::Ctrl('d') |
+					Key::Ctrl('c') => { break 'outer; },
+					_ => {}
+				};
+			};
+
+			pb.write_prompt(&mut stdout, &context)?;
+		}
+	}
+
+	write!(stdout, "\r\n")?;
+	return Ok(());
+}