Add viz for symbol tables

1 files changed, 24 insertions, 20 deletions

diff --git a/src/semantic.c b/src/semantic.c
index 06958b9..6c9f290 100644
--- a/src/semantic.c
+++ b/src/semantic.c
@@ -1,6 +1,7 @@
 #include "hashtable.h"
 
 typedef struct Scope {
+    size_t id;
     struct Scope *parent;
     HashTable *symbols;
     HashTable *types;
@@ -8,8 +9,7 @@ typedef struct Scope {
 
 typedef struct ParseTree {
     Root *roots;
-    Scope *global_scope;
-    Scope *current_scope;
+    Scope **scopes;
 } ParseTree;
 
 typedef struct Type {
@@ -70,6 +70,7 @@ typedef struct Symbol {
     };
 } Symbol;
 
+static size_t scope_gen_id = 0;
 
 Symbol *
 alloc_symval(Node *name, SymbolType type) {
@@ -110,6 +111,7 @@ bool type_eq(void *a, void *b) {
 Scope *
 alloc_scope(Scope *parent) {
     Scope *scope = malloc(sizeof(Scope));
+    scope->id = scope_gen_id++;
     scope->parent = parent;
     scope->symbols = ht_init(sym_hash, sym_eq);
     scope->types = ht_init(type_hash, type_eq);
@@ -216,7 +218,7 @@ find_symbol(Scope *scope, Node *node) {
 }
 
 bool
-resolve_type(Scope *scope, Node *node) {
+resolve_type(ParseTree *ast, Scope *scope, Node *node) {
     if (node->expr_type != NULL) {
         return true;
     }
@@ -224,7 +226,7 @@ resolve_type(Scope *scope, Node *node) {
         case NODE_BUILTIN: {
             for (size_t i = 0; i < array_size(node->builtin.args); ++i) {
                 Node *arg = node->builtin.args[i];
-                if (!resolve_type(scope, arg)) {
+                if (!resolve_type(ast, scope, arg)) {
                     return false;
                 }
             }
@@ -311,6 +313,7 @@ resolve_type(Scope *scope, Node *node) {
         case NODE_FUN: {
             // Fill up new scope with parameters
             scope = alloc_scope(scope);
+            array_push(ast->scopes, scope);
 
             // Parameters.
             for (size_t i = 0; i < array_size(node->fun.param_names); ++i) {
@@ -328,14 +331,14 @@ resolve_type(Scope *scope, Node *node) {
             if (body->type == NODE_BLOCK) {
                 for (size_t i = 0; i < array_size(body->block.expr); ++i) {
                     Node *expr = body->block.expr[i];
-                    if (!resolve_type(scope, expr)) {
+                    if (!resolve_type(ast, scope, expr)) {
                         return false;
                     }
                 }
                 Node *last_expr = body->block.expr[array_size(body->block.expr) - 1];
                 node->expr_type = last_expr->expr_type;
             } else {
-                if (!resolve_type(scope, body)) {
+                if (!resolve_type(ast, scope, body)) {
                     return false;
                 }
             }
@@ -350,9 +353,10 @@ resolve_type(Scope *scope, Node *node) {
         } break;
         case NODE_BLOCK: {
             scope = alloc_scope(scope);
+            array_push(ast->scopes, scope);
             for (size_t i = 0; i < array_size(node->block.expr); ++i) {
                 Node *expr = node->block.expr[i];
-                if (!resolve_type(scope, expr)) {
+                if (!resolve_type(ast, scope, expr)) {
                     return false;
                 }
             }
@@ -360,16 +364,16 @@ resolve_type(Scope *scope, Node *node) {
             node->expr_type = last_expr->expr_type;
         } break;
         case NODE_IF: {
-            if (!resolve_type(scope, node->ifexpr.cond)) {
+            if (!resolve_type(ast, scope, node->ifexpr.cond)) {
                 return false;
             }
-            if (!resolve_type(scope, node->ifexpr.expr_true)) {
+            if (!resolve_type(ast, scope, node->ifexpr.expr_true)) {
                 return false;
             }
             Type *type_true = node->ifexpr.expr_true->expr_type;
             node->expr_type = type_true;
             if (node->ifexpr.expr_false != NULL) {
-                if (!resolve_type(scope, node->ifexpr.expr_false)) {
+                if (!resolve_type(ast, scope, node->ifexpr.expr_false)) {
                     return false;
                 }
             }
@@ -396,10 +400,10 @@ resolve_type(Scope *scope, Node *node) {
         } break;
         case NODE_SET: {
             node->expr_type = &default_types[TYPE_VOID];
-            if (!resolve_type(scope, node->set.symbol)) {
+            if (!resolve_type(ast, scope, node->set.symbol)) {
                 return false;
             }
-            if (!resolve_type(scope, node->set.value)) {
+            if (!resolve_type(ast, scope, node->set.value)) {
                 return false;
             }
             Node *symbol = node->set.symbol;
@@ -426,7 +430,7 @@ resolve_type(Scope *scope, Node *node) {
 
             node->expr_type = &default_types[TYPE_VOID];
             // TODO: type inference from right side when not annotated?
-            if (!resolve_type(scope, node->def.value)) {
+            if (!resolve_type(ast, scope, node->def.value)) {
                 return false;
             }
             Node *symbol = node->def.symbol;
@@ -455,7 +459,7 @@ resolve_type(Scope *scope, Node *node) {
         } break;
         case NODE_FUNCALL: {
             Symbol *val = find_symbol(scope, node->funcall.name);
-            if (!resolve_type(scope, node->funcall.name)) {
+            if (!resolve_type(ast, scope, node->funcall.name)) {
                 return false;
             }
             if (val->type != SYMBOL_FUN) {
@@ -470,7 +474,7 @@ resolve_type(Scope *scope, Node *node) {
             node->expr_type = node->funcall.name->expr_type;
             for (size_t i = 0; i < array_size(node->funcall.args); ++i) {
                 Node *arg = node->funcall.args[i];
-                if (!resolve_type(scope, arg)) {
+                if (!resolve_type(ast, scope, arg)) {
                     return false;
                 }
                 Node *expected = val->fun.param_types[i];
@@ -490,18 +494,18 @@ ParseTree *
 semantic_analysis(Root *roots) {
     ParseTree *parse_tree = malloc(sizeof(ParseTree));
     parse_tree->roots = roots;
-    parse_tree->global_scope = alloc_scope(NULL);
-    parse_tree->current_scope = parse_tree->global_scope;
+    array_init(parse_tree->scopes, 0);
+    Scope *scope = alloc_scope(NULL);
+    array_push(parse_tree->scopes, scope);
 
     // Fill global scope with default types.
-    HashTable *types = parse_tree->global_scope->types;
+    HashTable *types = scope->types;
     for (size_t i = 0; i < sizeof(default_types)/sizeof(Type); ++i) {
         Type *type = &default_types[i];
         ht_insert(types, &type->name, type);
     }
 
     // Fill up global function symbols.
-    Scope *scope = parse_tree->global_scope;
     for (size_t i = 0; i < array_size(parse_tree->roots); ++i) {
         Node *root = parse_tree->roots[i];
         if (root->type == NODE_FUN) {
@@ -518,7 +522,7 @@ semantic_analysis(Root *roots) {
     for (size_t i = 0; i < array_size(parse_tree->roots); ++i) {
         // Fill up symbol tables in proper scope and resolve type of expression
         // for all elements.
-        if (!resolve_type(scope, parse_tree->roots[i])) {
+        if (!resolve_type(parse_tree, scope, parse_tree->roots[i])) {
             return NULL;
         }
     }