275 lines
12 KiB
Rust
275 lines
12 KiB
Rust
use crate::lexer::{Token, TokenType};
|
|
use once_cell::sync::Lazy;
|
|
use regex::Regex;
|
|
use std::{collections::HashMap, fmt};
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub enum AstType {
|
|
Ref,
|
|
FunctionDeceleration,
|
|
StructDeceleration,
|
|
StructCall,
|
|
StructVar,
|
|
VoidFunctionDeceleration,
|
|
Namespace,
|
|
VariableDeceleration,
|
|
PointerDeceleration,
|
|
MutVariableDeceleration,
|
|
State3,
|
|
State2,
|
|
Include,
|
|
IncludeLocal,
|
|
CodeBlock,
|
|
Json,
|
|
Impl,
|
|
Other,
|
|
}
|
|
|
|
pub struct Ast {
|
|
pub tokens: Vec<Token>,
|
|
pub ast_type: AstType,
|
|
}
|
|
|
|
impl fmt::Display for Ast {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(f, "\x1b[36m{:?}:\x1b[0m [\n", self.ast_type)?;
|
|
for (i, token) in self.tokens.iter().enumerate() {
|
|
if i < self.tokens.len() - 1 {
|
|
write!(f, " {},\n", token)?;
|
|
} else {
|
|
write!(f, " {}\n", token)?;
|
|
}
|
|
}
|
|
write!(f, "]")
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for Ast {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(f, "{:?}: [\n", self.ast_type)?;
|
|
for (i, token) in self.tokens.iter().enumerate() {
|
|
if i < self.tokens.len() - 1 {
|
|
write!(f, " {:?},\n", token)?;
|
|
} else {
|
|
write!(f, " {:?}\n", token)?;
|
|
}
|
|
}
|
|
write!(f, "]")
|
|
}
|
|
}
|
|
|
|
pub struct Parser {
|
|
pub tokens: Vec<Token>,
|
|
pub index: u32,
|
|
pub include_regex: Lazy<Regex>,
|
|
pub include_regex_local: Lazy<Regex>,
|
|
pub json: bool,
|
|
pub variables: HashMap<String, Variable>,
|
|
}
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum VariableType {
|
|
Func,
|
|
Var,
|
|
}
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub struct Variable {
|
|
pub vtype: VariableType,
|
|
pub indent: u32,
|
|
pub line: usize,
|
|
pub column: usize,
|
|
}
|
|
|
|
impl Parser {
|
|
pub fn new(tokens: Vec<Token>, variables: HashMap<String, Variable>) -> Parser {
|
|
Parser {
|
|
tokens: tokens,
|
|
index: 0,
|
|
include_regex: Lazy::new(|| Regex::new(r"^(#include *)<(.*?)>").unwrap()),
|
|
include_regex_local: Lazy::new(|| Regex::new(r#"^(#include *)"(.*?)""#).unwrap()),
|
|
variables: variables,
|
|
json: false,
|
|
}
|
|
}
|
|
pub fn parse(&mut self) -> Vec<Ast> {
|
|
let mut full_ast: Vec<Ast> = Vec::new();
|
|
while self.tokens.len() > self.index as usize {
|
|
let mut ast_res: Ast = Ast {
|
|
tokens: vec![],
|
|
ast_type: AstType::Other,
|
|
};
|
|
let index = self.index as usize;
|
|
if index == self.tokens.len() {
|
|
panic!("Reached the end of tokens")
|
|
}
|
|
let token = &self.tokens[index];
|
|
if self.json
|
|
&& self.tokens.len() - (self.index as usize) > 2
|
|
&& self.tokens[index + 1].value == ":"
|
|
{
|
|
ast_res.ast_type = AstType::Json;
|
|
ast_res.tokens.push(self.tokens[index].clone());
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
self.index += 2;
|
|
} else if self.tokens.len() - index > 1
|
|
&& self.tokens[index].value == "&"
|
|
&& self.tokens[index + 1].token_type == TokenType::Identifier
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.ast_type = AstType::Ref;
|
|
self.index += 1;
|
|
} else if self.tokens.len() - index > 2
|
|
&& self.tokens[index].value == "struct"
|
|
&& self.tokens[index + 1].token_type == TokenType::Identifier
|
|
&& self.tokens[index + 2].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
ast_res.ast_type = AstType::StructDeceleration;
|
|
self.index += 2;
|
|
} else if self.tokens.len() - index > 2
|
|
&& self.tokens[index].value == "namespace"
|
|
&& self.tokens[index + 1].token_type == TokenType::Identifier
|
|
&& self.tokens[index + 2].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
ast_res.ast_type = AstType::Namespace;
|
|
self.index += 2;
|
|
} else if self.tokens.len() - index > 2
|
|
&& self.tokens[index].value == "impl"
|
|
&& self.tokens[index + 1].token_type == TokenType::Identifier
|
|
&& self.tokens[index + 2].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
ast_res.ast_type = AstType::Impl;
|
|
self.index += 2;
|
|
} else if self.tokens.len() - index > 2
|
|
&& self.tokens[index].token_type == TokenType::Keyword1
|
|
&& self.tokens[index + 1].token_type == TokenType::Round
|
|
&& self.tokens[index + 2].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index].clone());
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
ast_res.ast_type = AstType::State3;
|
|
self.index += 2;
|
|
} else if self.tokens.len() - index > 1
|
|
&& self.tokens[index].token_type == TokenType::Keyword2
|
|
&& self.tokens[index + 1].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index].clone());
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.ast_type = AstType::State2;
|
|
self.index += 1;
|
|
} else {
|
|
match token.token_type {
|
|
TokenType::Identifier => {
|
|
ast_res.tokens.push(self.tokens[index].clone());
|
|
if self.tokens.len() - index > 3
|
|
&& self.tokens[index + 1].token_type == TokenType::Identifier
|
|
&& self.tokens[index + 2].token_type == TokenType::Round
|
|
&& self.tokens[index + 3].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
ast_res.tokens.push(self.tokens[index + 3].clone());
|
|
if token.value == "void" {
|
|
ast_res.ast_type = AstType::VoidFunctionDeceleration;
|
|
} else {
|
|
ast_res.ast_type = AstType::FunctionDeceleration;
|
|
}
|
|
self.variables.insert(
|
|
self.tokens[index + 1].value.clone(),
|
|
Variable {
|
|
vtype: VariableType::Func,
|
|
indent: 0,
|
|
line: self.tokens[index + 1].line.clone(),
|
|
column: self.tokens[index + 1].column.clone(),
|
|
},
|
|
);
|
|
self.index += 3;
|
|
} else if self.tokens.len() - index > 1
|
|
&& self.tokens[index + 1].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.ast_type = AstType::StructCall;
|
|
self.index += 1;
|
|
} else if self.tokens.len() - index > 2
|
|
&& self.tokens[index + 1].token_type == TokenType::Identifier
|
|
&& self.tokens[index + 2].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
ast_res.ast_type = AstType::StructVar;
|
|
self.index += 2;
|
|
} else if self.tokens.len() - index > 1 {
|
|
if self.tokens[index + 1].token_type == TokenType::Identifier {
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.ast_type = AstType::VariableDeceleration;
|
|
self.index += 1;
|
|
} else if self.tokens.len() - index > 2
|
|
&& self.tokens[index + 2].token_type == TokenType::Identifier
|
|
&& self.tokens[index + 1].token_type == TokenType::Angle
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
ast_res.tokens[0].value += "<";
|
|
ast_res.tokens[0].value += self.tokens[index + 1].value.as_str();
|
|
ast_res.tokens[0].value += ">";
|
|
ast_res.ast_type = AstType::VariableDeceleration;
|
|
self.index += 2;
|
|
} else if self.tokens.len() - index > 2
|
|
&& self.tokens[index + 1].value == "*"
|
|
&& self.tokens[index + 2].token_type == TokenType::Identifier
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 2].clone());
|
|
ast_res.ast_type = AstType::PointerDeceleration;
|
|
self.index += 2;
|
|
}
|
|
}
|
|
}
|
|
TokenType::Include => {
|
|
if let Some(caps) = self.include_regex.captures(&token.value) {
|
|
ast_res.tokens.push(Token {
|
|
token_type: TokenType::String,
|
|
value: caps[2].to_owned().to_string(),
|
|
line: 0,
|
|
column: 0,
|
|
});
|
|
ast_res.ast_type = AstType::Include;
|
|
} else if let Some(caps) = self.include_regex_local.captures(&token.value) {
|
|
ast_res.tokens.push(Token {
|
|
token_type: TokenType::String,
|
|
value: caps[2].to_owned().to_string(),
|
|
line: 0,
|
|
column: 0,
|
|
});
|
|
ast_res.ast_type = AstType::IncludeLocal;
|
|
} else {
|
|
ast_res.tokens.push(token.clone());
|
|
ast_res.ast_type = AstType::Include;
|
|
}
|
|
}
|
|
TokenType::Keyword => {
|
|
if token.value == "cb"
|
|
&& self.tokens[index + 1].token_type == TokenType::Curly
|
|
{
|
|
ast_res.tokens.push(self.tokens[index + 1].clone());
|
|
ast_res.ast_type = AstType::CodeBlock;
|
|
self.index += 1;
|
|
} else {
|
|
ast_res.tokens.push(token.clone());
|
|
}
|
|
}
|
|
_ => {
|
|
ast_res.tokens.push(token.clone());
|
|
}
|
|
}
|
|
}
|
|
self.index += 1;
|
|
full_ast.push(ast_res);
|
|
}
|
|
full_ast
|
|
}
|
|
}
|