LunarAkai/AkaiLang
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

better ast

Browse source
This commit is contained in:
LunarAkai 2025-08-07 14:19:26 +02:00
commit 55605d2cd1
4 changed files with 292 additions and 174 deletions
Download patch file Download diff file Expand all files Collapse all files

213
src/language_frontend/abstract_syntax_tree/ast.rs
View file

@ -1,95 +1,134 @@
use std::rc::Rc;
/// Abstract Syntax Tree /// Abstract Syntax Tree
pub type BlockStatement = Vec<Statement>;
#[derive(Clone, Debug)]
pub enum Expr {
Ident(Ident),
Literal(Literal),
Call(FunctionCall),
}
#[derive(Clone, Debug)]
pub struct FunctionCall {
pub parameters: Vec<Expr>,
pub name: Rc<str>,
}
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum Expression<'src> { pub enum ExprResult {
// Identifier
Ident(&'src str),
// Types
Integer(i64),
Float(f64),
String(String),
Bool(bool), Bool(bool),
UnsignedInteger(usize),
// Operations SignedInteger(isize),
Negatation(Box<Expression<'src>>), Char(char),
Add(Box<Expression<'src>>, Box<Expression<'src>>), Return(Box<ExprResult>),
Substract(Box<Expression<'src>>, Box<Expression<'src>>), Void,
Multiply(Box<Expression<'src>>, Box<Expression<'src>>),
Divide(Box<Expression<'src>>, Box<Expression<'src>>),
// Keywords
Var {
name: &'src str,
rhs: Box<Expression<'src>>,
then: Box<Expression<'src>>,
},
Function {
name: &'src str,
args: Vec<&'src str>,
body: Box<Expression<'src>>,
then: Box<Expression<'src>>,
},
Unit,
} }
pub fn eval<'src>( impl std::fmt::Display for ExprResult {
expr: &'src Expression<'src>, fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
vars: &mut Vec<(&'src str, f64)>, match self {
funcs: &mut Vec<(&'src str, &'src [&'src str], &'src Expression<'src>)>, ExprResult::Bool(b) => write!(f, "{b}"),
) -> Result<f64, String> { ExprResult::UnsignedInteger(i) => write!(f, "{i}"),
match expr { ExprResult::SignedInteger(i) => write!(f, "{i}"),
Expression::Ident(name) => { ExprResult::Char(c) => write!(f, "{c}"),
if let Some((_, val)) = vars.iter().rev().find(|(var, _)| var == name) { ExprResult::Return(v) => write!(f, "{}", *v),
Ok(*val) ExprResult::Void => write!(f, ""),
} else { }
Err(format!("Cannot find variable `{name}` in scope"))
}
},
// Types
Expression::Integer(x) => Ok((*x) as f64), // todo
Expression::Float(x) => Ok(*x),
Expression::String(_) => todo!(),
Expression::Bool(_) => todo!(),
// Operations
Expression::Negatation(lhs) => todo!(),
Expression::Add(lhs, rhs) => Ok(eval(lhs, vars, funcs)? + eval(rhs, vars, funcs)?),
Expression::Substract(lhs, rhs) => Ok(eval(lhs, vars, funcs)? - eval(rhs, vars, funcs)?),
Expression::Multiply(lhs, rhs) => Ok(eval(lhs, vars, funcs)? * eval(rhs, vars, funcs)?),
Expression::Divide(lhs, rhs) => Ok(eval(lhs, vars, funcs)? / eval(rhs, vars, funcs)?),
// Keywords
Expression::Var { name, rhs, then } => {
let rhs = eval(rhs, vars, funcs)?;
vars.push((*name, rhs));
let output = eval(then, vars, funcs);
vars.pop();
output
},
Expression::Function {
name,
args,
body,
then,
} => {
funcs.push((name, args, body));
let output = eval(then, vars, funcs);
funcs.pop();
output
},
Expression::Unit => todo!(),
} }
} }
#[derive(Clone, Debug)]
pub enum BinaryOp {
Multiply,
Divide,
Add,
Substract,
Equals,
NotEquals,
Less,
LessEquals,
Greater,
GreaterEquals,
And,
Or,
}
#[derive(Clone, Debug)]
pub enum UnaryOp {
Not,
Minus,
Plus,
}
#[derive(Clone, Debug)]
pub enum Literal {
UnsignedInteger(usize),
Bool(bool),
Char(char),
String(Rc<str>),
}
#[derive(Clone, Debug)]
pub struct Ident(pub Rc<str>);
#[derive(Clone, Debug)]
pub enum Statement {
Var(Ident, Option<Type>)
}
#[derive(Clone, Debug)]
pub struct While {
pub condition: Expr,
pub body: BlockStatement,
}
#[derive(Clone, Debug)]
pub struct Condition {
pub condition: Expr,
pub if_body: BlockStatement,
pub else_body: Option<BlockStatement>,
}
#[derive(Clone, Debug)]
pub enum Type {
UnsignedInteger,
SignedInteger,
Bool,
Char,
String,
}
pub enum Value {
UnsignedInteger(u32),
SignedInteger(i32),
Bool(bool),
Char(char),
String(String),
}
impl Value {
pub fn is_type(&self, ty: &Type) -> bool {
match (ty, self) {
(Type::Bool, Value::Bool(_)) => true,
(Type::Char, Value::Char(_)) => true,
(Type::SignedInteger, Value::SignedInteger(_)) => true,
(Type::UnsignedInteger, Value::UnsignedInteger(_)) => true,
(Type::String, Value::String(_)) => true,
_ => false,
}
}
}
#[derive(Clone, Debug)]
pub struct Function {
pub name: Rc<str>,
pub params: Vec<(Ident, Type)>,
pub return_type: Option<Type>,
pub body: Vec<Statement>,
}

19
src/language_frontend/abstract_syntax_tree/op.rs
View file

@ -1,19 +0,0 @@
#[derive(Debug, Clone)]
pub enum Op {
Add,
Subtract,
Multiply,
Divide,
}
impl Op {
pub fn eval(&self) -> String {
let text: &str = match self {
Op::Add => "+",
Op::Subtract => "-",
Op::Multiply => "*",
Op::Divide => "/",
};
text.to_string()
}
}

232
src/language_frontend/lexer/tokens.rs
View file

@ -1,26 +1,96 @@
use std::fmt; use std::fmt;
use logos::{Lexer, Logos}; use logos::{Logos};
#[derive(Logos, Debug, Clone, PartialEq)] #[derive(Logos, Debug, Clone, PartialEq)]
#[logos(skip r"[ \r\f]+")] // Skip whitespace pub enum Token {
pub enum Token<'src> {
Error, Error,
Null,
Indent, // Identifier
NewLine, #[regex(r"[a-zA-Z_][a-zA-Z0-9_]*", |lex| lex.slice().to_owned())]
Dedent, Identifier(String),
// Keywords
#[token("fun")]
Fun,
#[token("class")]
Class,
#[token("var")]
Var,
#[token("interface")]
Interface,
#[token("derive")]
Derive,
#[token("impl")]
Impl,
#[token("if")]
If,
#[token("else")]
Else,
#[token("->")]
Return,
#[token("enum")]
Enum,
// Types
#[token("int")]
IntType,
#[token("float")]
FloatType,
#[token("bool")]
BoolType,
#[token("String")]
StringType,
// Literals
#[regex(r#""([^"\\]|\\.)*""#, |lex| lex.slice().to_owned())]
StringLiteral(String),
#[regex(r"[0-9]+", |lex| lex.slice().parse::<i64>().ok())]
IntLiteral(i64),
#[regex(r"[0-9]+\.[0-9]+", |lex| lex.slice().parse::<f64>().ok())]
FloatLiteral(f64),
#[token("false", |_| false)]
#[token("true", |_| true)] #[token("true", |_| true)]
Bool(bool), #[token("false", |_| false)]
BoolLiteral(bool),
#[token("+")] // Operators
Add, #[token("=")]
Assign,
#[token("==")]
Equals,
#[token("-")] #[token("!=")]
Substract, NotEquals,
#[token("<", priority = 2)]
Less,
#[token("<=")]
LessEquals,
#[token(">", priority = 2)]
Greater,
#[token(">=")]
GreaterEquals,
#[token("*")] #[token("*")]
Multiply, Multiply,
@ -28,70 +98,98 @@ pub enum Token<'src> {
#[token("/")] #[token("/")]
Divide, Divide,
#[token("=")] #[token("+")]
Equals, Add,
#[token("-")]
Substract,
#[token("&&")]
And,
#[token("||")]
Or,
// Punctiuation
#[token("(")]
LParen,
#[token(")")]
RParen,
#[token("{")]
LBrace,
#[token("}")]
RBrace,
#[token("[")]
LBracket,
#[token("]")]
RBracket,
#[token(":")] #[token(":")]
Colon, Colon,
#[token("(")] // Special
ParenBegin, #[regex(r"//[^\n\r]*", logos::skip)]
#[regex(r"/\*([^*]|\*[^/])*\*/", logos::skip)]
#[token(")")] Comment,
ParenEnd,
#[regex(r"[ \t\n\f]+", logos::skip)]
#[token("{")] Whitespace,
BraceBegin,
Eof,
#[token("}")]
BraceEnd,
#[regex(r"[+-]?[0-9]+", |lex| lex.slice().parse::<i64>().unwrap(), priority = 3)]
Integer(i64),
#[regex(r"[+-]?([0-9]*[.])?[0-9]+", |lex| lex.slice().parse::<f64>().unwrap())]
Float(f64),
#[regex(r"[_a-zA-Z][_0-9a-zA-Z]*")]
Ident(&'src str),
#[regex(r#""([^"\\\x00-\x1F]|\\(["\\bnfrt/]|u[a-fA-F0-9]{4}))*""#, |lex| lex.slice().to_owned())]
String(String),
#[token("class")]
#[token("fun")]
#[token("var")]
#[token("if")]
#[token("else")]
Keyword(&'src str),
} }
impl fmt::Display for Token {
impl fmt::Display for Token<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
Token::Float(s) => write!(f, "{s}"), Token::Identifier(ident) => write!(f, "{ident}"),
Token::Null => write!(f, "<null>"), Token::Fun => write!(f, "fun"),
Token::Indent => write!(f, "<indent>"), Token::Class => write!(f, "class"),
Token::NewLine => write!(f, "<new_line>"), Token::Var => write!(f, "var"),
Token::Dedent => write!(f, "<dedent>"), Token::Interface => write!(f, "interface"),
Token::Add => write!(f, "+"), Token::Derive => write!(f, "derive"),
Token::Bool(_) => write!(f, "+"), Token::Impl => write!(f, "impl"),
Token::Substract => write!(f, "-"), Token::If => write!(f, "if"),
Token::Else => write!(f, "else"),
Token::Return => write!(f, "->"),
Token::Enum => write!(f, "enum"),
Token::IntType => write!(f, "int"),
Token::FloatType => write!(f, "float"),
Token::BoolType => write!(f, "bool"),
Token::StringType => write!(f, "String"),
Token::StringLiteral(s) => write!(f, "{s}"),
Token::IntLiteral(i) => write!(f, "{i}"),
Token::FloatLiteral(fl) => write!(f, "{fl}"),
Token::BoolLiteral(b) => write!(f, "{b}"),
Token::Assign => write!(f, "="),
Token::Equals => write!(f, "=="),
Token::NotEquals => write!(f, "!="),
Token::Less => write!(f, "<"),
Token::LessEquals => write!(f, "<="),
Token::Greater => write!(f, ">"),
Token::GreaterEquals => write!(f, ">="),
Token::Multiply => write!(f, "*"), Token::Multiply => write!(f, "*"),
Token::Divide => write!(f, "/"), Token::Divide => write!(f, "/"),
Token::Equals => write!(f, "="), Token::Add => write!(f, "+"),
Token::Substract => write!(f, "-"),
Token::And => write!(f, "&&"),
Token::Or => write!(f, "||"),
Token::LParen => write!(f, "("),
Token::RParen => write!(f, ")"),
Token::LBrace => write!(f, "{{"),
Token::RBrace => write!(f, "}}"),
Token::LBracket => write!(f, "["),
Token::RBracket => write!(f, "]"),
Token::Colon => write!(f, ":"), Token::Colon => write!(f, ":"),
Token::ParenBegin => write!(f, "("), Token::Comment => write!(f, ""),
Token::ParenEnd => write!(f, ")"), Token::Whitespace => write!(f, ""),
Token::BraceBegin => write!(f, "{{"), Token::Eof => write!(f, ""),
Token::BraceEnd => write!(f, "}}"),
Token::Integer(s) => write!(f, "{s}"),
Token::Ident(s) => write!(f, "{s}"),
Token::String(s) => write!(f, "{s}"),
Token::Keyword(s) => write!(f, "{s}"),
Token::Error => write!(f, "<error>"), Token::Error => write!(f, "<error>"),
} }
} }
} }

2
src/main.rs
View file

@ -5,7 +5,7 @@ use logos::Logos;
use crate::{ use crate::{
language_frontend::lexer::tokens::Token, language_frontend::abstract_syntax_tree::parser::parser}; language_frontend::lexer::tokens::Token, language_frontend::abstract_syntax_tree::parser::parser};
use crate::language_frontend::abstract_syntax_tree::ast::{eval, Expression}; use crate::language_frontend::abstract_syntax_tree::ast::{Expr};
mod language_frontend; mod language_frontend;