131 lines
4.4 KiB
Rust
131 lines
4.4 KiB
Rust
use crate::backend::{Backend, BackendError};
|
|
use crate::ir::Program as IR;
|
|
use crate::syntax::{Location, ParserError, Statement};
|
|
use codespan_reporting::diagnostic::Diagnostic;
|
|
use codespan_reporting::files::SimpleFiles;
|
|
use codespan_reporting::term::{self, Config};
|
|
use cranelift_jit::JITModule;
|
|
use cranelift_module::ModuleError;
|
|
use pretty::termcolor::{ColorChoice, StandardStream};
|
|
use std::collections::HashMap;
|
|
|
|
pub struct REPL {
|
|
file_database: SimpleFiles<String, String>,
|
|
jitter: Backend<JITModule>,
|
|
variable_binding_sites: HashMap<String, Location>,
|
|
gensym_index: usize,
|
|
console: StandardStream,
|
|
console_config: Config,
|
|
}
|
|
|
|
impl Default for REPL {
|
|
fn default() -> Self {
|
|
let console = StandardStream::stdout(ColorChoice::Auto);
|
|
REPL::new(console, Config::default()).unwrap()
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
#[derive(Debug, thiserror::Error)]
|
|
enum REPLError {
|
|
#[error("Error parsing statement: {0}")]
|
|
Parser(#[from] ParserError),
|
|
#[error("JIT error: {0}")]
|
|
JIT(#[from] BackendError),
|
|
#[error("Internal cranelift error: {0}")]
|
|
Cranelift(#[from] ModuleError),
|
|
#[error(transparent)]
|
|
Reporting(#[from] codespan_reporting::files::Error),
|
|
}
|
|
|
|
impl From<REPLError> for Diagnostic<usize> {
|
|
fn from(value: REPLError) -> Self {
|
|
match value {
|
|
REPLError::Parser(err) => Diagnostic::from(&err),
|
|
REPLError::JIT(err) => Diagnostic::from(err),
|
|
REPLError::Cranelift(err) => Diagnostic::bug().with_message(format!("{}", err)),
|
|
REPLError::Reporting(err) => Diagnostic::bug().with_message(format!("{}", err)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl REPL {
|
|
pub fn new(console: StandardStream, console_config: Config) -> Result<Self, BackendError> {
|
|
Ok(REPL {
|
|
file_database: SimpleFiles::new(),
|
|
jitter: Backend::jit(None)?,
|
|
variable_binding_sites: HashMap::new(),
|
|
gensym_index: 1,
|
|
console,
|
|
console_config,
|
|
})
|
|
}
|
|
|
|
fn emit_diagnostic(
|
|
&mut self,
|
|
diagnostic: Diagnostic<usize>,
|
|
) -> Result<(), codespan_reporting::files::Error> {
|
|
term::emit(
|
|
&mut self.console,
|
|
&self.console_config,
|
|
&self.file_database,
|
|
&diagnostic,
|
|
)
|
|
}
|
|
|
|
pub fn process_input(&mut self, line_no: usize, command: String) {
|
|
if let Err(err) = self.process(line_no, command) {
|
|
if let Err(e) = self.emit_diagnostic(Diagnostic::from(err)) {
|
|
eprintln!(
|
|
"WOAH! System having trouble printing error messages. This is very bad. ({})",
|
|
e
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn process(&mut self, line_no: usize, command: String) -> Result<(), REPLError> {
|
|
let entry = self.file_database.add("entry".to_string(), command);
|
|
let source = self
|
|
.file_database
|
|
.get(entry)
|
|
.expect("entry exists")
|
|
.source();
|
|
let syntax = Statement::parse(entry, source)?;
|
|
|
|
// if this is a variable binding, and we've never defined this variable before,
|
|
// we should tell cranelift about it. this is optimistic; if we fail to compile,
|
|
// then we won't use this definition until someone tries again.
|
|
if let Statement::Binding(_, ref name, _) = syntax {
|
|
if !self.variable_binding_sites.contains_key(name.as_str()) {
|
|
self.jitter.define_string(name)?;
|
|
self.jitter.define_variable(name.clone())?;
|
|
}
|
|
};
|
|
|
|
let (mut errors, mut warnings) = syntax.validate(&mut self.variable_binding_sites);
|
|
let stop = !errors.is_empty();
|
|
let messages = errors
|
|
.drain(..)
|
|
.map(Into::into)
|
|
.chain(warnings.drain(..).map(Into::into));
|
|
|
|
for message in messages {
|
|
self.emit_diagnostic(message)?;
|
|
}
|
|
|
|
if stop {
|
|
return Ok(());
|
|
}
|
|
|
|
let ir = IR::from(syntax.simplify(&mut self.gensym_index));
|
|
let name = format!("line{}", line_no);
|
|
let function_id = self.jitter.compile_function(&name, ir)?;
|
|
self.jitter.module.finalize_definitions()?;
|
|
let compiled_bytes = self.jitter.bytes(function_id);
|
|
let compiled_function = unsafe { std::mem::transmute::<_, fn() -> ()>(compiled_bytes) };
|
|
compiled_function();
|
|
Ok(())
|
|
}
|
|
}
|