From 835f4d9f23f55a973d76ae9384b7b9d75da5472b Mon Sep 17 00:00:00 2001
From: Bad Diode <bd@badd10de.dev>
Date: Fri, 21 Jun 2024 18:20:35 +0200
Subject: Remove old files no longer needed as reference

---
 src/main.c | 95 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 89 insertions(+), 6 deletions(-)

(limited to 'src/main.c')

diff --git a/src/main.c b/src/main.c
index 2bcbf39..60203d5 100644
--- a/src/main.c
+++ b/src/main.c
@@ -30,13 +30,20 @@ typedef enum {
     SYM_PARAM,
     SYM_ENUM,
     SYM_ENUM_FIELD,
+    SYM_STRUCT,
+    SYM_STRUCT_FIELD,
 } SymbolKind;
 
 Str sym_kind_str[] = {
-    [SYM_UNKNOWN] = cstr("UNKNOWN   "),    [SYM_BUILTIN] = cstr("BUILTIN   "),
-    [SYM_FUN] = cstr("FUNCTION  "),        [SYM_VAR] = cstr("VARIABLE  "),
-    [SYM_PARAM] = cstr("PARAMETER "),      [SYM_ENUM] = cstr("ENUM      "),
-    [SYM_ENUM_FIELD] = cstr("ENUM FIELD"),
+    [SYM_UNKNOWN] = cstr("UNKNOWN      "),
+    [SYM_BUILTIN] = cstr("BUILTIN      "),
+    [SYM_FUN] = cstr("FUNCTION     "),
+    [SYM_VAR] = cstr("VARIABLE     "),
+    [SYM_PARAM] = cstr("PARAMETER    "),
+    [SYM_ENUM] = cstr("ENUM         "),
+    [SYM_ENUM_FIELD] = cstr("ENUM FIELD   "),
+    [SYM_STRUCT] = cstr("STRUCT       "),
+    [SYM_STRUCT_FIELD] = cstr("STRUCT FIELD "),
 };
 
 typedef struct Symbol {
@@ -84,6 +91,69 @@ find_symbol(Scope *scope, Str symbol) {
     return NULL;
 }
 
+void
+graph_scope(Scope *scope, Arena a) {
+    if (!scope->symbols) {
+        return;
+    }
+    SymbolMapIter iter = symmap_iterator(scope->symbols, &a);
+    SymbolMap *sym = symmap_next(&iter, &a);
+    print(
+        "%d[shape=\"none\" label=<\
+<TABLE ALIGN=\"left\" STYLE=\"rounded\"  BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"6\" COLUMNS=\"*\">\
+  <TR style=\"rounded\" ><TD COLSPAN=\"2\">ID: %d</TD></TR>",
+        scope->id, scope->id);
+    print(
+        "<TR ><TD ALIGN=\"left\" > NAME</TD><TD ALIGN=\"left\" > "
+        "KIND</TD></TR>");
+    while (sym) {
+        print(
+            "<TR><TD ALIGN=\"left\"> %s </TD><TD ALIGN=\"left\"> %s </TD></TR>",
+            sym->val.name, sym_kind_str[sym->val.kind]);
+        SymbolMapIter field_iter = symmap_iterator(sym->val.fields, &a);
+        SymbolMap *field = symmap_next(&field_iter, &a);
+        while (field) {
+            print(
+                "<TR><TD ALIGN=\"left\"> %s.%s </TD><TD ALIGN=\"left\"> %s "
+                "</TD></TR>",
+                sym->val.name, field->val.name, sym_kind_str[field->val.kind]);
+            field = symmap_next(&field_iter, &a);
+        }
+        sym = symmap_next(&iter, &a);
+    }
+    println("</TABLE>>];");
+    sz this_id = scope->id;
+    while (scope->parent) {
+        if (scope->parent->symbols) {
+            println("%d:n->%d:s;", this_id, scope->parent->id);
+            break;
+        } else {
+            scope = scope->parent;
+        }
+    }
+}
+
+void
+graph_symbols(Scope **scopes, Arena a) {
+    if (scopes == NULL) return;
+    println("digraph symbols {");
+    println("rankdir=BT;");
+    println("ranksep=\"0.95 equally\";");
+    println("nodesep=\"0.5 equally\";");
+    println("overlap=scale;");
+    println("bgcolor=\"transparent\";");
+    for (sz i = 0; i < array_size(scopes); i++) {
+        Scope *scope = scopes[i];
+        if (!scope) {
+            continue;
+        }
+        println("subgraph %d {", i);
+        graph_scope(scope, a);
+        println("}");
+    }
+    println("}");
+}
+
 void
 analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
     assert(a);
@@ -158,6 +228,7 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                 analyzer_symbols(a, expr, next);
             }
         } break;
+        case NODE_STRUCT:
         case NODE_ENUM: {
             Str symbol = node->value.str;
             if (symmap_lookup(&scope->symbols, symbol) != NULL) {
@@ -168,7 +239,10 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
             }
             SymbolMap *map = symmap_insert(
                 &scope->symbols, symbol,
-                (Symbol){.kind = SYM_ENUM, .name = symbol}, a->storage);
+                (Symbol){
+                    .kind = node->kind == NODE_ENUM ? SYM_ENUM : SYM_STRUCT,
+                    .name = symbol},
+                a->storage);
             // TODO: symcheck the value expression?
             for (sz i = 0; i < array_size(node->struct_field); i++) {
                 Node *field = node->struct_field[i];
@@ -179,7 +253,10 @@ analyzer_symbols(Analyzer *a, Node *node, Scope *scope) {
                         a->file_name, field->line, field->col, symbol,
                         field_name);
                 }
-                Symbol s = (Symbol){.kind = SYM_ENUM_FIELD, .name = field_name};
+                Symbol s =
+                    (Symbol){.kind = node->kind == NODE_ENUM ? SYM_ENUM_FIELD
+                                                             : SYM_STRUCT_FIELD,
+                             .name = field_name};
                 symmap_insert(&map->val.fields, field_name, s, a->storage);
             }
         } break;
@@ -404,6 +481,11 @@ process_file(Str path) {
     symbolic_analysis(&analyzer, &parser);
 
     // Printing symbol tables.
+    if (mode == PRINT_SYMTABLES) {
+        graph_symbols(analyzer.scopes, lexer_arena);
+    }
+
+#if DEBUG == 1
     for (sz i = 0; i < array_size(analyzer.scopes); i++) {
         Arena scratch = lexer_arena;
         Scope *scope = analyzer.scopes[i];
@@ -424,6 +506,7 @@ process_file(Str path) {
             sym = symmap_next(&iter, &lexer_arena);
         }
     }
+#endif
 
     // TODO: Type checking.
 
-- 
cgit v1.2.1