Implements identifier trees for for-loops and conditional branching

CMakeLists.txt

@@ -23,7 +23,7 @@ find_package(LLVM)
 
 include_directories(${CMAKE_SOURCE_DIR})
 
-BISON_TARGET(Parser generators/wraith.y ${CMAKE_CURRENT_BINARY_DIR}/y.tab.c COMPILE_FLAGS "-d -v -t -Wcounterexamples")
+BISON_TARGET(Parser generators/wraith.y ${CMAKE_CURRENT_BINARY_DIR}/y.tab.c COMPILE_FLAGS "-d -v -t")
 FLEX_TARGET(Scanner generators/wraith.lex ${CMAKE_CURRENT_BINARY_DIR}/lex.yy.c)
 
 ADD_FLEX_BISON_DEPENDENCY(Scanner Parser)
@@ -41,9 +41,11 @@ add_executable(
 	# Source
 	src/ast.h
 	src/codegen.h
+	src/identcheck.h
 	src/parser.h
     src/ast.c
 	src/codegen.c
+	src/identcheck.c
 	src/parser.c
 	src/main.c
 	# Generated code

iftest.w

@@ -0,0 +1,27 @@
+struct Program {                                      // Scope ()
+    static Main(): int {                              // | Program : Struct
+        myInt: int = 54;                              // | | Main : Function
+        if (myInt < 0) {                              // | | | myInt : Variable
+            signTag: int = 0 - 1;                     // | | | Scope (if-else)
+        } else if (myInt == 0) {                      // | | | | Scope (if)
+            signTag: int = 0;                         // | | | | | signTag : Variable
+        } else {                                      // | | | | Scope (else)
+            signTag: int = 1;                         // | | | | | Scope (if)
+        }                                             // | | | | | | signTag : Variable
+                                                      // | | | myBool : Variable
+        myBool: bool;                                 // | | | Scope (if)
+        if (myBool) {                                 // | | | | Scope (if)
+            if (myBool) {                             // | | | | | Scope (if)
+                if (myBool) {                         // | | | | | | Scope (if)
+                    if (myBool) {                     // | | | | | | | Scope (if)
+                        if (myBool) {                 // | | | | | | | | lol : Variable
+                            lol: int = 69;
+                        }
+                    }
+                }
+            }
+        }
+
+        return 0;
+    }
+}

src/ast.c

@@ -2,21 +2,8 @@
 
 #include <stdlib.h>
 #include <stdio.h>
-#include <string.h>
 
-char* strdup (const char* s)
+#include "util.h"
-{
-    size_t slen = strlen(s);
-    char* result = malloc(slen + 1);
-
-    if(result == NULL)
-    {
-        return NULL;
-    }
-
-    memcpy(result, s, slen+1);
-    return result;
-}
 
 const char* SyntaxKindString(SyntaxKind syntaxKind)
 {
@@ -29,6 +16,8 @@ const char* SyntaxKindString(SyntaxKind syntaxKind)
         case Comment: return "Comment";
         case CustomTypeNode: return "CustomTypeNode";
         case Declaration: return "Declaration";
+        case Expression: return "Expression";
+        case ForLoop: return "ForLoop";
         case DeclarationSequence: return "DeclarationSequence";
         case FunctionArgumentSequence: return "FunctionArgumentSequence";
         case FunctionCallExpression: return "FunctionCallExpression";

src/ast.h

@@ -89,7 +89,6 @@ typedef struct Node
     PrimitiveType primitiveType;
 } Node;
 
-char* strdup (const char* s);
 const char* SyntaxKindString(SyntaxKind syntaxKind);
 
 uint8_t IsPrimitiveType(Node *typeNode);

src/identcheck.c

@@ -0,0 +1,167 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "ast.h"
+#include "identcheck.h"
+
+IdNode* MakeIdNode(NodeType type, char *name) {
+    IdNode *node = (IdNode*)malloc(sizeof(IdNode));
+    node->type = type;
+    node->name = strdup(name);
+    node->childCount = 0;
+    node->childCapacity = 0;
+    node->children = NULL;
+    return node;
+}
+
+void AddChildToNode(IdNode *node, IdNode *child) {
+    if (child == NULL) return;
+
+    if (node->children == NULL) {
+        node->childCapacity = 2;
+        node->children = (IdNode**)malloc(sizeof(IdNode*) * node->childCapacity);
+    } else if (node->childCount == node->childCapacity) {
+        node->childCapacity *= 2;
+        node->children = realloc(node->children, sizeof(IdNode*) * node->childCapacity);
+    }
+
+    node->children[node->childCount] = child;
+    node->childCount += 1;
+}
+
+IdNode* FindId(IdNode *root, NodeType targetType, char *targetName) {
+    IdNode *result = NULL;
+    IdNode **frontier = (IdNode**)malloc(sizeof(IdNode*));
+    frontier[0] = root;
+    uint32_t frontierCount = 1;
+
+    while (frontierCount > 0) {
+        IdNode *current = frontier[0];
+
+        if (current->type == targetType && strcmp(current->name, targetName)) {
+            result = current;
+            break;
+        }
+
+        IdNode **temp = 
+            (IdNode**)malloc(sizeof(IdNode*) * (frontierCount - 1 + current->childCount));
+        uint32_t i;
+        for (i = 1; i < frontierCount; i++) {
+            temp[i - 1] = frontier[i];
+        }
+        uint32_t offset = i;
+        for (i = 0; i < current->childCount; i++) {
+            temp[offset + i] = current->children[i];
+        }
+        frontier = temp;
+        frontierCount += current->childCount - 1;
+    }
+
+    free(frontier);
+    return result;
+}
+
+IdNode* MakeIdTree(Node *astNode) {
+    uint32_t i;
+    switch (astNode->syntaxKind) {
+        case Assignment:
+            return (astNode->children[0]->syntaxKind == Declaration)
+                ? MakeIdTree(astNode->children[0])
+                : NULL;
+
+        case IfStatement: {
+            Node *stmtSeq = astNode->children[1];
+            IdNode *ifNode = MakeIdNode(LexicalScope, "if");
+            for (i = 0; i < stmtSeq->childCount; i++) {
+                AddChildToNode(ifNode, MakeIdTree(stmtSeq->children[i]));
+            }
+            return ifNode;
+        }
+
+        case IfElseStatement: {
+            Node *ifNode = astNode->children[0];
+            Node *elseStmts = astNode->children[1];
+            IdNode *ifElseNode = MakeIdNode(LexicalScope, "if-else");
+            IdNode *ifBranch = MakeIdTree(ifNode);
+            IdNode *elseBranch = MakeIdNode(LexicalScope, "else");
+
+            AddChildToNode(ifElseNode, ifBranch);
+            AddChildToNode(ifElseNode, elseBranch);
+            for (i = 0; i < elseStmts->childCount; i++) {
+                AddChildToNode(elseBranch, MakeIdTree(elseStmts->children[i]));
+            }
+
+            return ifElseNode;
+        }
+
+        case ForLoop: {
+            Node *loopDecl = astNode->children[0];
+            Node *loopBody = astNode->children[3];
+            IdNode *loopNode = MakeIdNode(LexicalScope, "for-loop");
+            AddChildToNode(loopNode, MakeIdTree(loopDecl));
+            for (i = 0; i < loopBody->childCount; i++) {
+                AddChildToNode(loopNode, MakeIdTree(loopBody->children[i]));
+            }
+            return loopNode;
+        }
+
+        case Declaration:
+            return MakeIdNode(Variable, astNode->children[1]->value.string);
+
+        case StructDeclaration: {
+            Node *idNode = astNode->children[0];
+            Node *declsNode = astNode->children[1];
+            IdNode *structNode = MakeIdNode(Struct, idNode->value.string);
+            for (i = 0; i < declsNode->childCount; i++) {
+                AddChildToNode(structNode, MakeIdTree(declsNode->children[i]));
+            }
+            return structNode;
+        }
+
+        case FunctionDeclaration: {
+            Node *sigNode = astNode->children[0];
+            Node *funcNameNode = sigNode->children[0];
+            Node *funcArgsNode = sigNode->children[2];
+            Node *bodyStatementsNode = astNode->children[1];
+            IdNode *funcNode = MakeIdNode(Function, funcNameNode->value.string);
+            for (i = 0; i < funcArgsNode->childCount; i++) {
+                AddChildToNode(funcNode, MakeIdTree(funcArgsNode->children[i]));
+            }
+            for (i = 0; i < bodyStatementsNode->childCount; i++) {
+                AddChildToNode(funcNode, MakeIdTree(bodyStatementsNode->children[i]));
+            }
+            return funcNode;
+        }
+
+        case DeclarationSequence: {
+            IdNode *declSeqNode = MakeIdNode(LexicalScope, "");
+            for (i = 0; i < astNode->childCount; i++) {
+                AddChildToNode(declSeqNode, MakeIdTree(astNode->children[i]));
+            }
+            return declSeqNode;
+        }
+
+        default:
+            return NULL;
+    }
+}
+
+void PrintIdTree(IdNode *tree, uint32_t tabCount) {
+    uint32_t i;
+    for (i = 0; i < tabCount; i++) {
+        printf("| ");
+    }
+
+    switch(tree->type) {
+        case LexicalScope: printf("Scope (%s)\n", tree->name); break;
+        case Struct: printf("%s : Struct\n", tree->name); break;
+        case Function: printf("%s : Function\n", tree->name); break;
+        case Variable: printf("%s : Variable\n", tree->name); break;
+    }
+
+    for (i = 0; i < tree->childCount; i++) {
+        PrintIdTree(tree->children[i], tabCount + 1);
+    }
+}

src/identcheck.h

@@ -0,0 +1,36 @@
+// Validates identifier usage in an AST.
+#ifndef WRAITH_IDENTCHECK_H
+#define WRAITH_IDENTCHECK_H
+
+#include <stdint.h>
+
+#include "ast.h"
+
+typedef enum NodeType {
+    LexicalScope,
+    Struct,
+    Function,
+    Variable
+} NodeType;
+
+typedef struct IdNode {
+    NodeType type;
+    char *name;
+    struct IdNode **children;
+    uint32_t childCount;
+    uint32_t childCapacity;
+} IdNode;
+
+typedef struct IdStatus {
+    enum StatusCode {
+        Valid,
+    } StatusCode;
+} IdStatus;
+
+
+IdNode* MakeIdTree(Node *astNode);
+void PrintIdTree(IdNode *tree, uint32_t tabCount);
+
+//IdStatus CheckIds(Node *root);
+
+#endif /* WRAITH_IDENTCHECK_H */

src/main.c

@@ -3,6 +3,7 @@
 
 #include "parser.h"
 #include "codegen.h"
+#include "identcheck.h"
 
 int main(int argc, char *argv[])
 {
@@ -64,6 +65,7 @@ int main(int argc, char *argv[])
                 }
                 else
                 {
+                    PrintIdTree(MakeIdTree(rootNode), /*tabCount=*/0);
                     exitCode = Codegen(rootNode, optimizationLevel);
                 }
             }

src/util.c

@@ -0,0 +1,16 @@
+#include "util.h"
+
+#include <string.h>
+
+char* strdup (const char* s)
+{
+  size_t slen = strlen(s);
+  char* result = malloc(slen + 1);
+  if(result == NULL)
+  {
+    return NULL;
+  }
+
+  memcpy(result, s, slen+1);
+  return result;
+}

src/util.h

@@ -0,0 +1,8 @@
+#ifndef WRAITH_UTIL_H
+#define WRAITH_UTIL_H
+
+#include <string.h>
+
+char* strdup (const char* s);
+
+#endif /* WRAITH_UTIL_H */