You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
154 lines
5.1 KiB
Rust
154 lines
5.1 KiB
Rust
pub(crate) mod tree;
|
|
|
|
use crate::error::Error;
|
|
use crate::lex::token;
|
|
use crate::lex::token::Token;
|
|
use crate::lex::Lexer;
|
|
|
|
use std::fs;
|
|
use std::io;
|
|
|
|
enum Scope {
|
|
File,
|
|
Module,
|
|
DepList,
|
|
SourceList,
|
|
}
|
|
|
|
struct Parser {
|
|
lexer: Lexer,
|
|
scope: Vec<Scope>,
|
|
filename: String,
|
|
}
|
|
|
|
pub fn parse(filename: String) -> io::Result<Result<tree::Node, Error>> {
|
|
let raw: String = fs::read_to_string(filename.clone())?;
|
|
let mut p = Parser::new(filename, raw);
|
|
Ok(p.parse_file())
|
|
}
|
|
|
|
impl Parser {
|
|
pub fn new(filename: String, raw: String) -> Parser {
|
|
let lexer = Lexer::new(filename.clone(), raw);
|
|
Parser {
|
|
lexer,
|
|
scope: Vec::new(),
|
|
filename,
|
|
}
|
|
}
|
|
|
|
pub fn parse_file(&mut self) -> Result<tree::Node, Error> {
|
|
let mut nodes = Vec::new();
|
|
self.scope.push(Scope::File);
|
|
|
|
while let Some(result) = self.lexer.next() {
|
|
let token = result?;
|
|
let node = match token.kind {
|
|
token::Kind::ModuleKeyword => self.parse_module(),
|
|
token::Kind::SetKeyword => self.parse_set_expr(),
|
|
_ => self.syntax_error(format!("Unexpected token {}", token.kind), &token),
|
|
}?;
|
|
nodes.push(node);
|
|
}
|
|
|
|
Ok(tree::Node::File {
|
|
name: self.filename.clone(),
|
|
content: nodes,
|
|
})
|
|
}
|
|
|
|
fn parse_module(&mut self) -> Result<tree::Node, Error> {
|
|
self.scope.push(Scope::Module);
|
|
let name_token = self.lexer.expect_kind(token::Kind::Ident)?;
|
|
self.lexer.expect_kind(token::Kind::OBrace)?;
|
|
|
|
let mut children = Vec::new();
|
|
|
|
while let Some(result) = self.lexer.next() {
|
|
let token = result?;
|
|
match token.kind {
|
|
token::Kind::DependKeyword => children.push(self.parse_depend_expr()?),
|
|
token::Kind::TypeKeyword => children.push(self.parse_type_expr()?),
|
|
token::Kind::SourceKeyword => children.push(self.parse_source_expr()?),
|
|
token::Kind::SetKeyword => children.push(self.parse_set_expr()?),
|
|
token::Kind::CBrace => break,
|
|
_ => {
|
|
return self.syntax_error(format!("Unexpected token \"{}\"", token.raw), &token)
|
|
}
|
|
}
|
|
}
|
|
|
|
self.scope.pop();
|
|
Ok(tree::Node::Module {
|
|
name: Box::new(tree::Node::Ident(name_token.raw)),
|
|
content: children,
|
|
})
|
|
}
|
|
|
|
fn parse_depend_expr(&mut self) -> Result<tree::Node, Error> {
|
|
self.scope.push(Scope::DepList);
|
|
let rvalue = self.parse_rvalue(&[token::Kind::Semi])?;
|
|
self.scope.pop();
|
|
Ok(tree::Node::DepList(Box::new(rvalue)))
|
|
}
|
|
|
|
fn parse_set_expr(&mut self) -> Result<tree::Node, Error> {
|
|
let lvalue = self.parse_lvalue(&[token::Kind::Eq])?;
|
|
let rvalue = self.parse_rvalue(&[token::Kind::Semi])?;
|
|
Ok(tree::Node::SetExpr {
|
|
name: Box::new(lvalue),
|
|
val: Box::new(rvalue),
|
|
})
|
|
}
|
|
|
|
fn parse_type_expr(&mut self) -> Result<tree::Node, Error> {
|
|
let rvalue = self.parse_rvalue(&[token::Kind::Semi])?;
|
|
Ok(tree::Node::TypeExpr(Box::new(rvalue)))
|
|
}
|
|
|
|
fn parse_source_expr(&mut self) -> Result<tree::Node, Error> {
|
|
self.scope.push(Scope::SourceList);
|
|
let rvalue = self.parse_rvalue(&[token::Kind::Semi])?;
|
|
self.scope.pop();
|
|
Ok(tree::Node::SourceList(Box::new(rvalue)))
|
|
}
|
|
|
|
fn parse_array(&mut self) -> Result<tree::Node, Error> {
|
|
let mut elements = Vec::new();
|
|
while let Some(result) = self.lexer.peek() {
|
|
if result?.kind == token::Kind::CBracket {
|
|
self.lexer.next();
|
|
break;
|
|
} else {
|
|
elements.push(self.parse_rvalue(&[token::Kind::Comma, token::Kind::CBracket])?);
|
|
}
|
|
}
|
|
Ok(tree::Node::Array(elements))
|
|
}
|
|
|
|
fn parse_lvalue(&mut self, terminators: &[token::Kind]) -> Result<tree::Node, Error> {
|
|
// this will be expanded when we have array accesses and similar stuff
|
|
let ident_token = self.lexer.expect_kind(token::Kind::Ident)?;
|
|
self.lexer.expect_kinds(terminators)?;
|
|
Ok(tree::Node::Ident(ident_token.raw))
|
|
}
|
|
|
|
fn parse_rvalue(&mut self, terminators: &[token::Kind]) -> Result<tree::Node, Error> {
|
|
// this will also be expanded to support more complex expressions, naturally
|
|
let token = self.lexer.require_next()?;
|
|
let node = match token.kind {
|
|
token::Kind::Ident => Ok(tree::Node::Ident(token.raw)),
|
|
token::Kind::IntLiteral => Ok(tree::Node::Int(token.raw.parse().unwrap())),
|
|
token::Kind::StringLiteral => Ok(tree::Node::String(token.raw)),
|
|
token::Kind::OBracket => self.parse_array(),
|
|
k => self.syntax_error(format!("Unexpected {}", k), &token),
|
|
}?;
|
|
self.lexer.expect_kinds(terminators)?;
|
|
Ok(node)
|
|
}
|
|
|
|
fn syntax_error<T>(&self, msg: String, token: &Token) -> Result<T, Error> {
|
|
Err(Error::syntax_error(token.pos.clone(), msg))
|
|
}
|
|
}
|