added 2 ast nodes

src/lexer.rs

@@ -19,6 +19,8 @@ pub enum TokenType {
     Operator,
     Round,
     Curly,
+    Square,
+    Angle,
     // EOF,
 }
 
@@ -41,7 +43,7 @@ pub struct Node {
     token_regex: Lazy<Regex>
 }
 
-const SYNTAX: [Node; 9] = [
+const SYNTAX: [Node; 11] = [
     Node {
         token_type: TokenType::Newline,
         token_regex: Lazy::new(|| Regex::new(r"^\n+").unwrap()),
@@ -56,7 +58,7 @@ const SYNTAX: [Node; 9] = [
     },
     Node {
         token_type: TokenType::Keyword,
-        token_regex: Lazy::new(|| Regex::new(r"^mut|try|catch|return|fn").unwrap())
+        token_regex: Lazy::new(|| Regex::new(r"^mut|try|catch|return|fn\b").unwrap())
     },
     Node {
         token_type: TokenType::Identifier,
@@ -76,8 +78,16 @@ const SYNTAX: [Node; 9] = [
     },
     Node {
         token_type: TokenType::Curly,
-        token_regex: Lazy::new(|| Regex::new(r"^[\{|\}]").unwrap())
+        token_regex: Lazy::new(|| Regex::new(r"\{(?:[^{}]|(?R))*}").unwrap())
-    }
+    },
+    Node {
+        token_type: TokenType::Square,
+        token_regex: Lazy::new(|| Regex::new(r"\[(?:[^\[\]]|(?R))*]").unwrap())
+    },
+    Node {
+        token_type: TokenType::Angle,
+        token_regex: Lazy::new(|| Regex::new(r"<(?:[^<>]|(?R))*>").unwrap())
+    },
 ];
 
 pub fn lex(mut code: &str, use_whitespace: bool) -> Vec<Token> {

src/main.rs

@@ -4,7 +4,7 @@ mod parser;
 use parser::parse;
 
 fn main() {
-    let input = "if a + b {}";
+    let input = "void main() {} <>";
     println!("\n\n\n\n");
     // let input = "test->xy";
     let mut tokens = lex(input, false);
@@ -14,7 +14,11 @@ fn main() {
     // }
     let mut _x = 1;
     for a in ast {
-        println!("{:?}: {:?}\n", a.type_, a.values);
+        println!("{:?}: [", a.type_);
+        for v in a.values {
+            println!("    {:?},", v);
+        }
+        println!("]");
         _x+=1;
     }
 }

src/parser.rs

@@ -1,10 +1,13 @@
 // use std::collections::HashMap;
 use  crate::lexer::{Token, TokenType};
 use std::fmt;
+use crate::parser::AstDef::{Else, Normal};
+use crate::parser::AstTypes::{FunctionDecleration, Other};
 
 #[derive(Debug, Clone)]
 pub enum AstTypes {
     FunctionDecleration,
+    VariableDecleration,
     Other
 }
 
@@ -36,13 +39,17 @@ pub struct PNode {
 pub fn parse(tokens: &mut Vec<Token>) -> Box<Vec<Ast>> {
     let ast_def: Vec<PNode> = vec![
         PNode {
-            ast_type: AstTypes::FunctionDecleration,
+            ast_type: FunctionDecleration,
-            ast_match: vec![AstDef::NormalValue(TokenType::Identifier, vec!["if".to_string()]), AstDef::Repeated(vec![TokenType::Operator, TokenType::Identifier, ])]
+            ast_match: vec![Normal(TokenType::Identifier), Normal(TokenType::Identifier), Normal(TokenType::Round), Normal(TokenType::Curly)]
         },
         PNode {
-            ast_type: AstTypes::Other,
+            ast_type: AstTypes::VariableDecleration,
-            ast_match: vec![AstDef::Else]
+            ast_match: vec![Normal(TokenType::Identifier), Normal(TokenType::Identifier)]
         },
+        PNode {
+            ast_type: Other,
+            ast_match: vec![Else]
+        }
     ];
     let tokens_len = tokens.len();
     let mut ast: Vec<Ast> = Vec::new();