107 lines
2.8 KiB
Rust
107 lines
2.8 KiB
Rust
use super::ast::*;
|
|
use crate::lex::tok::*;
|
|
use logos::Lexer;
|
|
use std::rc::Rc;
|
|
|
|
#[macro_export]
|
|
macro_rules! unwrap {
|
|
($var:expr) => {
|
|
$var.next().unwrap().unwrap()
|
|
}
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! parse_value {
|
|
($parse:expr) => {
|
|
parse_value(&($parse.next(), $parse.slice()))
|
|
}
|
|
}
|
|
|
|
pub fn parse_math(mut tokens: Lexer<Token>) -> Option<Expr> {
|
|
// Is it a Value? → Is it an operator? → Is it a value?
|
|
|
|
if let Some(left) = parse_value!(tokens) {
|
|
if let Some(operator) = match_operator(&mut tokens) {
|
|
if let Some(right) = parse_value!(tokens) {
|
|
let left = Rc::new(left);
|
|
let right = Rc::new(right);
|
|
|
|
return Some(Expr::MathExpr(Math {left: left, right: right, operator}))
|
|
}
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub fn parse_var_declaration(mut tokens: Lexer<Token>) -> Option<Expr> {
|
|
let mut tok = None;
|
|
if unwrap!(tokens) == Let {
|
|
if unwrap!(tokens) == Identifier {
|
|
let name = tokens.slice();
|
|
|
|
println!("{:?}", name);
|
|
if unwrap!(tokens) == Equal {
|
|
let temp_token = unwrap!(tokens);
|
|
if let Number(n) = temp_token {
|
|
let value = Value::Number(n);
|
|
println!("{:?}", value);
|
|
tok = Some(Expr::VarDefinition(VarDefinition {name, value}));
|
|
} else if temp_token == Identifier {
|
|
let value = Value::Var(VarReference { name: tokens.slice() });
|
|
tok = Some(Expr::VarDefinition(VarDefinition {name, value}));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tok
|
|
}
|
|
|
|
pub fn parse_value<'a>(token: &(Option<Result<Token, ()>>, &'a str)) -> Option<Value<'a>> {
|
|
if let Some(Ok(tt)) = &token.0 {
|
|
let mut value = None;
|
|
|
|
if let Number(n) = tt {
|
|
value = Some(Value::Number(*n));
|
|
} else if *tt == Identifier {
|
|
value = Some(Value::Var(VarReference { name: token.1 }));
|
|
}
|
|
|
|
value
|
|
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
|
|
pub fn parse_fun_call(mut tokens: Lexer<Token>) -> Option<Expr> {
|
|
// Is it an Ident? → Is it a LeftParen? → Is it a value (I should really make a function to parse that) or is it a RightParen?
|
|
// ↓ ↓
|
|
// If it's a value, push that to `params`. Otherwise, params will just be a `Vec::new()`.
|
|
let mut tok = None;
|
|
|
|
if unwrap!(tokens) == Identifier {
|
|
let name = tokens.slice();
|
|
if unwrap!(tokens) == LeftParen {
|
|
let mut params = Vec::new();
|
|
while let Some(value) = parse_value!(tokens) {
|
|
params.push(value);
|
|
}
|
|
tok = Some(Expr::FunCall(FunCall {name, params: params.clone()}));
|
|
}
|
|
}
|
|
|
|
tok
|
|
}
|
|
|
|
pub fn match_operator(tokens: &mut Lexer<Token>) -> Option<MathOperator> {
|
|
match unwrap!(tokens) {
|
|
Plus => Some(MathOperator::OP_ADD),
|
|
Minus => Some(MathOperator::OP_SUB),
|
|
Slash => Some(MathOperator::OP_DIV),
|
|
Star => Some(MathOperator::OP_MULT),
|
|
Percent => Some(MathOperator::OP_MOD),
|
|
_ => None
|
|
}
|
|
}
|