2018-03-11 14:53:08 -07:00
|
|
|
use std::collections::HashMap;
|
2018-03-24 15:14:24 -07:00
|
|
|
use colored::*;
|
2018-03-24 13:20:10 -07:00
|
|
|
use std::fmt::Write;
|
2017-09-08 03:47:04 -07:00
|
|
|
|
2017-01-23 19:11:50 -08:00
|
|
|
pub struct LLVMCodeString(pub String);
|
|
|
|
|
2017-09-17 18:57:47 -07:00
|
|
|
#[derive(Debug, Default, Serialize, Deserialize)]
|
2017-08-30 19:09:22 -07:00
|
|
|
pub struct EvalOptions {
|
2018-03-20 20:29:07 -07:00
|
|
|
pub debug: DebugOptions,
|
|
|
|
pub execution_method: ExecutionMethod
|
|
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
|
|
pub enum ExecutionMethod {
|
|
|
|
Compile,
|
|
|
|
Interpret,
|
|
|
|
}
|
|
|
|
impl Default for ExecutionMethod {
|
|
|
|
fn default() -> ExecutionMethod {
|
|
|
|
ExecutionMethod::Interpret
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, Default, Serialize, Deserialize)]
|
|
|
|
pub struct DebugOptions {
|
|
|
|
pub tokens: bool,
|
|
|
|
pub parse_tree: bool,
|
|
|
|
pub ast: bool,
|
|
|
|
pub type_checking: bool,
|
|
|
|
pub symbol_table: bool,
|
|
|
|
pub evaluation: bool,
|
|
|
|
pub llvm_ir: bool,
|
2017-08-30 19:09:22 -07:00
|
|
|
}
|
|
|
|
|
2017-08-31 20:59:43 -07:00
|
|
|
#[derive(Debug, Default)]
|
2018-03-07 22:07:13 -08:00
|
|
|
pub struct LanguageOutput {
|
2017-08-31 20:59:43 -07:00
|
|
|
output: String,
|
2018-03-09 00:50:06 -08:00
|
|
|
artifacts: Vec<TraceArtifact>,
|
2018-03-11 12:56:51 -07:00
|
|
|
pub failed: bool,
|
2017-08-31 20:59:43 -07:00
|
|
|
}
|
|
|
|
|
2018-03-07 22:07:13 -08:00
|
|
|
impl LanguageOutput {
|
2017-08-31 20:59:43 -07:00
|
|
|
pub fn add_artifact(&mut self, artifact: TraceArtifact) {
|
|
|
|
self.artifacts.push(artifact);
|
|
|
|
}
|
|
|
|
pub fn add_output(&mut self, output: String) {
|
|
|
|
self.output = output;
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn to_string(&self) -> String {
|
|
|
|
let mut acc = String::new();
|
|
|
|
for line in self.artifacts.iter() {
|
2017-09-08 03:47:04 -07:00
|
|
|
acc.push_str(&line.debug_output.color(line.text_color).to_string());
|
|
|
|
acc.push_str(&"\n");
|
2017-08-31 20:59:43 -07:00
|
|
|
}
|
|
|
|
acc.push_str(&self.output);
|
|
|
|
acc
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn print_to_screen(&self) {
|
|
|
|
for line in self.artifacts.iter() {
|
2017-10-12 10:43:54 -07:00
|
|
|
let color = line.text_color;
|
|
|
|
let stage = line.stage_name.color(color).to_string();
|
|
|
|
let output = line.debug_output.color(color).to_string();
|
|
|
|
println!("{}: {}", stage, output);
|
2017-08-31 20:59:43 -07:00
|
|
|
}
|
|
|
|
println!("{}", self.output);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-11 14:53:08 -07:00
|
|
|
#[derive(Debug, Default)]
|
|
|
|
pub struct UnfinishedComputation {
|
|
|
|
artifacts: HashMap<String, TraceArtifact>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct FinishedComputation {
|
|
|
|
artifacts: HashMap<String, TraceArtifact>,
|
|
|
|
text_output: Result<String, String>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl UnfinishedComputation {
|
|
|
|
pub fn add_artifact(&mut self, artifact: TraceArtifact) {
|
|
|
|
self.artifacts.insert(artifact.stage_name.clone(), artifact);
|
|
|
|
}
|
|
|
|
pub fn output(self, output: Result<String, String>) -> FinishedComputation {
|
|
|
|
FinishedComputation {
|
|
|
|
artifacts: self.artifacts,
|
|
|
|
text_output: output
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:57:54 -07:00
|
|
|
impl FinishedComputation {
|
2018-03-20 20:29:07 -07:00
|
|
|
pub fn to_repl(&self) -> String {
|
2018-04-24 23:11:04 -07:00
|
|
|
let mut buf = String::new();
|
|
|
|
for stage in ["tokens", "parse_trace", "ast", "symbol_table", "type_check"].iter() {
|
|
|
|
if let Some(artifact) = self.artifacts.get(&stage.to_string()) {
|
|
|
|
let color = artifact.text_color;
|
|
|
|
let stage = stage.color(color).bold();
|
|
|
|
let output = artifact.debug_output.color(color);
|
|
|
|
write!(&mut buf, "{}: {}\n", stage, output).unwrap();
|
2018-03-24 13:20:10 -07:00
|
|
|
}
|
2018-03-19 22:57:54 -07:00
|
|
|
}
|
2018-04-24 23:11:04 -07:00
|
|
|
match self.text_output {
|
|
|
|
Ok(ref output) => write!(&mut buf, "{}", output).unwrap(),
|
|
|
|
Err(ref err) => write!(&mut buf, "{} {}", "Error: ".red().bold(), err).unwrap(),
|
|
|
|
}
|
|
|
|
buf
|
2018-03-19 22:57:54 -07:00
|
|
|
}
|
2018-03-20 20:29:07 -07:00
|
|
|
pub fn to_noninteractive(&self) -> Option<String> {
|
|
|
|
match self.text_output {
|
2018-03-27 00:50:31 -07:00
|
|
|
Ok(_) => {
|
|
|
|
let mut buf = String::new();
|
|
|
|
for stage in ["tokens", "parse_trace", "ast", "symbol_table", "type_check"].iter() {
|
|
|
|
if let Some(artifact) = self.artifacts.get(&stage.to_string()) {
|
|
|
|
let color = artifact.text_color;
|
|
|
|
let stage = stage.color(color).bold();
|
|
|
|
let output = artifact.debug_output.color(color);
|
|
|
|
write!(&mut buf, "{}: {}\n", stage, output).unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if buf == "" { None } else { Some(buf) }
|
|
|
|
},
|
2018-03-22 03:37:48 -07:00
|
|
|
Err(ref s) => Some(format!("{} {}", "Error: ".red().bold(), s))
|
2018-03-20 20:29:07 -07:00
|
|
|
}
|
|
|
|
}
|
2018-03-19 22:57:54 -07:00
|
|
|
}
|
|
|
|
|
2017-08-31 20:59:43 -07:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct TraceArtifact {
|
|
|
|
stage_name: String,
|
|
|
|
debug_output: String,
|
2017-09-08 03:47:04 -07:00
|
|
|
text_color: &'static str,
|
2017-08-31 20:59:43 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
impl TraceArtifact {
|
|
|
|
pub fn new(stage: &str, debug: String) -> TraceArtifact {
|
2017-09-16 14:29:22 -07:00
|
|
|
let color = match stage {
|
2017-10-08 22:17:29 -07:00
|
|
|
"parse_trace" | "ast" => "red",
|
2017-09-16 14:29:22 -07:00
|
|
|
"tokens" => "green",
|
2017-10-01 00:48:08 -07:00
|
|
|
"type_check" => "magenta",
|
2017-09-16 14:29:22 -07:00
|
|
|
_ => "blue",
|
|
|
|
};
|
|
|
|
TraceArtifact { stage_name: stage.to_string(), debug_output: debug, text_color: color}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn new_parse_trace(trace: Vec<String>) -> TraceArtifact {
|
2017-09-16 15:05:11 -07:00
|
|
|
let mut output = String::new();
|
|
|
|
|
|
|
|
for t in trace {
|
|
|
|
output.push_str(&t);
|
|
|
|
output.push_str("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
TraceArtifact { stage_name: "parse_trace".to_string(), debug_output: output, text_color: "red"}
|
2017-08-31 20:59:43 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-30 19:09:22 -07:00
|
|
|
pub trait ProgrammingLanguageInterface {
|
2018-03-20 20:29:07 -07:00
|
|
|
/* old */
|
2018-03-24 19:02:16 -07:00
|
|
|
fn evaluate_in_repl(&mut self, _: &str, _: &EvalOptions) -> LanguageOutput {
|
2018-03-19 22:57:54 -07:00
|
|
|
LanguageOutput { output: format!("Defunct"), artifacts: vec![], failed: false }
|
|
|
|
}
|
2018-03-20 20:29:07 -07:00
|
|
|
/* old */
|
|
|
|
|
2018-04-29 00:04:31 -07:00
|
|
|
fn execute_pipeline(&mut self, _input: &str, _eval_options: &EvalOptions) -> FinishedComputation {
|
|
|
|
FinishedComputation { artifacts: HashMap::new(), text_output: Err(format!("Execution pipeline not done")) }
|
|
|
|
}
|
|
|
|
|
2018-03-24 23:28:00 -07:00
|
|
|
fn execute(&mut self, _input: &str, _eval_options: &EvalOptions) -> FinishedComputation {
|
2018-03-19 22:57:54 -07:00
|
|
|
FinishedComputation { artifacts: HashMap::new(), text_output: Err(format!("REPL evaluation not implemented")) }
|
|
|
|
}
|
2017-08-30 19:09:22 -07:00
|
|
|
fn get_language_name(&self) -> String;
|
2017-10-02 23:07:05 -07:00
|
|
|
fn get_source_file_suffix(&self) -> String;
|
2018-04-23 21:33:15 -07:00
|
|
|
fn handle_custom_interpreter_directives(&mut self, commands: &Vec<&str>) -> Option<String> {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
fn custom_interpreter_directives_help(&self) -> String {
|
|
|
|
format!(">> No custom interpreter directives specified <<")
|
|
|
|
}
|
2017-08-30 19:09:22 -07:00
|
|
|
}
|
2018-04-29 00:04:31 -07:00
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! pass_chain {
|
|
|
|
($($pass:path), *) => {
|
|
|
|
|begin| pass_chain_helper! { begin $(, $pass)* }
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! pass_chain_helper {
|
|
|
|
($e:expr, $next:path $(, $rest:path)*) => {
|
|
|
|
pass_chain_helper! {
|
|
|
|
{
|
|
|
|
let output = $next({
|
|
|
|
let input = $e;
|
|
|
|
println!("About to run: {}", stringify!($next));
|
|
|
|
input
|
|
|
|
});
|
|
|
|
println!("Finished running {}", stringify!($next));
|
|
|
|
output.unwrap()
|
|
|
|
}
|
|
|
|
$(, $rest)*
|
|
|
|
}
|
|
|
|
};
|
|
|
|
// Done
|
|
|
|
($e:expr) => { $e };
|
|
|
|
}
|