config.mk

@@ -11,7 +11,7 @@ TEST_DIR = test
 TEST_BUILD_DIR = $(BUILD_DIR)/test
 TEST_OBJ_DIR = $(TEST_BUILD_DIR)/obj
 
-CC = clang -std=c23
+CC = clang -std=c2x
 LINK = clang
 CFLAGS = -Wall -DDBG -ggdb -fsanitize=leak
 LDFLAGS = -lm

src/ast.c

@@ -2,7 +2,7 @@
 
 #include "include/ast.h"
 #include "include/dstr.h"
-#include "include/scope.h"
+#include "include/htab.h"
 #include "include/util.h"
 
 extern AST* root;
@@ -28,7 +28,7 @@ AST* ast_init(ASTType type, void* data) {
     return ast;
 }
 
-AST* ast_init_scope(ASTType type, void* data, Scope* scope) {
+AST* ast_init_scope(ASTType type, void* data, HTab* scope) {
     AST* ast = malloc(sizeof(AST));
 
     ast->type = type;
@@ -53,21 +53,8 @@ void ast_destroy(AST* ast) {
             log_dbgf("Unknown ast type %d (max: %d)", ast->type, AST_TYPE_MAX);
     }
 
-    // If there're no more `AST`s linked to the scope, free.
-    if (ast->scope) {
-        log_dbgf("%p: there is scope.", ast->scope);
-        ast->scope->uses--;
-        log_dbgf(
-            "%p: were %d uses, now %d", ast->scope, ast->scope->uses + 1,
-            ast->scope->uses
-        );
-        if (!ast->scope->uses) {
-            log_dbgf("%p: no more uses, gonna free", ast->scope);
-            scope_destroy_psv(ast->scope);
-        }
-    }
-
     free(ast);
+    htab_destroy(ast->scope);
 }
 
 void ast_print(AST* ast) { ast_print_i(ast, 0); }
@@ -136,7 +123,7 @@ void ast_exc_print(ASTExcData* data, int i) {
     INDENT_END;
 }
 
-ASTBIFData* ast_bif_data_init(AST* fn(size_t, AST**, Scope*)) {
+ASTBIFData* ast_bif_data_init(AST* fn(size_t, AST**)) {
     return (ASTBIFData*)fn;
 }
 
@@ -289,13 +276,3 @@ void ast_arg_print(ASTArgData* arg, int i) {
     INDENT_FIELD("name", "%s", arg->name);
     INDENT_END;
 }
-
-AST* ast_find(Scope* scope, char* name) {
-    while (scope) {
-        AST* gotten = htab_get(scope->here, name);
-        if (gotten) return gotten;
-        else scope = scope->inherit;
-    }
-
-    return NULL;
-}

src/builtin.c

@@ -5,11 +5,11 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-AST* builtin_sum(size_t argc, AST** argv, Scope* parent) {
+AST* builtin_sum(size_t argc, AST** argv) {
     ASTNumData total = 0;
 
     for (int i = 0; i < argc; i++) {
-        AST* arg = exec_exp(argv[i], parent);
+        AST* arg = exec_exp(argv[i]);
         if (arg->type == AST_TYPE_EXC)
             return ast_init(
                 AST_TYPE_EXC,
@@ -27,9 +27,9 @@ AST* builtin_sum(size_t argc, AST** argv, Scope* parent) {
     return ast_init(AST_TYPE_NUM, ast_num_data_init(total));
 }
 
-AST* builtin_sub(size_t argc, AST** argv, Scope* parent) {
+AST* builtin_sub(size_t argc, AST** argv) {
     log_dbg("Got here");
-    AST* first = exec_exp(*argv, parent);
+    AST* first = exec_exp(*argv);
     if (first->type == AST_TYPE_EXC)
         return ast_init(
             AST_TYPE_EXC,
@@ -44,7 +44,7 @@ AST* builtin_sub(size_t argc, AST** argv, Scope* parent) {
     ASTNumData total = *(ASTNumData*)first->data;
 
     for (int i = 1; i < argc; i++) {
-        AST* arg = exec_exp(argv[i], parent);
+        AST* arg = exec_exp(argv[i]);
         if (arg->type == AST_TYPE_EXC)
             return ast_init(
                 AST_TYPE_EXC,
@@ -62,9 +62,9 @@ AST* builtin_sub(size_t argc, AST** argv, Scope* parent) {
     return ast_init(AST_TYPE_NUM, ast_num_data_init(total));
 }
 
-AST* builtin_mul(size_t argc, AST** argv, Scope* parent) {
+AST* builtin_mul(size_t argc, AST** argv) {
     log_dbg("Got here");
-    AST* first = exec_exp(*argv, parent);
+    AST* first = exec_exp(*argv);
     if (first->type == AST_TYPE_EXC)
         return ast_init(
             AST_TYPE_EXC,
@@ -79,7 +79,7 @@ AST* builtin_mul(size_t argc, AST** argv, Scope* parent) {
     ASTNumData total = *(ASTNumData*)first->data;
 
     for (int i = 1; i < argc; i++) {
-        AST* arg = exec_exp(argv[i], parent);
+        AST* arg = exec_exp(argv[i]);
         if (arg->type == AST_TYPE_EXC)
             return ast_init(
                 AST_TYPE_EXC,
@@ -97,9 +97,9 @@ AST* builtin_mul(size_t argc, AST** argv, Scope* parent) {
     return ast_init(AST_TYPE_NUM, ast_num_data_init(total));
 }
 
-AST* builtin_div(size_t argc, AST** argv, Scope* parent) {
+AST* builtin_div(size_t argc, AST** argv) {
     log_dbg("Got here");
-    AST* first = exec_exp(*argv, parent);
+    AST* first = exec_exp(*argv);
     if (first->type == AST_TYPE_EXC)
         return ast_init(
             AST_TYPE_EXC,
@@ -114,7 +114,7 @@ AST* builtin_div(size_t argc, AST** argv, Scope* parent) {
     ASTNumData total = *(ASTNumData*)first->data;
 
     for (int i = 1; i < argc; i++) {
-        AST* arg = exec_exp(argv[i], parent);
+        AST* arg = exec_exp(argv[i]);
         if (arg->type == AST_TYPE_EXC)
             return ast_init(
                 AST_TYPE_EXC,

src/exec.c

@@ -6,70 +6,67 @@
 #include "include/builtin.h"
 #include "include/exec.h"
 #include "include/htab.h"
-#include "include/scope.h"
+#include "include/stack.h"
 #include "include/util.h"
 
+extern AST* root;
+
+AST* exec_find(char* name);
+
 AST* exec_start(AST* ast) {
     log_dbg("Started execution.");
+    scope = stack_init();
 
-    Scope* global = scope_init(NULL);
+    HTab* global = htab_init();
-    global->uses = 1;
-
-    // Maybe root ast here should set global as scope?
 
     for (int i = 0; i < BUILTIN_FNS_LN; i++)
         htab_ins(
-            global->here, BUILTIN_FNS[i].name,
+            global, BUILTIN_FNS[i].name,
             ast_init(AST_TYPE_BIF, ast_bif_data_init(BUILTIN_FNS[i].fn))
         );
 
-    log_dbg("Completed startup sequence.");
+    // Push global namespace to `scope`.
+    stack_push(scope, global);
 
-    AST* res = exec_exp(ast, global);
+    return exec_exp(ast);
-    log_dbgf("global addr %p uses %d", global, global->uses);
-    scope_destroy_psv(global);
-    return res;
 }
 
-AST* exec_exp(AST* ast, Scope* parent) {
+AST* exec_exp(AST* ast) {
     switch (ast->type) {
-        case AST_TYPE_BLOCK: return exec_block(ast, parent);
+        case AST_TYPE_BLOCK: return exec_block(ast);
-        case AST_TYPE_CALL:  return exec_call(ast, parent);
+        case AST_TYPE_CALL:  return exec_call(ast);
         case AST_TYPE_NUM:   return ast;
-        case AST_TYPE_VREF:  return exec_vref(ast, parent);
+        case AST_TYPE_VREF:  return exec_vref(ast);
-        case AST_TYPE_VDEF:  return exec_vdef(ast, parent);
+        case AST_TYPE_VDEF:  return exec_vdef(ast);
-        case AST_TYPE_FDEF:  return exec_fdef(ast, parent);
+        case AST_TYPE_FDEF:  return exec_fdef(ast);
         default:             printf("what\n"); exit(1);
     }
 }
 
-AST* exec_block(AST* ast, Scope* parent) {
+AST* exec_block(AST* ast) {
     ASTBlockData* block = (ASTBlockData*)ast->data;
 
-    // Blocks create their own scope, shared among their expressions.
+    HTab* local = htab_init();
-    // ast->scope = scope_init(parent);
+    stack_push(scope, local);
-
-    // HERE
-    exec_new_scope(ast, parent);
 
     // Loop through all but last ast.
-    for (int i = 0; i < block->ln - 1; i++)
+    for (int i = 0; i < block->ln - 1; i++) exec_exp(block->inside[i]);
-        exec_exp(block->inside[i], ast->scope);
+    AST* last = exec_exp(block->inside[block->ln - 1]);
-    AST* last = exec_exp(block->inside[block->ln - 1], ast->scope);
+
+    stack_pop(scope);
+    htab_destroy(local);
 
     return last;
 }
 
-AST* exec_call(AST* ast, Scope* parent) {
+AST* exec_call(AST* ast) {
     log_dbg("Started call execution.");
     ASTCallData* data = (ASTCallData*)ast->data;
     size_t argc = data->argc;
     AST** argv = data->argv;
     char* fname = data->to;
 
-    ast->scope = parent;
+    AST* fdef = exec_find(fname);
-
-    AST* fdef = ast_find(ast->scope, fname);
 
     if (fdef == NULL)
         return ast_init(
@@ -79,7 +76,7 @@ AST* exec_call(AST* ast, Scope* parent) {
     switch (fdef->type) {
         case AST_TYPE_BIF:
             ASTBIFData bifdata = fdef->data;
-            return bifdata(argc, argv, parent);
+            return bifdata(argc, argv);
         case AST_TYPE_FDEF: return exec_cf(fdef, argc, argv);
         default:
             return ast_init(AST_TYPE_EXC, ast_exc_data_init("Good job!", NULL));
@@ -87,41 +84,41 @@ AST* exec_call(AST* ast, Scope* parent) {
 }
 
 AST* exec_cf(AST* ast, size_t argc, AST** argv) {
-    Scope* callscope = scope_init(ast->scope);
     ASTFDefData* fdef = (ASTFDefData*)ast->data;
     for (int i = 0; i < argc; i++) {
         char* key = ((ASTArgData*)fdef->argv[i]->data)->name;
         AST* val = argv[i];
-        scope_add(callscope, key, val);
+        htab_ins(scope->buf[scope->ln - 1], key, val);
     }
 
-    return exec_exp(fdef->body, callscope);
+    return exec_exp(fdef->body);
 }
 
-AST* exec_vdef(AST* ast, Scope* parent) {
+AST* exec_find(char* name) {
-    // Use parent's scope.
+    AST* val = NULL;
-    // ast->scope = parent;
 
-    // HERE
+    for (int i = scope->ln - 1; i >= 0; i--) {
-    exec_inherit_scope(ast, parent);
+        HTab* lvl = scope->buf[i];
+        val = htab_get(lvl, name);
+        if (val != NULL) return val;
+    }
 
+    return NULL;
+}
+
+AST* exec_vdef(AST* ast) {
     ASTVDefData* data = (ASTVDefData*)ast->data;
     AST* val = data->val;
     char* key = data->name;
-    scope_add(parent, key, val); // Add variable definition to parent scope.
+    htab_ins(scope->buf[scope->ln - 1], key, val);
-    return exec_exp(val, parent);
+    return exec_exp(val);
 }
 
-AST* exec_vref(AST* ast, Scope* parent) {
+AST* exec_vref(AST* ast) {
-    // Use parent's scope.
-    // ast->scope = parent;
-
-    // HERE
-    exec_inherit_scope(ast, parent);
     log_dbg("attempting to reference var");
     ASTVrefData* vref = (ASTVrefData*)ast->data;
 
-    AST* found = ast_find(parent, vref->to);
+    AST* found = exec_find(vref->to);
 
     if (found == NULL) {
         // TODO: Better memory management here.
@@ -133,32 +130,15 @@ AST* exec_vref(AST* ast, Scope* parent) {
         return ast_init(AST_TYPE_EXC, ast_exc_data_init(msg, NULL));
     }
 
-    return exec_exp(found, ast->scope);
+    return exec_exp(found);
 }
 
-AST* exec_fdef(AST* ast, Scope* parent) {
+AST* exec_fdef(AST* ast) {
-    ast->scope = scope_init(parent);
     ASTFDefData* fdef = (ASTFDefData*)ast->data;
     AST* val = fdef->body;
     char* key = fdef->name;
-    scope_add(parent, key, val);
+    htab_ins(scope->buf[scope->ln - 1], key, val);
     return val; // Function definitions return function body.
 }
 
 void exec_print(double n) { printf("= %lf\n", n); }
-
-inline void exec_new_scope(AST* ast, Scope* inherit) {
-    Scope* scope = scope_init(inherit);
-    ast->scope = scope;
-
-    // Update linked status.
-    scope->uses++;
-    // if (inherit) inherit->uses++;
-}
-
-inline void exec_inherit_scope(AST* ast, Scope* inherit) {
-    ast->scope = inherit;
-
-    // Update uses.
-    inherit->uses++;
-}

src/htab.c

@@ -7,7 +7,7 @@
 #include <string.h>
 
 HTab* htab_init() {
-    HTab* htab = malloc(sizeof(HTab));
+    HTab* htab = calloc(1, sizeof(HTab));
 
     return htab;
 }

src/include/ast.h

@@ -1,7 +1,7 @@
 #ifndef AST_H
 #define AST_H
 
-#include "scope.h"
+#include "htab.h"
 #include <stdlib.h>
 
 // The type of an `AST`.
@@ -32,13 +32,13 @@ typedef enum {
 typedef struct {
     ASTType type; // The type of the `AST`.
     void* data;   // The data of the `AST`.
-    Scope* scope; // The scope of the `AST`.
+    HTab* scope;  // The scope of the `AST`.
 } AST;
 
 // Create a new `AST`.
 AST* ast_init(ASTType type, void* data);
 // Create a new `AST` with a specified scope.
-AST* ast_init_scope(ASTType type, void* data, Scope* scope);
+AST* ast_init_scope(ASTType type, void* data, HTab* scope);
 // Destroy an `AST`, recursively.
 void ast_destroy(AST* ast);
 // Print an `AST`, recursively.
@@ -69,10 +69,10 @@ void ast_exc_data_destroy(ASTExcData* exc);
 void ast_exc_print(ASTExcData*, int i);
 
 // A built-in function.
-typedef AST* (*ASTBIFData)(size_t argc, AST** argv, Scope* scope);
+typedef AST* (*ASTBIFData)(size_t argc, AST** argv);
 
 // Create a built-in function.
-ASTBIFData* ast_bif_data_init(AST* fn(size_t, AST**, Scope*));
+ASTBIFData* ast_bif_data_init(AST* fn(size_t, AST**));
 
 // There is no `ASTBIFData` destroy function, as function pointers are immortal.
 
@@ -153,7 +153,4 @@ void ast_arg_data_destroy(ASTArgData* arg);
 // Print an `ASTArgData`.
 void ast_arg_print(ASTArgData* arg, int i);
 
-// Find a name in the scope.
-AST* ast_find(Scope* scope, char* name);
-
 #endif

src/include/builtin.h

@@ -4,20 +4,20 @@
 #include "ast.h"
 
 // Sum some nums.
-AST* builtin_sum(size_t argc, AST** argv, Scope* parent);
+AST* builtin_sum(size_t argc, AST** argv);
 
 // Subtract nums.
-AST* builtin_sub(size_t argc, AST** argv, Scope* parent);
+AST* builtin_sub(size_t argc, AST** argv);
 
 // Multiply nums.
-AST* builtin_mul(size_t argc, AST** argv, Scope* parent);
+AST* builtin_mul(size_t argc, AST** argv);
 
 // Divide nums.
-AST* builtin_div(size_t argc, AST** argv, Scope* parent);
+AST* builtin_div(size_t argc, AST** argv);
 
 struct builtin_data {
     char* name;
-    AST* (*fn)(size_t argc, AST** argv, Scope* parent);
+    AST* (*fn)(size_t argc, AST** argv);
 };
 
 static struct builtin_data BUILTIN_FNS[] = {

src/include/exec.h

@@ -2,31 +2,28 @@
 #define EXEC_H
 
 #include "ast.h"
-#include "scope.h"
+#include "stack.h"
+
+// The `Stack` of `HTab` that makes up the scope of any given `AST`.
+extern Stack* scope;
 
 // Start executing at the root of the AST. Initialize the `scope`.
 AST* exec_start(AST* ast);
 // Execute an expression. Delegates to the other executor functions.
-AST* exec_exp(AST* ast, Scope* parent);
+AST* exec_exp(AST* ast);
 // Execute the expressions of a block.
-AST* exec_block(AST* ast, Scope* parent);
+AST* exec_block(AST* ast);
 // Execute a call.
-AST* exec_call(AST* ast, Scope* parent);
+AST* exec_call(AST* ast);
 // Execute a custom function call.
 AST* exec_cf(AST* ast, size_t argc, AST** argv);
-// Execute a variable definition.
-AST* exec_vdef(AST* ast, Scope* parent);
 // Execute a variable reference.
-AST* exec_vref(AST* ast, Scope* parent);
+AST* exec_vref(AST* ast);
+// Execute a variable definition.
+AST* exec_vdef(AST* ast);
 // Execute a function definition.
-AST* exec_fdef(AST* ast, Scope* parent);
+AST* exec_fdef(AST* ast);
 // Print the result of an execution.
 void exec_print(double n);
 
-// Create a new scope and mark it as linked. Also update inherited scope.
-void exec_new_scope(AST* ast, Scope* inherit);
-
-// Inherit from another scope and mark it as linked.
-void exec_inherit_scope(AST* ast, Scope* inherit);
-
 #endif

src/include/scope.h

@@ -1,22 +0,0 @@
-#ifndef SCOPE_H
-#define SCOPE_H
-
-#include "htab.h"
-
-// Represents the reverse linked tree of scope.
-typedef struct SCOPE_T {
-    HTab* here; // This scope's hash table.
-    struct SCOPE_T* inherit; // The scope to inherit from.
-    int uses; // How many `AST`s are linked to this scope.
-} Scope;
-
-// Create a new `Scope`. Creates new empty `HTab` for current scope.
-Scope* scope_init(Scope* inherit);
-// Destroy all linked `Scope`s this inherits from.
-void scope_destroy(Scope* scope);
-// Destroy the current `Scope` only.
-void scope_destroy_psv(Scope *scope);
-// Insert a key/val pair into the `HTab` of a `Scope`.
-void scope_add(Scope* scope, char* key, void* val);
-
-#endif

src/main.c

@@ -4,8 +4,10 @@
 #include "include/ast.h"
 #include "include/dstr.h"
 #include "include/exec.h"
-
+#include "include/global.h"
+#include "include/htab.h"
 #include "include/lexer.h"
+#include "include/stack.h"
 #include "include/util.h"
 
 #include "../build/grammars/grammar.tab.h"
@@ -15,11 +17,16 @@ extern AST* root;
 extern char* inp;
 extern int yyparse();
 
+Stack* scope;
+
 int main(int argc, char** argv) {
 
     if (argc - 1 && strlen(argv[1]) > 0 && (inp = argv[1]) && !yyparse()) {
         log_dbg("Parsed successfully!\n");
         ast_print(exec_start(root));
+        HTab* global = stack_pop(scope);
+        htab_destroy(global);
+        stack_destroy(scope);
         ast_destroy(root);
         exit(0);
     }
@@ -56,6 +63,9 @@ int main(int argc, char** argv) {
 #endif
 
             ast_print(exec_start(root));
+            HTab* global = stack_pop(scope);
+            htab_destroy(global);
+            stack_destroy(scope);
 
             ast_destroy(root);
         }

src/scope.c

@@ -1,37 +0,0 @@
-#include "include/scope.h"
-#include "include/htab.h"
-#include "include/util.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-Scope* scope_init(Scope* inherit) {
-    Scope* scope = malloc(sizeof(Scope));
-
-    scope->here = htab_init();
-    scope->inherit = inherit;
-    scope->uses = 0;
-
-    log_dbgf("%p: new scope, inherits from %p", scope, inherit);
-
-    return scope;
-}
-
-void scope_destroy(Scope* scope) {
-    if (!scope) return;
-    htab_destroy(scope->here);
-    if (scope->inherit != NULL) scope_destroy(scope->inherit);
-    free(scope);
-}
-
-void scope_destroy_psv(Scope* scope) {
-    log_dbgf("%p got here", scope);
-    if (!scope) return;
-    htab_destroy(scope->here);
-    scope->inherit = NULL;
-    free(scope);
-    log_dbgf("%p got here 2", scope);
-}
-
-inline void scope_add(Scope* scope, char* key, void* val) {
-    htab_ins(scope->here, key, val);
-}

test/Unity

@@ -1 +1 @@
-Subproject commit 73237c5d224169c7b4d2ec8321f9ac92e8071708
+Subproject commit cdf1d0297effc2736ee847e557b4275b4f02310b