91 lines
2.7 KiB
Rust
91 lines
2.7 KiB
Rust
use chumsky::{
|
|
combinator::Or, prelude::{choice, just, recursive}, recursive, select, select_ref, text::{self, ascii::ident, whitespace}, IterParser, Parser
|
|
};
|
|
|
|
use crate::{language_frontend::abstract_syntax_tree::ast::Expression, language_frontend::lexer::tokens::Token};
|
|
|
|
// goal of parsing is to construct an abstract syntax tree
|
|
|
|
#[allow(clippy::let_and_return)]
|
|
pub fn parser<'src>() -> impl Parser<'src, &'src [Token<'src>], Expression<'src>> {
|
|
let ident = select_ref! {
|
|
Token::Ident(ident) => *ident
|
|
};
|
|
|
|
let keyword = |kw: &'static str| {
|
|
select! {
|
|
Token::Keyword(k) if k == kw => ()
|
|
}
|
|
};
|
|
|
|
let eq = just(Token::Equals);
|
|
|
|
let expr = recursive(|expr| {
|
|
let atom = select! {
|
|
Token::Float(x) => Expression::Float(x),
|
|
|
|
};
|
|
|
|
let unary = just(Token::Substract)
|
|
.repeated()
|
|
.foldr(atom, |_op, rhs| Expression::Negatation(Box::new(rhs)));
|
|
|
|
// "Punktrechnung vor Strichrechnung :nerd:"
|
|
|
|
let binary_1 = unary.clone().foldl(
|
|
just(Token::Multiply)
|
|
.or(just(Token::Divide))
|
|
.then(unary)
|
|
.repeated(),
|
|
|lhs, (op, rhs)| match op {
|
|
Token::Multiply => Expression::Multiply(Box::new(lhs), Box::new(rhs)),
|
|
Token::Divide => Expression::Divide(Box::new(lhs), Box::new(rhs)),
|
|
_ => unreachable!(),
|
|
},
|
|
);
|
|
|
|
let binary_2 = binary_1.clone().foldl(
|
|
just(Token::Add)
|
|
.or(just(Token::Substract))
|
|
.then(binary_1)
|
|
.repeated(),
|
|
|lhs, (op, rhs)| match op {
|
|
Token::Add => Expression::Add(Box::new(lhs), Box::new(rhs)),
|
|
Token::Substract => Expression::Substract(Box::new(lhs), Box::new(rhs)),
|
|
_ => unreachable!(),
|
|
},
|
|
);
|
|
|
|
binary_2
|
|
});
|
|
|
|
let decl = recursive(|decl| {
|
|
let r#var = keyword("var")
|
|
.ignore_then(ident)
|
|
.then_ignore(eq.clone())
|
|
.then(expr.clone())
|
|
.then(decl.clone())
|
|
.map(|((name, rhs), then)| Expression::Var {
|
|
name,
|
|
rhs: Box::new(rhs),
|
|
then: Box::new(then),
|
|
});
|
|
|
|
let r#fun = keyword("fun")
|
|
.ignore_then(ident.clone())
|
|
.then(ident.repeated().collect::<Vec<_>>())
|
|
.then_ignore(eq.clone())
|
|
.then(expr.clone())
|
|
.then(decl)
|
|
.map(|(((name, args), body), then)| Expression::Function {
|
|
name,
|
|
args,
|
|
body: Box::new(body),
|
|
then: Box::new(then),
|
|
});
|
|
|
|
var.or(r#fun).or(expr)
|
|
});
|
|
|
|
decl
|
|
}
|