use std::fmt::Write as FmtWrite; use std::io::{Read, Write}; use std::fs::File; use std::sync::Arc; use colored::*; use itertools::Itertools; use crate::language::{ProgrammingLanguageInterface, EvalOptions, PassDebugOptionsDescriptor}; mod command_tree; use self::command_tree::CommandTree; const HISTORY_SAVE_FILE: &'static str = ".schala_history"; const OPTIONS_SAVE_FILE: &'static str = ".schala_repl"; pub struct NewRepl { interpreter_directive_sigil: char, line_reader: ::linefeed::interface::Interface<::linefeed::terminal::DefaultTerminal>, language_states: Vec>, } impl NewRepl { pub fn new(languages: Vec>) -> NewRepl { use linefeed::Interface; let line_reader = Interface::new("schala-repl").unwrap(); let interpreter_directive_sigil = ':'; NewRepl { interpreter_directive_sigil, line_reader, language_states } } pub fn run_repl(&mut self) { self.line_reader.load_history(HISTORY_SAVE_FILE).unwrap_or(()); println!("Schala MetaInterpreter version {}", crate::VERSION_STRING); println!("Type {}help for help with the REPL", self.interpreter_directive_sigil); self.handle_repl_loop(); self.line_reader.save_history(HISTORY_SAVE_FILE).unwrap_or(()); self.save_options(); println!("Exiting..."); } fn handle_repl_loop(&mut self) { use linefeed::ReadResult::*; loop { self.update_line_reader(); match self.line_reader.read_line() { Err(e) => { println!("readline IO Error: {}", e); break; }, Ok(Eof) | Ok(Signal(_)) => break, Ok(Input(ref input)) => { self.line_reader.add_history_unique(input.to_string()); let output = match input.chars().nth(0) { Some(ch) if ch == self.interpreter_directive_sigil => self.handle_interpreter_directive(input), _ => Some(self.handle_input(input)), }; if let Some(o) = output { println!("=> {}", o); } } } } } fn update_line_reader(&mut self) { let tab_complete_handler = TabCompleteHandler::new(self.interpreter_directive_sigil, self.get_directives()); self.line_reader.set_completer(Arc::new(tab_complete_handler)); let prompt_str = format!(" >> "); self.line_reader.set_prompt(&prompt_str).unwrap(); } fn save_options(&self) { /* let ref options = self.options; let read = File::create(OPTIONS_SAVE_FILE) .and_then(|mut file| { let buf = ::serde_json::to_string(options).unwrap(); file.write_all(buf.as_bytes()) }); if let Err(err) = read { println!("Error saving {} file {}", OPTIONS_SAVE_FILE, err); } */ } fn get_directives(&self) -> CommandTree { CommandTree::Top(vec![]) } fn handle_interpreter_directive(&mut self, input: &str) -> Option { None } fn handle_input(&mut self, input: &str) -> String { format!("") } } /* --------------------------------------------- */ pub struct Repl { options: EvalOptions, languages: Vec>, current_language_index: usize, interpreter_directive_sigil: char, line_reader: ::linefeed::interface::Interface<::linefeed::terminal::DefaultTerminal>, } impl Repl { pub fn new(languages: Vec>, initial_index: usize) -> Repl { use linefeed::Interface; let current_language_index = if initial_index < languages.len() { initial_index } else { 0 }; let line_reader = Interface::new("schala-repl").unwrap(); Repl { options: Repl::get_options(), languages, current_language_index, interpreter_directive_sigil: ':', line_reader } } fn get_cur_language(&self) -> &ProgrammingLanguageInterface { self.languages[self.current_language_index].as_ref() } fn get_options() -> EvalOptions { File::open(OPTIONS_SAVE_FILE) .and_then(|mut file| { let mut contents = String::new(); file.read_to_string(&mut contents)?; Ok(contents) }) .and_then(|contents| { let options: EvalOptions = ::serde_json::from_str(&contents)?; Ok(options) }).unwrap_or(EvalOptions::default()) } fn save_options(&self) { let ref options = self.options; let read = File::create(OPTIONS_SAVE_FILE) .and_then(|mut file| { let buf = ::serde_json::to_string(options).unwrap(); file.write_all(buf.as_bytes()) }); if let Err(err) = read { println!("Error saving {} file {}", OPTIONS_SAVE_FILE, err); } } pub fn run(&mut self) { use linefeed::ReadResult; println!("Schala MetaInterpreter version {}", crate::VERSION_STRING); println!("Type {}help for help with the REPL", self.interpreter_directive_sigil); self.line_reader.load_history(HISTORY_SAVE_FILE).unwrap_or(()); loop { let language_name = self.get_cur_language().get_language_name(); let directives = self.get_directives(); let tab_complete_handler = TabCompleteHandler::new(self.interpreter_directive_sigil, directives); self.line_reader.set_completer(Arc::new(tab_complete_handler)); let prompt_str = format!("{} >> ", language_name); self.line_reader.set_prompt(&prompt_str).unwrap(); match self.line_reader.read_line() { Err(e) => { println!("Terminal read error: {}", e); }, Ok(ReadResult::Eof) => break, Ok(ReadResult::Signal(_)) => break, Ok(ReadResult::Input(ref input)) => { self.line_reader.add_history_unique(input.to_string()); let output = match input.chars().nth(0) { Some(ch) if ch == self.interpreter_directive_sigil => self.handle_interpreter_directive(input), _ => Some(self.input_handler(input)), }; if let Some(o) = output { println!("=> {}", o); } } } } self.line_reader.save_history(HISTORY_SAVE_FILE).unwrap_or(()); self.save_options(); println!("Exiting..."); } fn input_handler(&mut self, input: &str) -> String { let ref mut language = self.languages[self.current_language_index]; let interpreter_output = language.execute_pipeline(input, &self.options); interpreter_output.to_repl() } fn get_directives(&self) -> CommandTree { let ref passes = self.get_cur_language().get_passes(); let passes_directives: Vec = passes.iter() .map(|pass_descriptor| { let name = &pass_descriptor.name; if pass_descriptor.debug_options.len() == 0 { CommandTree::term(name, None) } else { let children: Vec = pass_descriptor.debug_options.iter() .map(|o| CommandTree::term(o, None)).collect(); CommandTree::NonTerminal { name: name.clone(), children, help_msg: None, function: None, } } }).collect(); CommandTree::Top(vec![ CommandTree::term("exit", Some("exit the REPL")), CommandTree::term("quit", Some("exit the REPL")), CommandTree::term("help", Some("Print this help message")), CommandTree::nonterm("debug", Some("show or hide pass debug info for a given pass, or display the names of all passes, or turn timing on/off"), vec![ CommandTree::term("passes", None), CommandTree::nonterm("show", None, passes_directives.clone()), CommandTree::nonterm("hide", None, passes_directives.clone()), CommandTree::nonterm("timing", None, vec![ CommandTree::term("on", None), CommandTree::term("off", None), ]) ] ), CommandTree::nonterm("lang", Some("switch between languages, or go directly to a langauge by name"), vec![ CommandTree::term("next", None), CommandTree::term("prev", None), CommandTree::nonterm("go", None, vec![]), ] ), CommandTree::term("doc", Some("Get language-specific help for an item")), ]) } fn handle_interpreter_directive(&mut self, input: &str) -> Option { let mut iter = input.chars(); iter.next(); let commands: Vec<&str> = iter .as_str() .split_whitespace() .collect(); let initial_cmd: &str = match commands.get(0).clone() { None => return None, Some(s) => s }; match initial_cmd { "exit" | "quit" => { self.save_options(); ::std::process::exit(0) }, "lang" | "language" => match commands.get(1) { Some(&"show") => { let mut buf = String::new(); for (i, lang) in self.languages.iter().enumerate() { write!(buf, "{}{}\n", if i == self.current_language_index { "* "} else { "" }, lang.get_language_name()).unwrap(); } Some(buf) }, Some(&"go") => match commands.get(2) { None => Some(format!("Must specify a language name")), Some(&desired_name) => { for (i, _) in self.languages.iter().enumerate() { let lang_name = self.languages[i].get_language_name(); if lang_name.to_lowercase() == desired_name.to_lowercase() { self.current_language_index = i; return Some(format!("Switching to {}", self.languages[self.current_language_index].get_language_name())); } } Some(format!("Language {} not found", desired_name)) } }, Some(&"next") | Some(&"n") => { self.current_language_index = (self.current_language_index + 1) % self.languages.len(); Some(format!("Switching to {}", self.languages[self.current_language_index].get_language_name())) }, Some(&"previous") | Some(&"p") | Some(&"prev") => { self.current_language_index = if self.current_language_index == 0 { self.languages.len() - 1 } else { self.current_language_index - 1 }; Some(format!("Switching to {}", self.languages[self.current_language_index].get_language_name())) }, Some(e) => Some(format!("Bad `lang(uage)` argument: {}", e)), None => Some(format!("Valid arguments for `lang(uage)` are `show`, `next`|`n`, `previous`|`prev`|`n`")) }, "help" => { let mut buf = String::new(); let ref lang = self.languages[self.current_language_index]; let directives = match self.get_directives() { CommandTree::Top(children) => children, _ => panic!("Top-level CommandTree not Top") }; writeln!(buf, "MetaInterpreter options").unwrap(); writeln!(buf, "-----------------------").unwrap(); for directive in directives { let trailer = " "; writeln!(buf, "{}{}- {}", directive.get_cmd(), trailer, directive.get_help()).unwrap(); } writeln!(buf, "").unwrap(); writeln!(buf, "Language-specific help for {}", lang.get_language_name()).unwrap(); writeln!(buf, "-----------------------").unwrap(); writeln!(buf, "{}", lang.custom_interpreter_directives_help()).unwrap(); Some(buf) }, "debug" => self.handle_debug(commands), "doc" => self.languages[self.current_language_index] .get_doc(&commands) .or(Some(format!("No docs implemented"))), e => { self.languages[self.current_language_index] .handle_custom_interpreter_directives(&commands) .or(Some(format!("Unknown command: {}", e))) } } } fn handle_debug(&mut self, commands: Vec<&str>) -> Option { let passes = self.get_cur_language().get_passes(); match commands.get(1) { Some(&"timing") => match commands.get(2) { Some(&"on") => { self.options.debug_timing = true; None } Some(&"off") => { self.options.debug_timing = false; None } _ => return Some(format!(r#"Argument to "timing" must be "on" or "off""#)), }, Some(&"passes") => Some( passes.into_iter() .map(|desc| { if self.options.debug_passes.contains_key(&desc.name) { let color = "green"; format!("*{}", desc.name.color(color)) } else { desc.name } }) .intersperse(format!(" -> ")) .collect()), b @ Some(&"show") | b @ Some(&"hide") => { let show = b == Some(&"show"); let debug_pass: String = match commands.get(2) { Some(s) => s.to_string(), None => return Some(format!("Must specify a stage to debug")), }; let pass_opt = commands.get(3); if let Some(desc) = passes.iter().find(|desc| desc.name == debug_pass) { let mut opts = vec![]; if let Some(opt) = pass_opt { opts.push(opt.to_string()); } let msg = format!("{} debug for pass {}", if show { "Enabling" } else { "Disabling" }, debug_pass); if show { self.options.debug_passes.insert(desc.name.clone(), PassDebugOptionsDescriptor { opts }); } else { self.options.debug_passes.remove(&desc.name); } Some(msg) } else { Some(format!("Couldn't find stage: {}", debug_pass)) } }, _ => Some(format!("Unknown debug command")) } } } struct TabCompleteHandler { sigil: char, top_level_commands: CommandTree, } use linefeed::complete::{Completion, Completer}; use linefeed::terminal::Terminal; impl TabCompleteHandler { fn new(sigil: char, top_level_commands: CommandTree) -> TabCompleteHandler { TabCompleteHandler { top_level_commands, sigil, } } } impl Completer for TabCompleteHandler { fn complete(&self, word: &str, prompter: &::linefeed::prompter::Prompter, start: usize, _end: usize) -> Option> { let line = prompter.buffer(); if line.starts_with(&format!("{}", self.sigil)) { let mut words = line[1..(if start == 0 { 1 } else { start })].split_whitespace(); let mut completions = Vec::new(); let mut command_tree: Option<&CommandTree> = Some(&self.top_level_commands); loop { match words.next() { None => { let top = match command_tree { Some(CommandTree::Top(_)) => true, _ => false }; let word = if top { word.get(1..).unwrap() } else { word }; for cmd in command_tree.map(|x| x.get_children()).unwrap_or(vec![]).into_iter() { if cmd.starts_with(word) { completions.push(Completion { completion: format!("{}{}", if top { ":" } else { "" }, cmd), display: Some(cmd.to_string()), suffix: ::linefeed::complete::Suffix::Some(' ') }) } } break; }, Some(s) => { let new_ptr: Option<&CommandTree> = command_tree.and_then(|cm| match cm { CommandTree::Top(children) => children.iter().find(|c| c.get_cmd() == s), CommandTree::NonTerminal { children, .. } => children.iter().find(|c| c.get_cmd() == s), CommandTree::Terminal { .. } => None, }); command_tree = new_ptr; } } } Some(completions) } else { None } } }