Implement Parsing, resolves #6

include/ast.h

@@ -1,4 +1,4 @@
 #ifndef REGEX_AST_H
 #define REGEX_AST_H
 
 
@@ -77,4 +77,10 @@
  */
 void ast_node_free(ASTNode* node);
 
+/**
+ * @param  node The node to convert to string
+ *
+ * @return A string description of the given AST Node
+ */
+char* str_ast_node(ASTNode* node);
 #endif // REGEX_AST

src/ast.c

@@ -1,7 +1,17 @@
 #include <stdlib.h>
 
 #include "ast.h"
 
+
+char* ast_str[] = {
+    "CharNode",
+    "StarNode",
+    "PlusNode",
+    "QuestionNode",
+    "OrNode",
+    "ConcatNode",
+};
+
 // Allocate a new AST Node, and initialize it with the given type
 ASTNode* ast_node_create(ASTNodeType type) {
     ASTNode* node = malloc(sizeof(ASTNode));
@@ -51,3 +61,7 @@
 
     free(node);
 }
+
+char* str_ast_node(ASTNode* node) {
+    return ast_str[node->type];
+}

src/parser.c

@@ -1,8 +1,14 @@
 #include "ast.h"
 #include "lexer.h"
 #include "parser.h"
 #include "token.h"
 
+// Forward declaration of parsing functions
+ASTNode* parse_base(Parser* parser);
+ASTNode* parse_factor(Parser* parser);
+ASTNode* parse_term(Parser* parser);
+ASTNode* parse_expr(Parser* parser);
+
 /**
  * Returns the next token with advancing the parser's position
  *
@@ -59,12 +65,16 @@
         return -1;
     }
 
-    return parser->tokens[parser->position].type == type ? 0 : -1;
+    Token* token = next(parser);
+    if (token == NULL) {
+        return type == EOF_ ? 0 : -1;
+    }
+
+    return token->type == type ? 0 : -1;
 }
 
 
 /**
- * TODO: WIP
  * Parse the `base` non-terminal.
  *
  * See the regex CFG on
@@ -77,32 +87,96 @@
  *
  * @return The root of the AST created by parsing the `base` non-terminal
  */
-ASTNode* parse_base(Parser* parser){
-    return parser != NULL ? NULL : NULL;
+ASTNode* parse_base(Parser* parser) {
+    if (parser == NULL) {
+        return NULL;
+    }
+
+    Token* token = next(parser);
+    ASTNode* node = NULL;
+
+    switch (token->type) {
+    case CHAR:
+        node = ast_node_create(CHAR_NODE);
+        node->extra.character = token->value;
+        break;
+
+    case LPAREN:;
+        Token* next = peek(parser);
+        if (next != NULL && next->type == RPAREN) {
+            return NULL;
+        }
+
+        node = parse_expr(parser);
+
+        if (expect(parser, RPAREN) < 0) {
+            ast_node_free(node);
+            return NULL;
+        }
+
+        break;
+
+    default:
+        // Error
+        return NULL;
+    }
+
+    return node;
 }
 
 
 /**
- * TODO: WIP
  * Parse the `factor` non-terminal.
  *
  * See the regex CFG on
  * https://github.com/mkpro118/Regex-Engine/issues/6#issue-2337160940
  *
  * The relevant production is reproduced below
- *     non terminal  ::  factor ->   base op  |   factor op
+ *     non terminal  ::  factor ->   base op | epsilon
  *
  * @param  parser The parser to operate on
  *
  * @return The root of the AST created by parsing the `factor` non-terminal
  */
-ASTNode* parse_factor(Parser* parser){
-    return parser != NULL ? NULL : NULL;
+ASTNode* parse_factor(Parser* parser) {
+    if (parser == NULL) {
+        return NULL;
+    }
+
+    ASTNode* node = parse_base(parser);
+
+    Token* token;
+
+    while ((token = peek(parser))) {
+        ASTNode* parent = NULL;
+
+        switch (token->type) {
+        case STAR:
+            parent = ast_node_create(STAR_NODE);
+            break;
+
+        case PLUS:
+            parent = ast_node_create(PLUS_NODE);
+            break;
+
+        case QUESTION:
+            parent = ast_node_create(QUESTION_NODE);
+            break;
+
+        default:
+            return node;
+        }
+
+        parent->child1 = node;
+        node = parent;
+        next(parser);
+    }
+
+    return node;
 }
 
 
 /**
- * TODO: WIP
  * Parse the `term` non-terminal.
  *
  * See the regex CFG on
@@ -115,13 +189,45 @@
  *
  * @return The root of the AST created by parsing the `term` non-terminal
  */
-ASTNode* parse_term(Parser* parser){
-    return parser != NULL ? NULL : NULL;
+ASTNode* parse_term(Parser* parser) {
+    if (parser == NULL) {
+        return NULL;
+    }
+
+    ASTNode* left = parse_factor(parser);
+
+    Token* token;
+
+    while ((token = peek(parser))) {
+        if (token->type == OR || token->type == RPAREN) {
+            return left;
+        }
+
+        ASTNode* right = parse_factor(parser);
+        if (right == NULL) {
+            ast_node_free(left);
+            return NULL;
+        }
+
+        ASTNode* concat = ast_node_create(CONCAT_NODE);
+        if (concat == NULL) {
+            ast_node_free(left);
+            ast_node_free(right);
+            return NULL;
+        }
+
+
+        concat->child1 = left;
+        concat->extra.child2 = right;
+
+        left = concat;
+    }
+
+    return left;
 }
 
 
 /**
- * TODO: WIP
  * Parse the `expr` non-terminal.
  *
  * See the regex CFG on
@@ -135,7 +241,40 @@
  * @return The root of the AST created by parsing the `expr` non-terminal
  */
 ASTNode* parse_expr(Parser* parser){
-    return parser != NULL ? NULL : NULL;
+    if (parser == NULL) {
+        return NULL;
+    }
+
+
+    ASTNode* left = parse_term(parser);
+
+    Token* token;
+
+    while ((token = peek(parser)) && token->type == OR) {
+        // This is to consume the OR token
+        next(parser);
+
+        ASTNode* right = parse_term(parser);
+        if (right == NULL) {
+            ast_node_free(left);
+            return NULL;
+        }
+
+        ASTNode* or = ast_node_create(OR_NODE);
+        if (or == NULL) {
+            ast_node_free(left);
+            ast_node_free(right);
+            return NULL;
+        }
+
+
+        or->child1 = left;
+        or->extra.child2 = right;
+
+        left = or;
+    }
+
+    return left;
 }
 
 // Create a heap allocated parser from the given Lexer
@@ -176,5 +315,5 @@
 
 // Create a AST by parsing the tokens in the given parser
 ASTNode* parse(Parser* parser) {
-    return parser != NULL ? NULL : NULL;
+    return parse_expr(parser);
 }