109 lines
3.1 KiB
Rust
109 lines
3.1 KiB
Rust
pub mod expression_node;
|
|
pub mod operator;
|
|
|
|
mod binary_expr;
|
|
mod block_expr;
|
|
mod grouping_expr;
|
|
mod literal_expr;
|
|
mod unary_expr;
|
|
mod variable_expr;
|
|
|
|
pub use binary_expr::BinaryExpr;
|
|
pub use block_expr::BlockExpr;
|
|
pub use grouping_expr::GroupingExpr;
|
|
pub use literal_expr::Literal;
|
|
pub use unary_expr::UnaryExpr;
|
|
pub use variable_expr::VariableExpr;
|
|
|
|
use super::parser::{InnerASTParsingError, Parser, Result};
|
|
use crate::lexer::token::{self, TokenType};
|
|
use itertools::PeekingNext;
|
|
|
|
use from_variants::FromVariants;
|
|
use match_any::match_any;
|
|
use std::fmt::Debug;
|
|
|
|
#[derive(FromVariants)]
|
|
pub enum ExpressionNode {
|
|
BinaryExpr(BinaryExpr),
|
|
GroupingExpr(GroupingExpr),
|
|
Literal(Literal),
|
|
Variable(VariableExpr),
|
|
UnaryExpr(UnaryExpr),
|
|
BlockExpr(BlockExpr),
|
|
}
|
|
|
|
macro_rules! all_variants {
|
|
($expr:expr, $val_name:ident => $expr_arm:expr) => {
|
|
{
|
|
use match_any::match_any;
|
|
use $crate::ast::expression::*;
|
|
match_any!($expr,
|
|
ExpressionNode::BinaryExpr($val_name) |
|
|
ExpressionNode::GroupingExpr($val_name) |
|
|
ExpressionNode::Literal($val_name) |
|
|
ExpressionNode::Variable($val_name) |
|
|
ExpressionNode::BlockExpr($val_name) |
|
|
ExpressionNode::UnaryExpr($val_name) => $expr_arm)
|
|
}
|
|
};
|
|
}
|
|
pub(crate) use all_variants;
|
|
|
|
impl Debug for ExpressionNode {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
all_variants!(self, n => n.fmt(f))
|
|
}
|
|
}
|
|
|
|
impl<'a, T: Iterator<Item = token::Token<'a>>> Parser<'a, T> {
|
|
pub fn expression(&mut self) -> Result<ExpressionNode> {
|
|
self.block_expr()
|
|
}
|
|
pub(super) fn primary(&mut self) -> Result<ExpressionNode> {
|
|
let token = self.token_iter.next();
|
|
let node = match token.token_type {
|
|
TokenType::False => ExpressionNode::Literal(Literal::Bool(false)),
|
|
TokenType::True => ExpressionNode::Literal(Literal::Bool(true)),
|
|
TokenType::Int(i) => ExpressionNode::Literal(Literal::Int(i)),
|
|
TokenType::String(i) => ExpressionNode::Literal(Literal::String(i)),
|
|
TokenType::Float(f) => ExpressionNode::Literal(Literal::Float(f)),
|
|
TokenType::Nil => ExpressionNode::Literal(Literal::Nil),
|
|
TokenType::LeftParen => {
|
|
let expr = self.expression()?;
|
|
let group = GroupingExpr::new(Box::new(expr));
|
|
match self
|
|
.token_iter
|
|
.peeking_next(|v| matches!(v.token_type, TokenType::RightParen))
|
|
{
|
|
Some(_) => return Ok(group.into()),
|
|
None => return Err(token.location.wrap(InnerASTParsingError::UnmatchedBrace)),
|
|
}
|
|
}
|
|
TokenType::Identifier(var_name) => VariableExpr::new(var_name).into(),
|
|
a => return Err(token.location.wrap(InnerASTParsingError::IncorrectToken(a))),
|
|
};
|
|
Ok(node)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use operator::{Operator, UnaryOperator};
|
|
|
|
#[test]
|
|
fn expression_node_ast_printer() {
|
|
let ast = ExpressionNode::BinaryExpr(BinaryExpr {
|
|
left: Box::new(ExpressionNode::UnaryExpr(UnaryExpr {
|
|
operator: UnaryOperator::Bang,
|
|
right: Box::new(ExpressionNode::Literal(Literal::Int(1))),
|
|
})),
|
|
operator: Operator::EqualEqual,
|
|
right: Box::new(ExpressionNode::Literal(Literal::Int(0))),
|
|
});
|
|
let formated = format!("{:?}", ast);
|
|
assert_eq!("(== (! Int(1)) Int(0))", formated);
|
|
}
|
|
}
|