feat: connect source compilation and VM execution
Verify databases and deploy Aster VM / verify-and-deploy (push) Successful in 7m56s
Verify databases and deploy Aster VM / verify-and-deploy (push) Successful in 7m56s
This commit is contained in:
@@ -0,0 +1,9 @@
|
||||
# Compiler 源码
|
||||
|
||||
| 文件 | 职责 |
|
||||
| --- | --- |
|
||||
| [lib.rs](lib.rs) | CompileOptions、公开分析/编译入口、AST 原文范围检查与带来源诊断 |
|
||||
| [analysis.rs](analysis.rs) | 模块/函数/表达式/单次交互作用域、局部槽、全局名称、逐引用绑定和初始化检查 |
|
||||
| [codegen.rs](codegen.rs) | AST 到已有指令、嵌套代码模板、EndorCode 验证、显式 VM 装载与临时根释放 |
|
||||
|
||||
节点定义在 frontend/Endor.asdl;这里匹配生成的 AST,不复制节点类型。源码和调用方提供的 AST 都先分析后生成,不执行 AST。修改名称语义、代码布局或所有权时同步 [编译契约](../../../docs/runtime/compiler.md)、[检查](../tests/README.md) 与 [示例](../examples/README.md)。返回 [compiler](../README.md)。
|
||||
@@ -0,0 +1,287 @@
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use endor_core::CodeLayout;
|
||||
use frontend::ast::{AstRoot, Decl, DeclKind, Expr, ExprKind, Function, Spanned, StmtKind};
|
||||
use frontend::{Diagnostic, DiagnosticKind, Span};
|
||||
|
||||
use crate::{CompileOptions, diagnostic};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum ScopeKind {
|
||||
Module,
|
||||
Expression,
|
||||
Interactive,
|
||||
Function,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum NameBinding {
|
||||
Local(usize),
|
||||
Global(usize),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct NameUse {
|
||||
pub name: String,
|
||||
pub span: Span,
|
||||
pub binding: NameBinding,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Scope {
|
||||
pub kind: ScopeKind,
|
||||
pub name: String,
|
||||
pub span: Span,
|
||||
pub layout: CodeLayout,
|
||||
pub references: Vec<NameUse>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SymbolTable {
|
||||
pub root: Scope,
|
||||
/// Top-level function scopes in declaration order. Nested declarations
|
||||
/// are rejected until source closure semantics are implemented.
|
||||
pub functions: Vec<Scope>,
|
||||
}
|
||||
|
||||
fn error(span: Span, message: impl Into<String>) -> Diagnostic {
|
||||
diagnostic(DiagnosticKind::Semantic, span, message)
|
||||
}
|
||||
|
||||
fn definition(declaration: &Decl) -> &Function {
|
||||
let DeclKind::Function(function) = &declaration.kind;
|
||||
function
|
||||
}
|
||||
|
||||
/// Resolve a closed source unit plus explicitly declared host globals.
|
||||
/// Function locals are collected before reading expressions; a later let
|
||||
/// shadows the global for the entire function, but cannot be read early.
|
||||
pub fn analyze(root: &AstRoot, options: &CompileOptions) -> Result<SymbolTable, Diagnostic> {
|
||||
if let AstRoot::Interactive(input) = root
|
||||
&& input.statements.len() != 1
|
||||
{
|
||||
return Err(error(
|
||||
input.span,
|
||||
"interactive input must contain exactly one statement",
|
||||
));
|
||||
}
|
||||
let mut globals: BTreeSet<String> = options.globals.iter().cloned().collect();
|
||||
if globals.contains("") {
|
||||
return Err(error(root.span(), "host global names must not be empty"));
|
||||
}
|
||||
let functions: Vec<&Function> = match root {
|
||||
AstRoot::Module(program) => program.declarations.iter().map(definition).collect(),
|
||||
AstRoot::Interactive(input) => input
|
||||
.statements
|
||||
.iter()
|
||||
.filter_map(|statement| {
|
||||
if let StmtKind::Declaration(declaration) = &statement.kind {
|
||||
Some(definition(declaration))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect(),
|
||||
AstRoot::Expression(_) => Vec::new(),
|
||||
};
|
||||
let (kind, name) = match root {
|
||||
AstRoot::Module(_) => (ScopeKind::Module, "<module>"),
|
||||
AstRoot::Expression(_) => (ScopeKind::Expression, "<expression>"),
|
||||
AstRoot::Interactive(_) => (ScopeKind::Interactive, "<interactive>"),
|
||||
};
|
||||
let mut root_scope = Builder::new(kind, name, root.span());
|
||||
let mut declared = BTreeSet::new();
|
||||
for function in &functions {
|
||||
declare(&mut declared, &function.name.text, function.name.span)?;
|
||||
globals.insert(function.name.text.clone());
|
||||
root_scope.intern(&function.name.text);
|
||||
}
|
||||
// Analyze all bodies after registering all functions, enabling forward
|
||||
// references and recursion without instantiating function objects here.
|
||||
let scopes = functions
|
||||
.iter()
|
||||
.map(|function| function_scope(function, &globals))
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
match root {
|
||||
AstRoot::Module(_) => {}
|
||||
AstRoot::Expression(expression) => root_scope.expression(expression, &globals)?,
|
||||
AstRoot::Interactive(input) => {
|
||||
for statement in &input.statements {
|
||||
match &statement.kind {
|
||||
StmtKind::Binding(binding) => {
|
||||
declare(&mut declared, &binding.name.text, binding.name.span)?;
|
||||
root_scope.expression(&binding.value, &globals)?;
|
||||
globals.insert(binding.name.text.clone());
|
||||
root_scope.intern(&binding.name.text);
|
||||
}
|
||||
StmtKind::Declaration(_) => {}
|
||||
StmtKind::Expression(expression) => {
|
||||
root_scope.expression(expression, &globals)?
|
||||
}
|
||||
StmtKind::Return(_) => {
|
||||
return Err(error(statement.span, "return outside a function"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(SymbolTable {
|
||||
root: root_scope.scope,
|
||||
functions: scopes,
|
||||
})
|
||||
}
|
||||
|
||||
fn declare(names: &mut BTreeSet<String>, name: &str, span: Span) -> Result<(), Diagnostic> {
|
||||
if name.is_empty() || !names.insert(name.to_owned()) {
|
||||
return Err(error(
|
||||
span,
|
||||
format!("duplicate or empty declaration: {name}"),
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn function_scope(function: &Function, globals: &BTreeSet<String>) -> Result<Scope, Diagnostic> {
|
||||
let mut builder = Builder::new(ScopeKind::Function, &function.name.text, function.span);
|
||||
let mut locals = BTreeSet::new();
|
||||
for parameter in &function.parameters {
|
||||
declare(&mut locals, ¶meter.name.text, parameter.name.span)?;
|
||||
builder
|
||||
.scope
|
||||
.layout
|
||||
.parameters
|
||||
.push(parameter.name.text.clone());
|
||||
builder
|
||||
.scope
|
||||
.layout
|
||||
.locals
|
||||
.push(parameter.name.text.clone());
|
||||
builder.initialized.insert(parameter.name.text.clone());
|
||||
}
|
||||
for statement in &function.body.statements {
|
||||
match &statement.kind {
|
||||
StmtKind::Binding(binding) => {
|
||||
declare(&mut locals, &binding.name.text, binding.name.span)?;
|
||||
builder.scope.layout.locals.push(binding.name.text.clone());
|
||||
}
|
||||
StmtKind::Declaration(_) => {
|
||||
return Err(error(
|
||||
statement.span,
|
||||
"nested function declarations are not compiled yet",
|
||||
));
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let mut returned = false;
|
||||
for statement in &function.body.statements {
|
||||
if returned {
|
||||
return Err(error(
|
||||
statement.span,
|
||||
"statement after return is unreachable",
|
||||
));
|
||||
}
|
||||
match &statement.kind {
|
||||
StmtKind::Binding(binding) => {
|
||||
builder.expression(&binding.value, globals)?;
|
||||
builder.initialized.insert(binding.name.text.clone());
|
||||
}
|
||||
StmtKind::Return(statement) => {
|
||||
if let Some(value) = &statement.value {
|
||||
builder.expression(value, globals)?;
|
||||
}
|
||||
returned = true;
|
||||
}
|
||||
StmtKind::Expression(expression) => builder.expression(expression, globals)?,
|
||||
StmtKind::Declaration(_) => unreachable!("nested declaration rejected above"),
|
||||
}
|
||||
}
|
||||
Ok(builder.scope)
|
||||
}
|
||||
|
||||
struct Builder {
|
||||
scope: Scope,
|
||||
initialized: BTreeSet<String>,
|
||||
}
|
||||
|
||||
impl Builder {
|
||||
fn new(kind: ScopeKind, name: &str, span: Span) -> Self {
|
||||
Self {
|
||||
scope: Scope {
|
||||
kind,
|
||||
name: name.into(),
|
||||
span,
|
||||
layout: CodeLayout::default(),
|
||||
references: Vec::new(),
|
||||
},
|
||||
initialized: BTreeSet::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn intern(&mut self, name: &str) -> usize {
|
||||
if let Some(index) = self
|
||||
.scope
|
||||
.layout
|
||||
.names
|
||||
.iter()
|
||||
.position(|candidate| candidate == name)
|
||||
{
|
||||
index
|
||||
} else {
|
||||
self.scope.layout.names.push(name.to_owned());
|
||||
self.scope.layout.names.len() - 1
|
||||
}
|
||||
}
|
||||
|
||||
fn expression(
|
||||
&mut self,
|
||||
expression: &Expr,
|
||||
globals: &BTreeSet<String>,
|
||||
) -> Result<(), Diagnostic> {
|
||||
match &expression.kind {
|
||||
ExprKind::Name(name) => {
|
||||
let binding = if let Some(index) = self
|
||||
.scope
|
||||
.layout
|
||||
.locals
|
||||
.iter()
|
||||
.position(|local| local == name)
|
||||
{
|
||||
if !self.initialized.contains(name) {
|
||||
return Err(error(
|
||||
expression.span,
|
||||
format!("local variable read before initialization: {name}"),
|
||||
));
|
||||
}
|
||||
NameBinding::Local(index)
|
||||
} else if globals.contains(name) {
|
||||
NameBinding::Global(self.intern(name))
|
||||
} else {
|
||||
return Err(error(expression.span, format!("undefined name: {name}")));
|
||||
};
|
||||
self.scope.references.push(NameUse {
|
||||
name: name.clone(),
|
||||
span: expression.span,
|
||||
binding,
|
||||
});
|
||||
}
|
||||
ExprKind::Unary { operand, .. } => self.expression(operand, globals)?,
|
||||
ExprKind::Binary { left, right, .. } => {
|
||||
self.expression(left, globals)?;
|
||||
self.expression(right, globals)?;
|
||||
}
|
||||
ExprKind::Member { object, name } => {
|
||||
self.expression(object, globals)?;
|
||||
self.intern(&name.text);
|
||||
}
|
||||
ExprKind::Call { callee, arguments } => {
|
||||
self.expression(callee, globals)?;
|
||||
for argument in arguments {
|
||||
self.expression(argument, globals)?;
|
||||
}
|
||||
}
|
||||
ExprKind::Number(_) | ExprKind::String(_) | ExprKind::Symbol(_) => {}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,315 @@
|
||||
use endor_core::{
|
||||
CodeLayout, DecodedInstruction, EndorCode, EndorNumber, Instruction, ObjectRef, Opcode, Value,
|
||||
Vm, VmError,
|
||||
};
|
||||
use frontend::ast::{AstRoot, Decl, DeclKind, Expr, ExprKind, Stmt, StmtKind, UnaryOp};
|
||||
use frontend::{Diagnostic, DiagnosticKind, SourceUnit, Span};
|
||||
|
||||
use crate::{NameBinding, Scope, ScopeKind, SymbolTable, diagnostic};
|
||||
|
||||
/// Validated, heap-independent executable template. Nested code constants
|
||||
/// remain templates until load(), so no ObjectRef is shared across VM heaps.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct CompiledCode {
|
||||
code: EndorCode,
|
||||
children: Vec<(usize, CompiledCode)>,
|
||||
}
|
||||
|
||||
impl CompiledCode {
|
||||
pub fn instructions(&self) -> &[DecodedInstruction] {
|
||||
self.code.instructions()
|
||||
}
|
||||
pub fn layout(&self) -> &CodeLayout {
|
||||
self.code.layout()
|
||||
}
|
||||
pub fn name(&self) -> &str {
|
||||
self.code.name()
|
||||
}
|
||||
pub fn filename(&self) -> &str {
|
||||
self.code.filename()
|
||||
}
|
||||
pub fn first_line(&self) -> usize {
|
||||
self.code.first_line()
|
||||
}
|
||||
pub fn children(&self) -> impl Iterator<Item = &CompiledCode> {
|
||||
self.children.iter().map(|(_, child)| child)
|
||||
}
|
||||
|
||||
/// Return one owned code-object root; release it after execution. The
|
||||
/// parent retains its nested code constants. Temporary child roots are
|
||||
/// released on both success and failure, including partial recursive loads.
|
||||
pub fn load(&self, vm: &mut Vm) -> Result<ObjectRef, VmError> {
|
||||
let mut roots = Vec::new();
|
||||
let result = (|| {
|
||||
let mut constants = self.code.constants().to_vec();
|
||||
for (index, child) in &self.children {
|
||||
let reference = child.load(vm)?;
|
||||
roots.push(reference);
|
||||
constants[*index] = Value::Object(reference);
|
||||
}
|
||||
let code = EndorCode::with_layout(
|
||||
self.code.bytecode().to_vec(),
|
||||
constants,
|
||||
self.code.layout().clone(),
|
||||
)?
|
||||
.with_location(
|
||||
self.code.name(),
|
||||
self.code.filename(),
|
||||
self.code.first_line(),
|
||||
);
|
||||
vm.new_code(code)
|
||||
})();
|
||||
for reference in roots {
|
||||
vm.release(reference)
|
||||
.expect("loader owns each temporary code root");
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
fn error(span: Span, message: impl Into<String>) -> Diagnostic {
|
||||
diagnostic(DiagnosticKind::Compilation, span, message)
|
||||
}
|
||||
|
||||
pub(crate) fn generate(
|
||||
root: &AstRoot,
|
||||
source: &SourceUnit,
|
||||
symbols: &SymbolTable,
|
||||
) -> Result<CompiledCode, Diagnostic> {
|
||||
let mut emitter = Emitter::new(&symbols.root, source);
|
||||
match root {
|
||||
AstRoot::Module(program) => {
|
||||
for declaration in &program.declarations {
|
||||
emitter.declaration(declaration, symbols)?;
|
||||
}
|
||||
emitter.constant(Value::Nil)?;
|
||||
emitter.simple(Opcode::ReturnValue);
|
||||
}
|
||||
AstRoot::Expression(expression) => {
|
||||
emitter.expression(expression)?;
|
||||
emitter.simple(Opcode::ReturnValue);
|
||||
}
|
||||
AstRoot::Interactive(input) => {
|
||||
for statement in &input.statements {
|
||||
if let StmtKind::Expression(expression) = &statement.kind {
|
||||
emitter.expression(expression)?;
|
||||
} else {
|
||||
emitter.statement(statement, symbols)?;
|
||||
emitter.constant(Value::Nil)?;
|
||||
}
|
||||
}
|
||||
emitter.simple(Opcode::ReturnValue);
|
||||
}
|
||||
}
|
||||
emitter.finish()
|
||||
}
|
||||
|
||||
struct Emitter<'a> {
|
||||
scope: &'a Scope,
|
||||
source: &'a SourceUnit,
|
||||
instructions: Vec<Instruction>,
|
||||
constants: Vec<Value>,
|
||||
children: Vec<(usize, CompiledCode)>,
|
||||
}
|
||||
|
||||
impl<'a> Emitter<'a> {
|
||||
fn new(scope: &'a Scope, source: &'a SourceUnit) -> Self {
|
||||
Self {
|
||||
scope,
|
||||
source,
|
||||
instructions: Vec::new(),
|
||||
constants: Vec::new(),
|
||||
children: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn emit(&mut self, opcode: Opcode, argument: usize) -> Result<(), Diagnostic> {
|
||||
let argument = u32::try_from(argument)
|
||||
.map_err(|_| error(self.scope.span, "bytecode operand exceeds u32"))?;
|
||||
self.instructions.push(Instruction::new(opcode, argument));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn simple(&mut self, opcode: Opcode) {
|
||||
self.instructions.push(Instruction::simple(opcode));
|
||||
}
|
||||
|
||||
fn constant(&mut self, value: Value) -> Result<(), Diagnostic> {
|
||||
let index = self.constants.len();
|
||||
self.constants.push(value);
|
||||
self.emit(Opcode::LoadConst, index)
|
||||
}
|
||||
|
||||
fn name_index(&self, name: &str) -> usize {
|
||||
self.scope
|
||||
.layout
|
||||
.names
|
||||
.iter()
|
||||
.position(|candidate| candidate == name)
|
||||
.expect("analysis interns every emitted name")
|
||||
}
|
||||
|
||||
fn declaration(&mut self, declaration: &Decl, symbols: &SymbolTable) -> Result<(), Diagnostic> {
|
||||
let DeclKind::Function(function) = &declaration.kind;
|
||||
let scope = symbols
|
||||
.functions
|
||||
.iter()
|
||||
.find(|scope| scope.span == function.span && scope.name == function.name.text)
|
||||
.expect("analysis creates each function scope");
|
||||
let mut body = Emitter::new(scope, self.source);
|
||||
for statement in &function.body.statements {
|
||||
body.statement(statement, symbols)?;
|
||||
}
|
||||
if !matches!(
|
||||
function
|
||||
.body
|
||||
.statements
|
||||
.last()
|
||||
.map(|statement| &statement.kind),
|
||||
Some(StmtKind::Return(_))
|
||||
) {
|
||||
body.constant(Value::Nil)?;
|
||||
body.simple(Opcode::ReturnValue);
|
||||
}
|
||||
let child = body.finish()?;
|
||||
let index = self.constants.len();
|
||||
self.children.push((index, child));
|
||||
self.constant(Value::Nil)?; // Replaced by a managed code object during load().
|
||||
self.instructions.push(Instruction::make_function(0, 0));
|
||||
self.emit(Opcode::StoreGlobal, self.name_index(&function.name.text))
|
||||
}
|
||||
|
||||
fn statement(&mut self, statement: &Stmt, symbols: &SymbolTable) -> Result<(), Diagnostic> {
|
||||
match &statement.kind {
|
||||
StmtKind::Binding(binding) => {
|
||||
self.expression(&binding.value)?;
|
||||
if self.scope.kind == ScopeKind::Function {
|
||||
let index = self
|
||||
.scope
|
||||
.layout
|
||||
.locals
|
||||
.iter()
|
||||
.position(|name| name == &binding.name.text)
|
||||
.expect("analysis allocates each local");
|
||||
self.emit(Opcode::StoreFast, index)?;
|
||||
} else {
|
||||
self.emit(Opcode::StoreGlobal, self.name_index(&binding.name.text))?;
|
||||
}
|
||||
}
|
||||
StmtKind::Return(statement) => {
|
||||
if let Some(value) = &statement.value {
|
||||
self.expression(value)?;
|
||||
} else {
|
||||
self.constant(Value::Nil)?;
|
||||
}
|
||||
self.simple(Opcode::ReturnValue);
|
||||
}
|
||||
StmtKind::Expression(expression) => {
|
||||
self.expression(expression)?;
|
||||
self.simple(Opcode::PopTop);
|
||||
}
|
||||
StmtKind::Declaration(declaration) => self.declaration(declaration, symbols)?,
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn expression(&mut self, expression: &Expr) -> Result<(), Diagnostic> {
|
||||
match &expression.kind {
|
||||
ExprKind::String(value) => self.constant(Value::Text(value.clone()))?,
|
||||
ExprKind::Number(spelling) => self.number(spelling, expression.span)?,
|
||||
ExprKind::Name(name) => {
|
||||
let reference = self
|
||||
.scope
|
||||
.references
|
||||
.iter()
|
||||
.find(|reference| reference.span == expression.span && &reference.name == name)
|
||||
.expect("analysis resolves every name expression");
|
||||
let (opcode, index) = match reference.binding {
|
||||
NameBinding::Local(index) => (Opcode::LoadFast, index),
|
||||
NameBinding::Global(index) => (Opcode::LoadGlobal, index),
|
||||
};
|
||||
self.emit(opcode, index)?;
|
||||
}
|
||||
ExprKind::Call { callee, arguments } => {
|
||||
self.expression(callee)?;
|
||||
self.simple(Opcode::PushNull);
|
||||
for argument in arguments {
|
||||
self.expression(argument)?;
|
||||
}
|
||||
self.emit(Opcode::Call, arguments.len())?;
|
||||
}
|
||||
ExprKind::Member { object, name } => {
|
||||
self.expression(object)?;
|
||||
self.emit(Opcode::LoadAttr, self.name_index(&name.text))?;
|
||||
}
|
||||
ExprKind::Unary { .. } => {
|
||||
// Literal sign folding preserves arbitrarily large integers
|
||||
// and decimal spelling; this is not general numeric arithmetic.
|
||||
let Some(spelling) = signed_literal(expression, false) else {
|
||||
return Err(error(
|
||||
expression.span,
|
||||
"numeric unary operations are not implemented; only signed number literals are supported",
|
||||
));
|
||||
};
|
||||
self.number(&spelling, expression.span)?;
|
||||
}
|
||||
ExprKind::Binary { .. } => {
|
||||
return Err(error(
|
||||
expression.span,
|
||||
"numeric arithmetic bytecode is not implemented yet",
|
||||
));
|
||||
}
|
||||
ExprKind::Symbol(_) => {
|
||||
return Err(error(
|
||||
expression.span,
|
||||
"symbol runtime values are not implemented yet",
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn number(&mut self, spelling: &str, span: Span) -> Result<(), Diagnostic> {
|
||||
let value = if spelling.contains('.') {
|
||||
EndorNumber::decimal(spelling)
|
||||
} else {
|
||||
EndorNumber::integer(spelling)
|
||||
}
|
||||
.map_err(|failure| error(span, failure.to_string()))?;
|
||||
self.constant(Value::Number(value))
|
||||
}
|
||||
|
||||
fn finish(self) -> Result<CompiledCode, Diagnostic> {
|
||||
let line = self
|
||||
.scope
|
||||
.span
|
||||
.location(self.source.text())
|
||||
.map_or(1, |location| location.line);
|
||||
let code = EndorCode::from_instructions(
|
||||
&self.instructions,
|
||||
self.constants,
|
||||
self.scope.layout.clone(),
|
||||
)
|
||||
.map_err(|failure| error(self.scope.span, failure.to_string()))?
|
||||
.with_location(&self.scope.name, self.source.origin().to_string(), line);
|
||||
Ok(CompiledCode {
|
||||
code,
|
||||
children: self.children,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn signed_literal(expression: &Expr, negative: bool) -> Option<String> {
|
||||
match &expression.kind {
|
||||
ExprKind::Number(spelling) => Some(if negative {
|
||||
format!("-{spelling}")
|
||||
} else {
|
||||
spelling.clone()
|
||||
}),
|
||||
ExprKind::Unary {
|
||||
operation: UnaryOp::Negate,
|
||||
operand,
|
||||
} => signed_literal(operand, !negative),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
//! Minimal source-to-wordcode compiler. Analysis and emission do not allocate
|
||||
//! VM objects; a compiled unit can be loaded into independent VMs explicitly.
|
||||
|
||||
mod analysis;
|
||||
mod codegen;
|
||||
|
||||
pub use analysis::{NameBinding, NameUse, Scope, ScopeKind, SymbolTable, analyze};
|
||||
pub use codegen::CompiledCode;
|
||||
|
||||
use frontend::ast::{AstDocument, AstRoot};
|
||||
use frontend::{Diagnostic, DiagnosticKind, ParseMode, SourceDiagnostic, SourceUnit, Span};
|
||||
|
||||
/// Names supplied by the host's globals or builtins dictionary. These are
|
||||
/// compile-time declarations only; loading code never injects their values.
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct CompileOptions {
|
||||
pub globals: Vec<String>,
|
||||
}
|
||||
|
||||
pub fn compile_source(
|
||||
source: &SourceUnit,
|
||||
mode: ParseMode,
|
||||
options: &CompileOptions,
|
||||
) -> Result<CompiledCode, SourceDiagnostic> {
|
||||
let root = frontend::parse_source_ast(source, mode)?;
|
||||
compile_ast(&root, source, options).map_err(|error| source.annotate(error))
|
||||
}
|
||||
|
||||
/// Compile an AST against its original source snapshot. Span validation does
|
||||
/// not prove the AST's semantic equivalence to the supplied text.
|
||||
pub fn compile_ast(
|
||||
root: &AstRoot,
|
||||
source: &SourceUnit,
|
||||
options: &CompileOptions,
|
||||
) -> Result<CompiledCode, Diagnostic> {
|
||||
AstDocument::new(root.clone())
|
||||
.and_then(|document| document.validate_source(source.text()))
|
||||
.map_err(|error| {
|
||||
diagnostic(
|
||||
DiagnosticKind::Compilation,
|
||||
Span::default(),
|
||||
error.to_string(),
|
||||
)
|
||||
})?;
|
||||
let symbols = analyze(root, options)?;
|
||||
codegen::generate(root, source, &symbols)
|
||||
}
|
||||
|
||||
fn diagnostic(kind: DiagnosticKind, span: Span, message: impl Into<String>) -> Diagnostic {
|
||||
Diagnostic {
|
||||
kind,
|
||||
span,
|
||||
message: message.into(),
|
||||
expected: Vec::new(),
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user