1061 lines
34 KiB
Rust
1061 lines
34 KiB
Rust
use crate::ast_compiler::Expression::{
|
|
FieldGet, FunctionCall, ListGet, MapGet, NamedParameter, Stop, Variable,
|
|
};
|
|
use crate::errors::CompilerError::{
|
|
self, Expected, ParseError, TooManyParameters, UndeclaredVariable, UnexpectedIndent,
|
|
UninitializedVariable,
|
|
};
|
|
use crate::errors::CompilerErrorAtLine;
|
|
use crate::symbol_builder::{Symbol, calculate_type, infer_type};
|
|
use crate::tokens::TokenType::{
|
|
Bang, Bool, Char, Colon, DateTime, Dot, Eof, Eol, Equal, F32, F64, False, FloatingPoint, Fn,
|
|
Greater, GreaterEqual, GreaterGreater, I32, I64, Identifier, Indent, Integer, LeftBrace,
|
|
LeftBracket, LeftParen, Less, LessEqual, LessLess, Let, ListType, MapType, Minus, Object, Plus,
|
|
Print, RightBrace, RightBracket, RightParen, SignedInteger, SingleRightArrow, Slash, Star,
|
|
StringType, True, U32, U64, Unknown, UnsignedInteger,
|
|
};
|
|
use crate::tokens::{Token, TokenType};
|
|
use crate::value::Value;
|
|
use log::debug;
|
|
use std::collections::HashMap;
|
|
|
|
pub fn compile(
|
|
path: Option<&str>,
|
|
tokens: Vec<Token>,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Vec<Statement>, CompilerErrorAtLine> {
|
|
let mut compiler = AstCompiler::new(path.unwrap_or(""), tokens);
|
|
compiler.compile_tokens(symbol_table)
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Function {
|
|
pub(crate) name: Token,
|
|
pub(crate) parameters: Vec<Parameter>,
|
|
pub(crate) return_type: TokenType,
|
|
pub(crate) body: Vec<Statement>,
|
|
}
|
|
|
|
struct AstCompiler {
|
|
tokens: Vec<Token>,
|
|
current: usize,
|
|
had_error: bool,
|
|
indent: Vec<usize>,
|
|
}
|
|
|
|
impl AstCompiler {
|
|
fn new(_name: &str, tokens: Vec<Token>) -> Self {
|
|
Self {
|
|
tokens,
|
|
current: 0,
|
|
had_error: false,
|
|
indent: vec![0],
|
|
}
|
|
}
|
|
|
|
fn reset(&mut self) {
|
|
self.current = 0;
|
|
}
|
|
|
|
fn compile_tokens(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Vec<Statement>, CompilerErrorAtLine> {
|
|
self.reset();
|
|
self.compile(symbol_table)
|
|
}
|
|
|
|
fn compile(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Vec<Statement>, CompilerErrorAtLine> {
|
|
self.current_line();
|
|
if !self.had_error {
|
|
let mut statements = vec![];
|
|
while !self.is_at_end() {
|
|
let statement = self.indent(symbol_table)?;
|
|
if let Some(statement) = statement {
|
|
statements.push(statement);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
debug!("AST {:?}", statements);
|
|
Ok(statements)
|
|
} else {
|
|
Err(self.raise(CompilerError::Failure))
|
|
}
|
|
}
|
|
|
|
fn raise(&self, error: CompilerError) -> CompilerErrorAtLine {
|
|
CompilerErrorAtLine::raise(error, self.current_line())
|
|
}
|
|
|
|
fn indent(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Option<Statement>, CompilerErrorAtLine> {
|
|
let expected_indent = *self.indent.last().unwrap();
|
|
// skip empty lines
|
|
while self.check(Eol) {
|
|
self.advance();
|
|
}
|
|
|
|
let mut indent_on_line = 0;
|
|
// keep track of indent level
|
|
while self.match_token(vec![Indent]) {
|
|
indent_on_line += 1;
|
|
}
|
|
if indent_on_line > expected_indent {
|
|
Err(self.raise(UnexpectedIndent(indent_on_line, expected_indent)))
|
|
} else if indent_on_line < expected_indent {
|
|
self.indent.pop();
|
|
return Ok(None);
|
|
} else {
|
|
Ok(Some(self.declaration(symbol_table)?))
|
|
}
|
|
}
|
|
|
|
fn declaration(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Statement, CompilerErrorAtLine> {
|
|
if self.match_token(vec![Fn]) {
|
|
self.function_declaration(symbol_table)
|
|
} else if self.match_token(vec![Let]) {
|
|
self.let_declaration(symbol_table)
|
|
} else if self.match_token(vec![Object]) {
|
|
self.object_declaration()
|
|
} else if self.match_token(vec![TokenType::Pipe]) {
|
|
self.guard_declaration(symbol_table)
|
|
} else {
|
|
self.statement(symbol_table)
|
|
}
|
|
}
|
|
|
|
// | /. -> service.get_all()
|
|
// | /{uuid} -> service.get(uuid)?
|
|
// | ?{query.firstname} -> service.get_by_firstname(fname)?
|
|
fn guard_declaration(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Statement, CompilerErrorAtLine> {
|
|
let if_expr = self.guard_if_expr(symbol_table)?;
|
|
let then_expr = self.expression(symbol_table)?;
|
|
Ok(Statement::GuardStatement { if_expr, then_expr })
|
|
}
|
|
|
|
fn guard_if_expr(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
while !self.check(SingleRightArrow) {
|
|
if self.match_token(vec![Slash]) {
|
|
return self.path_guard_expr();
|
|
} else if self.match_token(vec![TokenType::Question]) {
|
|
return self.query_guard_expr(symbol_table);
|
|
} else {
|
|
return Err(self.raise(Expected("-> or ?")));
|
|
}
|
|
}
|
|
Ok(Stop {
|
|
line: self.peek().line,
|
|
})
|
|
}
|
|
|
|
fn query_guard_expr(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
if self.match_token(vec![LeftBrace]) {
|
|
let query_params = self.expression(symbol_table)?;
|
|
self.consume(RightBrace, Expected("'}' after guard expression."))?;
|
|
Ok(query_params)
|
|
} else {
|
|
Ok(Stop {
|
|
line: self.peek().line,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn path_guard_expr(&mut self) -> Result<Expression, CompilerErrorAtLine> {
|
|
if self.match_token(vec![LeftBrace]) {
|
|
let path_params = self.match_expression()?;
|
|
self.consume(RightBrace, Expected("'}' after guard expression."))?;
|
|
Ok(path_params)
|
|
} else {
|
|
Ok(Stop {
|
|
line: self.peek().line,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn match_expression(&mut self) -> Result<Expression, CompilerErrorAtLine> {
|
|
Err(self.raise(Expected("unimplemented")))
|
|
}
|
|
|
|
fn object_declaration(&mut self) -> Result<Statement, CompilerErrorAtLine> {
|
|
let type_name = self.consume(Identifier, Expected("object name."))?;
|
|
self.consume(Colon, Expected("':' after object name."))?;
|
|
self.consume(Eol, Expected("end of line."))?;
|
|
|
|
let mut fields = vec![];
|
|
|
|
let expected_indent = self.indent.last().unwrap() + 1;
|
|
// self.indent.push(expected_indent);
|
|
let mut done = false;
|
|
while !done && !self.match_token(vec![Eof]) {
|
|
for _ in 0..expected_indent {
|
|
if self.peek().token_type == Indent {
|
|
self.advance();
|
|
} else {
|
|
done = true;
|
|
}
|
|
}
|
|
if !done {
|
|
let field_name = self.consume(Identifier, Expected("an object field name."))?;
|
|
self.consume(Colon, Expected("':' after field name."))?;
|
|
let field_type = self.peek().token_type.clone();
|
|
if field_type.is_type() {
|
|
self.advance();
|
|
} else {
|
|
Err(self.raise(Expected("a type")))?
|
|
}
|
|
fields.push(Parameter {
|
|
name: field_name,
|
|
var_type: field_type,
|
|
});
|
|
}
|
|
}
|
|
self.consume(Eol, Expected("end of line."))?;
|
|
Ok(Statement::ObjectStmt {
|
|
name: type_name,
|
|
fields,
|
|
})
|
|
}
|
|
|
|
fn function_declaration(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Statement, CompilerErrorAtLine> {
|
|
let name_token = self.consume(Identifier, Expected("function name."))?;
|
|
self.consume(LeftParen, Expected("'(' after function name."))?;
|
|
let mut parameters = vec![];
|
|
while !self.check(RightParen) {
|
|
if parameters.len() >= 25 {
|
|
return Err(self.raise(TooManyParameters));
|
|
}
|
|
let parm_name = self.consume(Identifier, Expected("a parameter name."))?;
|
|
|
|
self.consume(Colon, Expected(": after parameter name"))?;
|
|
let var_type = self.peek().token_type.clone();
|
|
|
|
self.advance();
|
|
parameters.push(Parameter {
|
|
name: parm_name,
|
|
var_type,
|
|
});
|
|
if self.peek().token_type == TokenType::Comma {
|
|
self.advance();
|
|
}
|
|
}
|
|
self.consume(RightParen, Expected(" ')' after parameters."))?;
|
|
let return_type = if self.check(SingleRightArrow) {
|
|
self.consume(SingleRightArrow, Expected("->"))?;
|
|
self.advance().token_type.clone()
|
|
} else {
|
|
TokenType::Void
|
|
};
|
|
self.consume(Colon, Expected("colon (:) after function declaration."))?;
|
|
self.consume(Eol, Expected("end of line."))?;
|
|
|
|
let current_indent = self.indent.last().unwrap();
|
|
self.indent.push(current_indent + 1);
|
|
|
|
let body = self.compile(symbol_table)?;
|
|
|
|
let function = Function {
|
|
name: name_token.clone(),
|
|
parameters,
|
|
return_type,
|
|
body,
|
|
};
|
|
|
|
Ok(Statement::FunctionStmt { function })
|
|
}
|
|
|
|
fn let_declaration(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Statement, CompilerErrorAtLine> {
|
|
if self.peek().token_type.is_type() {
|
|
return Err(self.raise(CompilerError::KeywordNotAllowedAsIdentifier(
|
|
self.peek().token_type.clone(),
|
|
)));
|
|
}
|
|
let name_token = self.consume(Identifier, Expected("variable name."))?;
|
|
|
|
let declared_type = if self.check(Colon) {
|
|
self.advance();
|
|
Some(self.advance().token_type.clone())
|
|
} else {
|
|
None
|
|
};
|
|
|
|
if self.match_token(vec![Equal]) {
|
|
let initializer = self.expression(symbol_table)?;
|
|
let declared_type = declared_type.unwrap_or(Unknown);
|
|
let inferred_type = initializer.infer_type();
|
|
let var_type =
|
|
calculate_type(&declared_type, &inferred_type).map_err(|e| self.raise(e))?;
|
|
symbol_table.insert(
|
|
name_token.lexeme.clone(),
|
|
Symbol::Variable {
|
|
name: name_token.lexeme.clone(),
|
|
var_type: var_type.clone(),
|
|
},
|
|
);
|
|
|
|
self.consume(Eol, Expected("end of line after initializer."))?;
|
|
|
|
Ok(Statement::VarStmt {
|
|
name: name_token,
|
|
var_type,
|
|
initializer,
|
|
})
|
|
} else {
|
|
Err(self.raise(UninitializedVariable))?
|
|
}
|
|
}
|
|
|
|
fn statement(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Statement, CompilerErrorAtLine> {
|
|
if self.match_token(vec![Print]) {
|
|
self.print_statement(symbol_table)
|
|
} else {
|
|
self.expr_statement(symbol_table)
|
|
}
|
|
}
|
|
|
|
fn print_statement(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Statement, CompilerErrorAtLine> {
|
|
let expr = self.expression(symbol_table)?;
|
|
self.consume(Eol, Expected("end of line after print statement."))?;
|
|
Ok(Statement::PrintStmt { value: expr })
|
|
}
|
|
|
|
fn expr_statement(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Statement, CompilerErrorAtLine> {
|
|
let expr = self.expression(symbol_table)?;
|
|
if !self.is_at_end() {
|
|
self.consume(Eol, Expected("end of line after expression."))?;
|
|
}
|
|
Ok(Statement::ExpressionStmt { expression: expr })
|
|
}
|
|
|
|
fn expression(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
self.or(symbol_table)
|
|
}
|
|
|
|
fn or(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.and(symbol_table)?;
|
|
self.binary(vec![TokenType::LogicalOr], expr, symbol_table)
|
|
}
|
|
|
|
fn and(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.bit_and(symbol_table)?;
|
|
self.binary(vec![TokenType::LogicalAnd], expr, symbol_table)
|
|
}
|
|
|
|
fn bit_and(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.bit_or(symbol_table)?;
|
|
self.binary(vec![TokenType::BitAnd], expr, symbol_table)
|
|
}
|
|
|
|
fn bit_or(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.bit_xor(symbol_table)?;
|
|
self.binary(vec![TokenType::Pipe], expr, symbol_table)
|
|
}
|
|
|
|
fn bit_xor(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.equality(symbol_table)?;
|
|
self.binary(vec![TokenType::BitXor], expr, symbol_table)
|
|
}
|
|
|
|
fn equality(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.comparison(symbol_table)?;
|
|
self.binary(
|
|
vec![TokenType::EqualEqual, TokenType::BangEqual],
|
|
expr,
|
|
symbol_table,
|
|
)
|
|
}
|
|
|
|
fn comparison(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.bitshift(symbol_table)?;
|
|
self.binary(
|
|
vec![Greater, GreaterEqual, Less, LessEqual],
|
|
expr,
|
|
symbol_table,
|
|
)
|
|
}
|
|
|
|
fn bitshift(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.term(symbol_table)?;
|
|
self.binary(vec![GreaterGreater, LessLess], expr, symbol_table)
|
|
}
|
|
|
|
fn term(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.factor(symbol_table)?;
|
|
self.binary(vec![Minus, Plus], expr, symbol_table)
|
|
}
|
|
|
|
fn factor(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.unary(symbol_table)?;
|
|
self.binary(vec![Slash, Star], expr, symbol_table)
|
|
}
|
|
|
|
fn binary(
|
|
&mut self,
|
|
types: Vec<TokenType>,
|
|
mut expr: Expression,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
while self.match_token(types.clone()) {
|
|
let operator = self.previous().clone();
|
|
let right = self.comparison(symbol_table)?;
|
|
expr = Expression::Binary {
|
|
line: operator.line,
|
|
left: Box::new(expr),
|
|
operator,
|
|
right: Box::new(right),
|
|
};
|
|
}
|
|
Ok(expr)
|
|
}
|
|
|
|
fn unary(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
if self.match_token(vec![Bang, Minus]) {
|
|
let operator = self.previous().clone();
|
|
let right = self.unary(symbol_table)?;
|
|
Ok(Expression::Unary {
|
|
line: self.peek().line,
|
|
operator,
|
|
right: Box::new(right),
|
|
})
|
|
} else {
|
|
let expr = self.get(symbol_table);
|
|
expr
|
|
}
|
|
}
|
|
|
|
fn get(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let expr = self.primary(symbol_table)?;
|
|
|
|
if self.match_token(vec![LeftParen]) {
|
|
let name = self.peek().clone();
|
|
self.advance();
|
|
self.function_call(name, symbol_table)
|
|
} else if self.match_token(vec![LeftBracket]) {
|
|
let index = self.expression(symbol_table)?;
|
|
self.index(expr, index)
|
|
} else if self.match_token(vec![Dot]) {
|
|
let name = self.peek().clone();
|
|
self.advance();
|
|
self.field(expr, name)
|
|
} else {
|
|
Ok(expr)
|
|
}
|
|
}
|
|
|
|
fn index(
|
|
&mut self,
|
|
operand: Expression,
|
|
index: Expression,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let get = (match &operand {
|
|
Expression::Map { .. } => MapGet {
|
|
key: Box::new(index),
|
|
},
|
|
Expression::List { .. } => ListGet {
|
|
list: Box::new(operand),
|
|
index: Box::new(index),
|
|
},
|
|
Variable { var_type, .. } => {
|
|
if var_type == &ListType {
|
|
ListGet {
|
|
list: Box::new(operand),
|
|
index: Box::new(index),
|
|
}
|
|
} else {
|
|
return Err(self.raise(CompilerError::IllegalTypeToIndex(var_type.to_string())));
|
|
}
|
|
}
|
|
_ => return Err(self.raise(CompilerError::IllegalTypeToIndex("Unknown".to_string()))),
|
|
});
|
|
self.consume(RightBracket, Expected("']' after index."))?;
|
|
Ok(get)
|
|
}
|
|
|
|
fn field(
|
|
&mut self,
|
|
operand: Expression,
|
|
index: Token,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
//TODO?
|
|
Ok(Expression::FieldGet {
|
|
field: index.lexeme.clone(),
|
|
})
|
|
}
|
|
|
|
fn primary(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
debug!("primary {:?}", self.peek());
|
|
Ok(if self.match_token(vec![LeftBracket]) {
|
|
self.list(symbol_table)?
|
|
} else if self.match_token(vec![LeftBrace]) {
|
|
self.map(symbol_table)?
|
|
} else if self.match_token(vec![False]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: Bool,
|
|
value: Value::Bool(false),
|
|
}
|
|
} else if self.match_token(vec![True]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: Bool,
|
|
value: Value::Bool(true),
|
|
} //, FloatingPoint, Text
|
|
} else if self.match_token(vec![Integer]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: Integer,
|
|
value: Value::I64(
|
|
self.previous()
|
|
.lexeme
|
|
.parse()
|
|
.map_err(|e| self.raise(ParseError(format!("{:?}", e))))?,
|
|
),
|
|
}
|
|
} else if self.match_token(vec![U32]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: Integer,
|
|
value: Value::U32(
|
|
u32::from_str_radix(&self.previous().lexeme.trim_start_matches("0x"), 16)
|
|
.map_err(|e| self.raise(ParseError(format!("{:?}", e))))?,
|
|
),
|
|
}
|
|
} else if self.match_token(vec![U64]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: Integer,
|
|
value: Value::U64(
|
|
u64::from_str_radix(&self.previous().lexeme.trim_start_matches("0x"), 16)
|
|
.map_err(|e| self.raise(ParseError(format!("{:?}", e))))?,
|
|
),
|
|
}
|
|
} else if self.match_token(vec![FloatingPoint]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: FloatingPoint,
|
|
value: Value::F64(
|
|
self.previous()
|
|
.lexeme
|
|
.parse()
|
|
.map_err(|e| self.raise(ParseError(format!("{:?}", e))))?,
|
|
),
|
|
}
|
|
} else if self.match_token(vec![StringType]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: StringType,
|
|
value: Value::String(self.previous().lexeme.clone()),
|
|
}
|
|
} else if self.match_token(vec![Char]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: Char,
|
|
value: Value::Char(self.previous().lexeme.chars().next().unwrap()),
|
|
}
|
|
} else if self.match_token(vec![DateTime]) {
|
|
Expression::Literal {
|
|
line: self.peek().line,
|
|
literaltype: DateTime,
|
|
value: Value::DateTime(
|
|
chrono::DateTime::parse_from_str(
|
|
&self.previous().lexeme,
|
|
"%Y-%m-%d %H:%M:%S%.3f %z",
|
|
)
|
|
.map_err(|e| self.raise(ParseError(self.previous().lexeme.clone())))?
|
|
.into(),
|
|
),
|
|
}
|
|
} else if self.match_token(vec![LeftParen]) {
|
|
let expr = self.expression(symbol_table)?;
|
|
self.consume(RightParen, Expected("')' after expression."))?;
|
|
Expression::Grouping {
|
|
line: self.peek().line,
|
|
expression: Box::new(expr),
|
|
}
|
|
} else {
|
|
let token = self.advance().clone();
|
|
debug!("{:?}", token);
|
|
// function call?
|
|
if self.match_token(vec![LeftParen]) {
|
|
self.function_call(token.clone(), symbol_table)?
|
|
} else if self.match_token(vec![Colon]) {
|
|
self.named_parameter(&token, symbol_table)?
|
|
} else {
|
|
// } else if self.check(Dot) {
|
|
// chain of variable or function lookups?
|
|
// let mut name = "/".to_string();
|
|
// name.push_str(&self.previous().lexeme);
|
|
// while self.match_token(vec![Dot]) {
|
|
// name.push_str("/");
|
|
// name.push_str(&self.peek().lexeme);
|
|
// self.advance();
|
|
// }
|
|
// chained function call?
|
|
// if self.match_token(vec![LeftParen]) {
|
|
// self.function_call(name())?
|
|
// } else {
|
|
// empty line
|
|
// return if self.match_token(vec![Eol, Eof]) {
|
|
// Ok(Expression::Literal {
|
|
// value: Value::Void,
|
|
// literaltype: Object,
|
|
// line: token.line,
|
|
// })
|
|
// } else {
|
|
// Err(self.raise(UndeclaredVariable(token.lexeme.clone())))
|
|
// };
|
|
// }
|
|
// } else {
|
|
// none of the above, must be a variable lookup
|
|
self.variable_lookup(&token, symbol_table)?
|
|
}
|
|
})
|
|
}
|
|
|
|
fn named_parameter(
|
|
&mut self,
|
|
name: &Token,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let value = self.expression(symbol_table)?;
|
|
let line = name.line;
|
|
Ok(NamedParameter {
|
|
name: name.clone(),
|
|
value: Box::new(value),
|
|
line,
|
|
})
|
|
}
|
|
|
|
fn list(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let mut list = vec![];
|
|
while !self.match_token(vec![RightBracket]) {
|
|
list.push(self.expression(symbol_table)?);
|
|
if self.peek().token_type == TokenType::Comma {
|
|
self.advance();
|
|
} else {
|
|
self.consume(RightBracket, Expected("']' at the end of the list."))?;
|
|
break;
|
|
}
|
|
}
|
|
Ok(Expression::List {
|
|
values: list,
|
|
literaltype: ListType,
|
|
line: self.peek().line,
|
|
})
|
|
}
|
|
|
|
fn map(
|
|
&mut self,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let mut entries = vec![];
|
|
while !self.match_token(vec![RightBrace]) {
|
|
let key = self.expression(symbol_table)?;
|
|
self.consume(Colon, Expected("':' after map key."))?;
|
|
let value = self.expression(symbol_table)?;
|
|
entries.push((key, value));
|
|
if self.peek().token_type == TokenType::Comma {
|
|
self.advance();
|
|
} else {
|
|
self.consume(RightBrace, Expected("'}' after map."))?;
|
|
break;
|
|
}
|
|
}
|
|
Ok(Expression::Map {
|
|
entries,
|
|
literaltype: MapType,
|
|
line: self.peek().line,
|
|
})
|
|
}
|
|
|
|
fn variable_lookup(
|
|
&mut self,
|
|
name: &Token,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let var = symbol_table.get(&name.lexeme);
|
|
let var_type = if let Some(Symbol::Variable { var_type, .. }) = var {
|
|
var_type
|
|
} else {
|
|
&Unknown
|
|
};
|
|
Ok(Variable {
|
|
name: name.lexeme.to_string(),
|
|
var_type: var_type.clone(),
|
|
line: name.line,
|
|
})
|
|
}
|
|
|
|
fn function_call(
|
|
&mut self,
|
|
name: Token,
|
|
symbol_table: &mut HashMap<String, Symbol>,
|
|
) -> Result<Expression, CompilerErrorAtLine> {
|
|
let mut arguments = vec![];
|
|
while !self.match_token(vec![RightParen]) {
|
|
if arguments.len() >= 25 {
|
|
return Err(self.raise(TooManyParameters));
|
|
}
|
|
let arg = self.expression(symbol_table)?;
|
|
arguments.push(arg);
|
|
if self.peek().token_type == TokenType::Comma {
|
|
self.advance();
|
|
} else {
|
|
self.consume(RightParen, Expected("')' after arguments."))?;
|
|
break;
|
|
}
|
|
}
|
|
Ok(FunctionCall {
|
|
line: self.peek().line,
|
|
name: name.lexeme.to_string(),
|
|
arguments,
|
|
})
|
|
}
|
|
|
|
fn consume(
|
|
&mut self,
|
|
token_type: TokenType,
|
|
message: CompilerError,
|
|
) -> Result<Token, CompilerErrorAtLine> {
|
|
if self.check(token_type) {
|
|
self.advance();
|
|
} else {
|
|
self.had_error = true;
|
|
return Err(self.raise(message));
|
|
}
|
|
Ok(self.previous().clone())
|
|
}
|
|
|
|
fn match_token(&mut self, tokens: Vec<TokenType>) -> bool {
|
|
for tt in tokens {
|
|
if self.check(tt) {
|
|
self.advance();
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
fn check(&self, token_type: TokenType) -> bool {
|
|
if self.is_at_end() {
|
|
false
|
|
} else {
|
|
self.peek().token_type == token_type
|
|
}
|
|
}
|
|
|
|
fn peek(&self) -> &Token {
|
|
&self.tokens[self.current]
|
|
}
|
|
|
|
fn previous(&self) -> &Token {
|
|
&self.tokens[self.current - 1]
|
|
}
|
|
|
|
fn advance(&mut self) -> &Token {
|
|
if !self.is_at_end() {
|
|
self.current += 1;
|
|
}
|
|
&self.previous()
|
|
}
|
|
|
|
fn is_at_end(&self) -> bool {
|
|
self.peek().token_type == Eof
|
|
}
|
|
|
|
fn current_line(&self) -> usize {
|
|
self.peek().line
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Statement {
|
|
ExpressionStmt {
|
|
expression: Expression,
|
|
},
|
|
VarStmt {
|
|
name: Token,
|
|
var_type: TokenType,
|
|
initializer: Expression,
|
|
},
|
|
PrintStmt {
|
|
value: Expression,
|
|
},
|
|
FunctionStmt {
|
|
function: Function,
|
|
},
|
|
ObjectStmt {
|
|
name: Token,
|
|
fields: Vec<Parameter>,
|
|
},
|
|
GuardStatement {
|
|
if_expr: Expression,
|
|
then_expr: Expression,
|
|
},
|
|
}
|
|
|
|
impl Statement {
|
|
pub fn line(&self) -> usize {
|
|
match self {
|
|
Statement::ExpressionStmt { expression } => expression.line(),
|
|
Statement::VarStmt { name, .. } => name.line,
|
|
Statement::PrintStmt { value } => value.line(),
|
|
Statement::FunctionStmt { function, .. } => function.name.line,
|
|
Statement::ObjectStmt { name, .. } => name.line,
|
|
Statement::GuardStatement { if_expr, .. } => if_expr.line(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Parameter {
|
|
pub(crate) name: Token,
|
|
pub(crate) var_type: TokenType,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Expression {
|
|
Binary {
|
|
line: usize,
|
|
left: Box<Expression>,
|
|
operator: Token,
|
|
right: Box<Expression>,
|
|
},
|
|
Unary {
|
|
line: usize,
|
|
operator: Token,
|
|
right: Box<Expression>,
|
|
},
|
|
Grouping {
|
|
line: usize,
|
|
expression: Box<Expression>,
|
|
},
|
|
Literal {
|
|
line: usize,
|
|
literaltype: TokenType,
|
|
value: Value,
|
|
},
|
|
List {
|
|
line: usize,
|
|
literaltype: TokenType,
|
|
values: Vec<Expression>,
|
|
},
|
|
Map {
|
|
line: usize,
|
|
literaltype: TokenType,
|
|
entries: Vec<(Expression, Expression)>,
|
|
},
|
|
Variable {
|
|
line: usize,
|
|
name: String,
|
|
var_type: TokenType,
|
|
},
|
|
FunctionCall {
|
|
line: usize,
|
|
name: String,
|
|
arguments: Vec<Expression>,
|
|
},
|
|
Stop {
|
|
line: usize,
|
|
},
|
|
// PathMatch {
|
|
// line: usize,
|
|
// condition: Box<Expression>,
|
|
// },
|
|
NamedParameter {
|
|
line: usize,
|
|
name: Token,
|
|
value: Box<Expression>,
|
|
},
|
|
MapGet {
|
|
key: Box<Expression>,
|
|
},
|
|
ListGet {
|
|
list: Box<Expression>,
|
|
index: Box<Expression>,
|
|
},
|
|
FieldGet {
|
|
field: String,
|
|
},
|
|
}
|
|
|
|
impl Expression {
|
|
pub fn line(&self) -> usize {
|
|
match self {
|
|
Self::Binary { line, .. } => *line,
|
|
Self::Unary { line, .. } => *line,
|
|
Self::Grouping { line, .. } => *line,
|
|
Self::Literal { line, .. } => *line,
|
|
Self::List { line, .. } => *line,
|
|
Self::Map { line, .. } => *line,
|
|
Variable { line, .. } => *line,
|
|
FunctionCall { line, .. } => *line,
|
|
Stop { line } => *line,
|
|
// Expression::PathMatch { line, .. } => *line,
|
|
NamedParameter { line, .. } => *line,
|
|
MapGet { .. } => 0,
|
|
ListGet { .. } => 0,
|
|
FieldGet { .. } => 0,
|
|
}
|
|
}
|
|
|
|
pub fn infer_type(&self) -> TokenType {
|
|
match self {
|
|
Expression::Binary {
|
|
left,
|
|
operator,
|
|
right,
|
|
..
|
|
} => {
|
|
let left_type = left.infer_type();
|
|
let right_type = right.infer_type();
|
|
if vec![Greater, Less, GreaterEqual, LessEqual].contains(&operator.token_type) {
|
|
Bool
|
|
} else if left_type == right_type {
|
|
// map to determined numeric type if yet undetermined (32 or 64 bits)
|
|
match left_type {
|
|
FloatingPoint => F64,
|
|
Integer => I64,
|
|
_ => left_type,
|
|
}
|
|
} else {
|
|
if let Plus = operator.token_type {
|
|
// includes string concatenation with numbers
|
|
// followed by type coercion to 64 bits for numeric types
|
|
debug!("coerce {} : {}", left_type, right_type);
|
|
match (left_type, right_type) {
|
|
(_, StringType) => StringType,
|
|
(StringType, _) => StringType,
|
|
(FloatingPoint, _) => F64,
|
|
(Integer, FloatingPoint) => F64,
|
|
(Integer, _) => I64,
|
|
(I64, Integer) => I64,
|
|
(F64, _) => F64,
|
|
(U64, U32) => U64,
|
|
(I64, I32) => I64,
|
|
// could add a date and a duration. future work
|
|
// could add a List and a value. also future work
|
|
// could add a Map and a tuple. Will I add tuple types? Future work!
|
|
_ => panic!("Unexpected coercion"),
|
|
}
|
|
// could have done some fall through here, but this will fail less gracefully,
|
|
// so if my thinking is wrong or incomplete it will panic
|
|
} else {
|
|
// type coercion to 64 bits for numeric types
|
|
debug!("coerce {} : {}", left_type, right_type);
|
|
match (left_type, right_type) {
|
|
(FloatingPoint, _) => F64,
|
|
(Integer, FloatingPoint) => F64,
|
|
(Integer, I64) => I64,
|
|
(I64, FloatingPoint) => F64,
|
|
(F64, _) => F64,
|
|
(U64, U32) => U64,
|
|
(I64, I32) => I64,
|
|
(I64, Integer) => I64,
|
|
_ => panic!("Unexpected coercion"),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Expression::Grouping { expression, .. } => expression.infer_type(),
|
|
Expression::Literal { literaltype, .. } => literaltype.clone(),
|
|
Expression::List { literaltype, .. } => literaltype.clone(),
|
|
Expression::Map { literaltype, .. } => literaltype.clone(),
|
|
Expression::Unary {
|
|
right, operator, ..
|
|
} => {
|
|
let literal_type = right.infer_type();
|
|
if literal_type == Integer && operator.token_type == Minus {
|
|
SignedInteger
|
|
} else {
|
|
UnsignedInteger
|
|
}
|
|
}
|
|
Expression::Variable { var_type, .. } => var_type.clone(),
|
|
Expression::Stop { .. } => TokenType::Unknown,
|
|
// Expression::PathMatch { .. } => TokenType::Unknown,
|
|
Expression::NamedParameter { .. } => TokenType::Unknown,
|
|
Expression::ListGet { .. } => TokenType::Unknown,
|
|
Expression::MapGet { .. } => TokenType::Unknown,
|
|
Expression::FieldGet { .. } => TokenType::Unknown,
|
|
FunctionCall { .. } => TokenType::Unknown,
|
|
}
|
|
}
|
|
}
|