schala/src/main.rs

352 lines
10 KiB
Rust
Raw Normal View History

2016-01-17 00:16:01 -08:00
#![feature(advanced_slice_patterns, slice_patterns, box_patterns)]
#![feature(plugin)]
#![plugin(rocket_codegen)]
2016-12-28 15:56:02 -08:00
extern crate getopts;
extern crate linefeed;
2017-09-18 19:09:27 -07:00
extern crate itertools;
2017-09-07 19:38:22 -07:00
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate maplit;
2017-09-17 18:57:47 -07:00
#[macro_use]
extern crate serde_derive;
extern crate serde_json;
extern crate rocket;
2017-09-19 20:29:08 -07:00
extern crate rocket_contrib;
2015-08-14 17:07:02 -07:00
use std::path::Path;
use std::fs::File;
2017-10-02 22:58:03 -07:00
use std::io::{Read, Write};
use std::process::exit;
use std::default::Default;
2015-07-22 03:02:55 -07:00
2017-08-29 04:15:31 -07:00
mod schala_lang;
mod maaru_lang;
2017-08-29 00:28:19 -07:00
mod robo_lang;
2017-01-21 01:49:45 -08:00
mod language;
2017-08-31 16:26:55 -07:00
use language::{ProgrammingLanguageInterface, EvalOptions, LLVMCodeString};
2017-01-21 01:49:45 -08:00
mod webapp;
2016-12-26 23:29:24 -08:00
mod llvm_wrap;
2016-02-11 10:49:45 -08:00
2015-07-16 01:40:37 -07:00
fn main() {
2017-09-01 02:08:26 -07:00
let languages: Vec<Box<ProgrammingLanguageInterface>> =
vec![
Box::new(schala_lang::Schala::new()),
Box::new(maaru_lang::Maaru::new()),
Box::new(robo_lang::Robo::new()),
];
2017-10-02 22:58:03 -07:00
let option_matches = program_options().parse(std::env::args()).unwrap_or_else(|e| {
println!("{:?}", e);
exit(1);
2017-10-02 22:58:03 -07:00
});
2017-09-01 02:08:26 -07:00
if option_matches.opt_present("list-languages") {
for lang in languages {
println!("{}", lang.get_language_name());
2017-02-02 01:04:15 -08:00
}
exit(1);
2017-09-01 02:08:26 -07:00
}
2017-10-02 22:58:03 -07:00
if option_matches.opt_present("help") {
2017-09-01 02:08:26 -07:00
println!("{}", program_options().usage("Schala metainterpreter"));
exit(0);
2017-09-01 02:08:26 -07:00
}
2017-07-23 02:12:05 -07:00
2017-10-02 22:58:03 -07:00
if option_matches.opt_present("webapp") {
webapp::web_main();
exit(0);
}
2017-09-01 02:08:26 -07:00
let language_names: Vec<String> = languages.iter().map(|lang| {lang.get_language_name()}).collect();
let initial_index: usize =
2017-10-02 22:58:03 -07:00
option_matches.opt_str("lang")
2017-09-01 02:08:26 -07:00
.and_then(|lang| { language_names.iter().position(|x| { *x == lang }) })
.unwrap_or(0);
2017-08-31 16:26:55 -07:00
2017-09-01 02:08:26 -07:00
let mut options = EvalOptions::default();
2017-10-02 22:58:03 -07:00
options.compile = match option_matches.opt_str("eval-style") {
Some(ref s) if s == "compile" => true,
_ => false
};
2016-12-28 15:56:02 -08:00
2017-09-01 02:08:26 -07:00
match option_matches.free[..] {
[] | [_] => {
let mut repl = Repl::new(languages, initial_index);
2017-10-02 22:58:03 -07:00
repl.options.show_llvm_ir = true; //TODO make this be configurable
2017-09-01 02:08:26 -07:00
repl.run();
}
[_, ref filename, _..] => {
2017-10-02 22:58:03 -07:00
run_noninteractive(filename, options);
2017-09-01 02:08:26 -07:00
}
};
2016-03-03 22:18:16 -08:00
}
2016-01-24 22:25:12 -08:00
2017-10-02 22:58:03 -07:00
fn run_noninteractive(filename: &str, options: EvalOptions) {
let mut language = maaru_lang::Maaru::new();
2017-08-30 23:36:13 -07:00
let mut source_file = File::open(&Path::new(filename)).unwrap();
let mut buffer = String::new();
source_file.read_to_string(&mut buffer).unwrap();
2017-10-02 22:58:03 -07:00
if options.compile {
2017-08-31 19:15:32 -07:00
if !language.can_compile() {
2017-10-02 22:58:03 -07:00
panic!("Trying to compile a non-compileable language");
2017-08-31 19:15:32 -07:00
} else {
let llvm_bytecode = language.compile(&buffer);
compilation_sequence(llvm_bytecode, filename);
}
} else {
2017-09-01 02:08:26 -07:00
let interpretor_output = language.evaluate_in_repl(&buffer, &options);
2017-08-31 20:59:43 -07:00
interpretor_output.print_to_screen();
2017-08-30 23:36:13 -07:00
}
2015-07-16 02:55:03 -07:00
}
2017-01-12 22:43:26 -08:00
type LineReader = linefeed::Reader<linefeed::terminal::DefaultTerminal>;
2017-02-02 00:23:48 -08:00
struct Repl {
2017-09-01 02:08:26 -07:00
options: EvalOptions,
languages: Vec<Box<ProgrammingLanguageInterface>>,
current_language_index: usize,
interpreter_directive_sigil: char,
reader: LineReader,
2015-12-20 13:20:24 -08:00
}
2017-02-02 00:23:48 -08:00
impl Repl {
2017-09-01 02:08:26 -07:00
fn new(languages: Vec<Box<ProgrammingLanguageInterface>>, initial_index: usize) -> Repl {
let mut reader: linefeed::Reader<_> = linefeed::Reader::new("Metainterpreter").unwrap();
reader.set_prompt(">> ");
let i = if initial_index < languages.len() { initial_index } else { 0 };
2017-09-17 18:57:47 -07:00
2017-09-01 02:08:26 -07:00
Repl {
2017-09-17 18:57:47 -07:00
options: Repl::get_options(),
2017-09-01 02:08:26 -07:00
languages: languages,
current_language_index: i,
interpreter_directive_sigil: '.',
reader: reader,
}
2017-09-01 02:08:26 -07:00
}
2017-09-17 18:57:47 -07:00
fn get_options() -> EvalOptions {
File::open(".schala_repl")
.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(".schala_repl")
.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 .schala_repl file {}", err);
}
}
2017-09-01 02:08:26 -07:00
fn run(&mut self) {
use linefeed::ReadResult::*;
println!("MetaInterpreter v 0.05");
println!("Using language: {}", self.languages[self.current_language_index].get_language_name());
loop {
match self.reader.read_line() {
Err(e) => {
println!("Terminal read error: {}", e);
},
Ok(Eof) => {
break;
}
Ok(Input(ref input)) => {
self.reader.add_history(input.clone());
if self.handle_interpreter_directive(input) {
continue;
}
let output = self.input_handler(input);
println!("=> {}", output);
}
2017-09-01 02:08:26 -07:00
_ => (),
}
}
2017-09-01 02:08:26 -07:00
println!("Exiting...");
}
2017-09-01 02:08:26 -07:00
fn input_handler(&mut self, input: &str) -> String {
let ref mut language = self.languages[self.current_language_index];
let interpretor_output = language.evaluate_in_repl(input, &self.options);
interpretor_output.to_string()
}
2017-09-01 02:08:26 -07:00
fn handle_interpreter_directive(&mut self, input: &str) -> bool {
match input.chars().nth(0) {
Some(ch) if ch == self.interpreter_directive_sigil => (),
_ => return false
}
2017-09-01 02:08:26 -07:00
let mut iter = input.chars();
iter.next();
let trimmed_sigil: &str = iter.as_str();
2017-09-01 02:08:26 -07:00
let commands: Vec<&str> = trimmed_sigil
.split_whitespace()
.collect();
2017-09-01 02:08:26 -07:00
let cmd: &str = match commands.get(0).clone() {
None => return true,
Some(s) => s
};
2017-09-01 02:08:26 -07:00
match cmd {
2017-09-17 18:57:47 -07:00
"exit" | "quit" => {
self.save_options();
exit(0)
2017-09-17 18:57:47 -07:00
},
2017-09-01 02:08:26 -07:00
"history" => {
for item in self.reader.history() {
println!("{}", item);
}
},
"help" => {
println!("Commands:");
println!("exit | quit");
println!("lang [show|next|previous]");
println!("set [show|hide] [tokens|parse|eval|llvm]");
}
2017-09-01 02:08:26 -07:00
"lang" => {
match commands.get(1) {
Some(&"show") => {
for (i, lang) in self.languages.iter().enumerate() {
if i == self.current_language_index {
println!("* {}", lang.get_language_name());
} else {
println!("{}", lang.get_language_name());
}
}
},
Some(&"next") => {
self.current_language_index = (self.current_language_index + 1) % self.languages.len();
println!("Switching to {}", self.languages[self.current_language_index].get_language_name());
}
Some(&"prev") | Some(&"previous") => {
self.current_language_index = if self.current_language_index == 0 { self.languages.len() - 1 } else { self.current_language_index - 1 };
println!("Switching to {}", self.languages[self.current_language_index].get_language_name());
},
Some(e) => println!("Bad `lang` argument: {}", e),
None => println!("`lang` - valid arguments `show`, `next`, `prev`|`previous`"),
}
},
"set" => {
let show = match commands.get(1) {
Some(&"show") => true,
Some(&"hide") => false,
Some(e) => {
println!("Bad `set` argument: {}", e);
return true;
}
None => {
println!("`set` - valid arguments `show {{option}}`, `hide {{option}}`");
return true;
}
};
2017-09-01 02:08:26 -07:00
match commands.get(2) {
Some(&"tokens") => self.options.debug_tokens = show,
Some(&"parse") => self.options.debug_parse = show,
Some(&"eval") => {
//let ref mut language = self.languages[self.current_language_index];
//language.set_option("trace_evaluation", show);
},
Some(&"llvm") => self.options.show_llvm_ir = show,
Some(e) => {
println!("Bad `show`/`hide` argument: {}", e);
return true;
}
None => {
println!("`show`/`hide` requires an argument");
return true;
}
2015-12-20 13:20:24 -08:00
}
2017-09-01 02:08:26 -07:00
},
e => println!("Unknown command: {}", e)
2015-12-20 13:20:24 -08:00
}
2017-09-01 02:08:26 -07:00
return true;
}
2015-12-20 13:20:24 -08:00
}
2017-01-21 01:49:45 -08:00
2017-01-23 19:11:50 -08:00
pub fn compilation_sequence(llvm_code: LLVMCodeString, sourcefile: &str) {
use std::process::Command;
let ll_filename = "out.ll";
let obj_filename = "out.o";
let q: Vec<&str> = sourcefile.split('.').collect();
let bin_filename = match &q[..] {
2017-08-29 00:28:19 -07:00
&[name, "maaru"] => name,
2017-01-23 19:11:50 -08:00
_ => panic!("Bad filename {}", sourcefile),
};
let LLVMCodeString(llvm_str) = llvm_code;
println!("Compilation process finished for {}", ll_filename);
File::create(ll_filename)
.and_then(|mut f| f.write_all(llvm_str.as_bytes()))
.expect("Error writing file");
let llc_output = Command::new("llc")
.args(&["-filetype=obj", ll_filename, "-o", obj_filename])
.output()
.expect("Failed to run llc");
if !llc_output.status.success() {
println!("{}", String::from_utf8_lossy(&llc_output.stderr));
}
let gcc_output = Command::new("gcc")
.args(&["-o", bin_filename, &obj_filename])
.output()
.expect("failed to run gcc");
if !gcc_output.status.success() {
println!("{}", String::from_utf8_lossy(&gcc_output.stdout));
println!("{}", String::from_utf8_lossy(&gcc_output.stderr));
}
for filename in [obj_filename].iter() {
Command::new("rm")
.arg(filename)
.output()
.expect(&format!("failed to run rm {}", filename));
}
}
2017-09-01 02:08:26 -07:00
fn program_options() -> getopts::Options {
let mut options = getopts::Options::new();
2017-10-02 22:58:03 -07:00
options.optopt("s",
"eval-style",
"Specify whether to compile (if supported) or interpret the language. If not specified, the default is language-specific",
"[compile|interpret]"
);
2017-09-01 02:08:26 -07:00
options.optflag("",
"list-languages",
"Show a list of all supported languages");
options.optopt("l",
"lang",
"Start up REPL in a language",
"LANGUAGE");
options.optflag("h",
"help",
"Show help text");
options.optflag("w",
"webapp",
"Start up web interpreter");
2017-09-01 02:08:26 -07:00
options
}