schala/schala-repl/src/language.rs

169 lines
4.4 KiB
Rust
Raw Normal View History

2017-09-08 03:47:04 -07:00
extern crate colored;
use std::collections::HashMap;
2017-09-08 03:47:04 -07:00
use self::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,
artifacts: Vec<TraceArtifact>,
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);
}
}
#[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-03-19 22:57:54 -07:00
match self.text_output {
2018-03-24 13:20:10 -07:00
Ok(ref output) => {
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);
}
}
write!(&mut buf, "{}", output);
buf
}
2018-03-22 03:37:48 -07:00
Err(ref s) => format!("{} {}", "Error: ".red().bold(), s)
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 {
Ok(ref s) => None,
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-19 22:57:54 -07:00
fn evaluate_in_repl(&mut self, input: &str, eval_options: &EvalOptions) -> LanguageOutput {
LanguageOutput { output: format!("Defunct"), artifacts: vec![], failed: false }
}
fn evaluate_noninteractive(&mut self, input: &str, eval_options: &EvalOptions) -> LanguageOutput {
self.evaluate_in_repl(input, eval_options)
}
2018-03-20 20:29:07 -07:00
/* old */
2018-03-19 22:57:54 -07:00
2018-03-20 20:29:07 -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;
2017-08-30 19:09:22 -07:00
}