Bump version in README.md.

🎉

README.md

@@ -1,6 +1,6 @@
 # SCL: Simple CAS Language
 
-Version v1.0-alpha
+Version v1.0-beta
 
 SCL aims to be a human-friendly Computer Algebra System (CAS) inspired by
 [maxima](https://maxima.sourceforge.io/) that feels like writing on paper. In

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=c2x
+CC = clang -std=c23
 LINK = clang
 CFLAGS = -Wall -DDBG -ggdb -fsanitize=leak
 LDFLAGS = -lm

src/ast.c

@@ -1,8 +1,10 @@
+#include <inttypes.h>
 #include <stdio.h>
 
 #include "include/ast.h"
 #include "include/dstr.h"
-#include "include/htab.h"
+#include "include/gc.h"
+#include "include/scope.h"
 #include "include/util.h"
 
 extern AST* root;
@@ -19,16 +21,23 @@ static char* asttype_names[] = {
 };
 
 AST* ast_init(ASTType type, void* data) {
-    AST* ast = malloc(sizeof(AST));
+    AST* ast = gc_alloc(sizeof(AST), GC_TYPE_AST);
 
     ast->type = type;
     ast->data = data;
     ast->scope = NULL;
 
+    if (ast->type > AST_TYPE_MAX) {
+        log_dbgf(
+            "Attempted to create invalid AST (%i > %i) to GC: ast:%p",
+            ast->type, AST_TYPE_MAX, ast
+        );
+    }
+
     return ast;
 }
 
-AST* ast_init_scope(ASTType type, void* data, HTab* scope) {
+AST* ast_init_scope(ASTType type, void* data, Scope* scope) {
     AST* ast = malloc(sizeof(AST));
 
     ast->type = type;
@@ -53,11 +62,36 @@ 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 && !--ast->scope->uses) scope_destroy_psv(ast->scope);
+
     free(ast);
-    htab_destroy(ast->scope);
 }
 
-void ast_print(AST* ast) { ast_print_i(ast, 0); }
+void ast_destroy_psv(AST* ast) {
+    if (!ast) return;
+
+    switch (ast->type) {
+        case AST_TYPE_NUM:   ast_num_data_destroy(ast->data); break;
+        case AST_TYPE_CALL:  ast_call_data_destroy_psv(ast->data); break;
+        case AST_TYPE_VREF:  ast_vref_data_destroy(ast->data); break;
+        case AST_TYPE_VDEF:  ast_vdef_data_destroy_psv(ast->data); break;
+        case AST_TYPE_BLOCK: ast_block_data_destroy_psv(ast->data); break;
+        case AST_TYPE_FDEF:  ast_fdef_data_destroy_psv(ast->data); break;
+        case AST_TYPE_ARG:   ast_arg_data_destroy(ast->data); break;
+        case AST_TYPE_BIF:   ast_bif_data_destroy(ast->data); break;
+        case AST_TYPE_EXC:   ast_exc_data_destroy(ast->data); break;
+        default:
+            log_dbgf("Unknown ast type %d (max: %d)", ast->type, AST_TYPE_MAX);
+    }
+
+    free(ast);
+}
+
+void ast_print(AST* ast) {
+    if (!ast) return;
+    ast_print_i(ast, 0);
+}
 
 void ast_print_i(AST* ast, int i) {
     INDENT_BEGIN(i);
@@ -101,13 +135,18 @@ void ast_num_print(ASTNumData* data, int i) {
     INDENT_END;
 }
 
-ASTExcData* ast_exc_data_init(char* msg, AST* trace) {
+ASTExcData* ast_exc_data_init(const char* msg, AST* trace) {
     ASTExcData* data = malloc(sizeof(ASTExcData));
     data->msg = msg;
     data->trace = trace;
     return data;
 }
 
+void ast_exc_data_destroy(ASTExcData* exc) {
+    // `msg` is static, and `trace` will get freed in GC.
+    free(exc);
+}
+
 void ast_exc_print(ASTExcData* data, int i) {
     INDENT_BEGIN(i);
 
@@ -123,10 +162,12 @@ void ast_exc_print(ASTExcData* data, int i) {
     INDENT_END;
 }
 
-ASTBIFData* ast_bif_data_init(AST* fn(size_t, AST**)) {
+ASTBIFData* ast_bif_data_init(AST* fn(size_t, AST**, Scope*)) {
     return (ASTBIFData*)fn;
 }
 
+void ast_bif_data_destroy(ASTBIFData* bif) { return; }
+
 ASTCallData* ast_call_data_init(char* to, size_t argc, AST** argv) {
     talloc(ASTCallData, call);
 
@@ -147,6 +188,15 @@ void ast_call_data_destroy(ASTCallData* call) {
     free(call);
 }
 
+void ast_call_data_destroy_psv(ASTCallData* call) {
+    if (!call) return;
+    free(call->to);
+    call->to = NULL;
+    free(call->argv);
+    call->argv = NULL;
+    free(call);
+}
+
 void ast_call_print(ASTCallData* data, int i) {
     INDENT_BEGIN(i);
 
@@ -173,6 +223,11 @@ void ast_vdef_data_destroy(ASTVDefData* vdef) {
     free(vdef);
 }
 
+void ast_vdef_data_destroy_psv(ASTVDefData* vdef) {
+    free(vdef->name);
+    free(vdef);
+}
+
 void ast_vdef_print(ASTVDefData* vdef, int depth) {
     INDENT_BEGIN(depth);
 
@@ -223,6 +278,11 @@ void ast_block_data_destroy(ASTBlockData* block) {
     free(block);
 }
 
+void ast_block_data_destroy_psv(ASTBlockData* block) {
+    free(block->inside);
+    free(block);
+}
+
 void ast_block_print(ASTBlockData* data, int depth) {
     INDENT_BEGIN(depth);
 
@@ -251,6 +311,12 @@ void ast_fdef_data_destroy(ASTFDefData* fdef) {
     ast_destroy(fdef->body);
 }
 
+void ast_fdef_data_destroy_psv(ASTFDefData* fdef) {
+    free(fdef->name);
+    free(fdef->argv);
+    free(fdef);
+}
+
 void ast_fdef_print(ASTFDefData* fdef, int i) {
     INDENT_BEGIN(i)
     INDENT_TITLE("ASTFDefData", fdef);
@@ -260,6 +326,7 @@ void ast_fdef_print(ASTFDefData* fdef, int i) {
     INDENT_FIELD_EXT_NONL_START("body");
     ast_print_i(fdef->body, i + 2);
     INDENT_FIELD_NONL_END;
+    INDENT_END;
 }
 
 ASTArgData* ast_arg_data_init(char* name) {
@@ -276,3 +343,13 @@ 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) {
+AST* builtin_sum(size_t argc, AST** argv, Scope* parent) {
     ASTNumData total = 0;
 
     for (int i = 0; i < argc; i++) {
-        AST* arg = exec_exp(argv[i]);
+        AST* arg = exec_exp(argv[i], parent);
         if (arg->type == AST_TYPE_EXC)
             return ast_init(
                 AST_TYPE_EXC,
@@ -27,9 +27,9 @@ AST* builtin_sum(size_t argc, AST** argv) {
     return ast_init(AST_TYPE_NUM, ast_num_data_init(total));
 }
 
-AST* builtin_sub(size_t argc, AST** argv) {
+AST* builtin_sub(size_t argc, AST** argv, Scope* parent) {
     log_dbg("Got here");
-    AST* first = exec_exp(*argv);
+    AST* first = exec_exp(*argv, parent);
     if (first->type == AST_TYPE_EXC)
         return ast_init(
             AST_TYPE_EXC,
@@ -44,7 +44,7 @@ AST* builtin_sub(size_t argc, AST** argv) {
     ASTNumData total = *(ASTNumData*)first->data;
 
     for (int i = 1; i < argc; i++) {
-        AST* arg = exec_exp(argv[i]);
+        AST* arg = exec_exp(argv[i], parent);
         if (arg->type == AST_TYPE_EXC)
             return ast_init(
                 AST_TYPE_EXC,
@@ -62,9 +62,9 @@ AST* builtin_sub(size_t argc, AST** argv) {
     return ast_init(AST_TYPE_NUM, ast_num_data_init(total));
 }
 
-AST* builtin_mul(size_t argc, AST** argv) {
+AST* builtin_mul(size_t argc, AST** argv, Scope* parent) {
     log_dbg("Got here");
-    AST* first = exec_exp(*argv);
+    AST* first = exec_exp(*argv, parent);
     if (first->type == AST_TYPE_EXC)
         return ast_init(
             AST_TYPE_EXC,
@@ -79,7 +79,7 @@ AST* builtin_mul(size_t argc, AST** argv) {
     ASTNumData total = *(ASTNumData*)first->data;
 
     for (int i = 1; i < argc; i++) {
-        AST* arg = exec_exp(argv[i]);
+        AST* arg = exec_exp(argv[i], parent);
         if (arg->type == AST_TYPE_EXC)
             return ast_init(
                 AST_TYPE_EXC,
@@ -97,9 +97,9 @@ AST* builtin_mul(size_t argc, AST** argv) {
     return ast_init(AST_TYPE_NUM, ast_num_data_init(total));
 }
 
-AST* builtin_div(size_t argc, AST** argv) {
+AST* builtin_div(size_t argc, AST** argv, Scope* parent) {
     log_dbg("Got here");
-    AST* first = exec_exp(*argv);
+    AST* first = exec_exp(*argv, parent);
     if (first->type == AST_TYPE_EXC)
         return ast_init(
             AST_TYPE_EXC,
@@ -114,7 +114,7 @@ AST* builtin_div(size_t argc, AST** argv) {
     ASTNumData total = *(ASTNumData*)first->data;
 
     for (int i = 1; i < argc; i++) {
-        AST* arg = exec_exp(argv[i]);
+        AST* arg = exec_exp(argv[i], parent);
         if (arg->type == AST_TYPE_EXC)
             return ast_init(
                 AST_TYPE_EXC,

src/exec.c

@@ -4,69 +4,71 @@
 
 #include "include/ast.h"
 #include "include/builtin.h"
+#include "include/dlist.h"
 #include "include/exec.h"
 #include "include/htab.h"
-#include "include/stack.h"
+#include "include/scope.h"
 #include "include/util.h"
 
-extern AST* root;
-
-AST* exec_find(char* name);
-
 AST* exec_start(AST* ast) {
     log_dbg("Started execution.");
-    Stack* scope = stack_init();
 
-    HTab* global = htab_init();
+    if (!ast) return ast;
+
+    Scope* global = scope_init(NULL);
+    global->uses = 1;
 
     for (int i = 0; i < BUILTIN_FNS_LN; i++)
         htab_ins(
-            global, BUILTIN_FNS[i].name,
+            global->here, BUILTIN_FNS[i].name,
             ast_init(AST_TYPE_BIF, ast_bif_data_init(BUILTIN_FNS[i].fn))
         );
 
-    // Push global namespace to `scope`.
-    stack_push(scope, global);
+    log_dbg("Completed startup sequence.");
 
-    return exec_exp(ast);
+    AST* res = exec_exp(ast, global);
+
+    return res;
 }
 
-AST* exec_exp(AST* ast) {
+AST* exec_exp(AST* ast, Scope* parent) {
     switch (ast->type) {
-        case AST_TYPE_BLOCK: return exec_block(ast);
-        case AST_TYPE_CALL:  return exec_call(ast);
-        case AST_TYPE_NUM:   return ast;
-        case AST_TYPE_VREF:  return exec_vref(ast);
-        case AST_TYPE_VDEF:  return exec_vdef(ast);
-        case AST_TYPE_FDEF:  return exec_fdef(ast);
+        case AST_TYPE_BLOCK: return exec_block(ast, parent);
+        case AST_TYPE_CALL:  return exec_call(ast, parent);
+        case AST_TYPE_NUM:
+            return ast_init(
+                AST_TYPE_NUM, ast_num_data_init(*(ASTNumData*)ast->data)
+            );
+        case AST_TYPE_VREF: return exec_vref(ast, parent);
+        case AST_TYPE_VDEF: return exec_vdef(ast, parent);
+        case AST_TYPE_FDEF: return exec_fdef(ast, parent);
         default:            printf("what\n"); exit(1);
     }
 }
 
-AST* exec_block(AST* ast) {
+AST* exec_block(AST* ast, Scope* parent) {
     ASTBlockData* block = (ASTBlockData*)ast->data;
 
-    HTab* local = htab_init();
-    //stack_push(scope, local);
+    exec_new_scope(ast, parent);
 
     // Loop through all but last ast.
-    for (int i = 0; i < block->ln - 1; i++) exec_exp(block->inside[i]);
-    AST* last = exec_exp(block->inside[block->ln - 1]);
-
-    //stack_pop(scope);
-    htab_destroy(local);
+    for (int i = 0; i < block->ln - 1; i++)
+        exec_exp(block->inside[i], ast->scope);
+    AST* last = exec_exp(block->inside[block->ln - 1], ast->scope);
 
     return last;
 }
 
-AST* exec_call(AST* ast) {
+AST* exec_call(AST* ast, Scope* parent) {
     log_dbg("Started call execution.");
     ASTCallData* data = (ASTCallData*)ast->data;
     size_t argc = data->argc;
     AST** argv = data->argv;
     char* fname = data->to;
 
-    AST* fdef = exec_find(fname);
+    ast->scope = parent;
+
+    AST* fdef = ast_find(ast->scope, fname);
 
     if (fdef == NULL)
         return ast_init(
@@ -76,7 +78,7 @@ AST* exec_call(AST* ast) {
     switch (fdef->type) {
         case AST_TYPE_BIF:
             ASTBIFData bifdata = fdef->data;
-            return bifdata(argc, argv);
+            return bifdata(argc, argv, parent);
         case AST_TYPE_FDEF: return exec_cf(fdef, argc, argv);
         default:
             return ast_init(AST_TYPE_EXC, ast_exc_data_init("Good job!", NULL));
@@ -84,42 +86,35 @@ AST* exec_call(AST* ast) {
 }
 
 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];
-        //htab_ins(scope->buf[scope->ln - 1], key, val);
+        scope_add(callscope, key, val);
     }
 
-    return exec_exp(fdef->body);
+    return exec_exp(fdef->body, callscope);
 }
 
-AST* exec_find(char* name) {
-    AST* val = NULL;
+AST* exec_vdef(AST* ast, Scope* parent) {
+    // Use parent's scope.
+    exec_inherit_scope(ast, parent);
 
-    /*
-    for (int i = scope->ln - 1; i >= 0; i--) {
-        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;
-    //htab_ins(scope->buf[scope->ln - 1], key, val);
-    return exec_exp(val);
+    scope_add(parent, key, val); // Add variable definition to parent scope.
+    return exec_exp(val, parent);
 }
 
-AST* exec_vref(AST* ast) {
+AST* exec_vref(AST* ast, Scope* parent) {
+    // Use parent's scope.
+    exec_inherit_scope(ast, parent);
     log_dbg("attempting to reference var");
     ASTVrefData* vref = (ASTVrefData*)ast->data;
 
-    AST* found = exec_find(vref->to);
+    AST* found = ast_find(parent, vref->to);
 
     if (found == NULL) {
         // TODO: Better memory management here.
@@ -131,15 +126,33 @@ AST* exec_vref(AST* ast) {
         return ast_init(AST_TYPE_EXC, ast_exc_data_init(msg, NULL));
     }
 
-    return exec_exp(found);
+    return exec_exp(found, ast->scope);
 }
 
-AST* exec_fdef(AST* ast) {
+AST* exec_fdef(AST* ast, Scope* parent) {
+    ast->scope = scope_init(parent);
     ASTFDefData* fdef = (ASTFDefData*)ast->data;
-    AST* val = fdef->body;
+    log_dbgf("IS THIS SUSPICIOUS??? %i", fdef->body->type);
+    AST* val = ast;
     char* key = fdef->name;
-    //htab_ins(scope->buf[scope->ln - 1], key, val);
-    return val; // Function definitions return function body.
+    scope_add(parent, key, val);
+    // TODO: Create lambda functions.
+    return fdef->body; // 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++;
+}
+
+inline void exec_inherit_scope(AST* ast, Scope* inherit) {
+    ast->scope = inherit;
+
+    // Update uses.
+    inherit->uses++;
+}

src/gc.c

@@ -0,0 +1,57 @@
+#include "include/gc.h"
+#include "include/ast.h"
+#include "include/scope.h"
+#include "include/util.h"
+#include <assert.h>
+#include <stdio.h>
+
+#include <stddef.h>
+
+GC* gclist = NULL;
+
+void gc_destroy(GC* gc) { free(gc); }
+
+void f() {}
+
+void* gc_alloc(size_t sz, GCType type) {
+    assert(type <= GC_TYPE_MAX);
+
+    void* mem = malloc(sz);
+    GC* gc = malloc(sizeof(GC));
+
+    gc->p = mem;
+    gc->type = type;
+    gc->marked = false;
+    gc->nxt = gclist;
+    gclist = gc;
+
+    if (type == GC_TYPE_AST) {
+        log_dbgf("Alloc'd AST for GC: %p", mem);
+    } else if (type == GC_TYPE_SCOPE) {
+        log_dbgf("Alloc'd scope for GC: %p", mem);
+    }
+
+    return mem;
+}
+
+void gc_hack_free() {
+    while (gclist) {
+        GC* gc = gclist;
+        gclist = gclist->nxt;
+        switch (gc->type) {
+            case GC_TYPE_AST:
+                f();
+                if (((AST*)gc->p)->type > AST_TYPE_MAX) {
+                    log_dbgf(
+                        "Attempted to free invalid AST (%i > %i) to GC: gc:%p "
+                        "ast:%p",
+                        ((AST*)gc->p)->type, AST_TYPE_MAX, gc, gc->p
+                    );
+                }
+                ast_destroy_psv(gc->p);
+                break;
+            case GC_TYPE_SCOPE: scope_destroy_psv(gc->p); break;
+        }
+        gc_destroy(gc);
+    }
+}

src/grammar.y

@@ -85,6 +85,7 @@ inputend:
     %empty
     | input {
         root = ast_init(AST_TYPE_BLOCK, ast_block_data_init((AST**) $1->buf, $1->ln));
+        dlist_destroypsv($1);
     }
     ;
 
@@ -123,7 +124,13 @@ block:
 exp:
     NUM { $$ = ast_init(AST_TYPE_NUM, ast_num_data_init($1)); }
 
-    //| BLOCKS exp BLOCKE { $$ = $2; }
+    // Function definitions.
+    | WORD GROUPS arg GROUPE EQ exp {
+        size_t argc = $3->ln;
+        AST** argv = $3->buf;
+        argarr_destroypsv($3);
+        $$ = ast_init(AST_TYPE_FDEF, ast_fdef_data_init($1, argc, argv, $6));
+    }
 
     | BLOCKS block BLOCKE {
         $$ = ast_init(AST_TYPE_BLOCK, ast_block_data_init((AST**) $2->buf, $2->ln));
@@ -192,11 +199,4 @@ exp:
         strcpy(to, "div");
         $$ = ast_init(AST_TYPE_CALL, ast_call_data_init(to, 2, argv));
     }
-
-    | WORD GROUPS arg GROUPE EQ exp {
-        size_t argc = $3->ln;
-        AST** argv = $3->buf;
-        argarr_destroypsv($3);
-        $$ = ast_init(AST_TYPE_FDEF, ast_fdef_data_init($1, argc, argv, $6));
-    }
 %%

src/htab.c

@@ -9,6 +9,8 @@
 HTab* htab_init() {
     HTab* htab = calloc(1, sizeof(HTab));
 
+    log_dbgf("HTAB %p", htab);
+
     return htab;
 }
 
@@ -29,7 +31,6 @@ void* htab_get(HTab* htab, char* key) {
 
 void htab_ins(HTab* htab, char* key, void* data) {
     size_t i = geti(key);
-    // assert((*htab)[i] == NULL);
     (*htab)[i] = data;
     log_dbgf("Inserted something to hash table @ index %lu", i);
 }

src/include/ast.h

@@ -1,7 +1,7 @@
 #ifndef AST_H
 #define AST_H
 
-#include "htab.h"
+#include "scope.h"
 #include <stdlib.h>
 
 // The type of an `AST`.
@@ -25,22 +25,24 @@ typedef enum {
     AST_TYPE_BLOCK, // A block of code (scope).
     AST_TYPE_FDEF,  // A function definition.
     AST_TYPE_ARG,   // A definition argument.
-    AST_TYPE_MAX = AST_TYPE_FDEF,
+    AST_TYPE_MAX = AST_TYPE_ARG,
 } ASTType;
 
 // An Abstract Syntax Tree.
 typedef struct {
     ASTType type; // The type of the `AST`.
     void* data;   // The data of the `AST`.
-    HTab* scope;  // The scope of the `AST`.
+    Scope* 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, HTab* scope);
+AST* ast_init_scope(ASTType type, void* data, Scope* scope);
 // Destroy an `AST`, recursively.
 void ast_destroy(AST* ast);
+// Destroy an `AST`.
+void ast_destroy_psv(AST* ast);
 // Print an `AST`, recursively.
 void ast_print(AST* ast);
 // Helper function to `ast_print()`, where `i` is indentation level.
@@ -58,23 +60,23 @@ void ast_num_print(ASTNumData*, int i);
 
 // An exception.
 typedef struct ASTEXCDATA {
-    char* msg;  // The exception message.
+    const char* msg;  // The exception message.
     AST* trace; // The previous exception.
 } ASTExcData;
-// Create a new `ASTExecData.
-ASTExcData* ast_exc_data_init(char* msg, AST* trace);
+// Create a new `ASTExecData. `msg` should be static.
+ASTExcData* ast_exc_data_init(const char* msg, AST* trace);
 // Destroy an `ASTExecData`.
 void ast_exc_data_destroy(ASTExcData* exc);
 // Print an `ASTExecData`.
 void ast_exc_print(ASTExcData*, int i);
 
 // A built-in function.
-typedef AST* (*ASTBIFData)(size_t argc, AST** argv);
+typedef AST* (*ASTBIFData)(size_t argc, AST** argv, Scope* scope);
 
 // Create a built-in function.
-ASTBIFData* ast_bif_data_init(AST* fn(size_t, AST**));
-
-// There is no `ASTBIFData` destroy function, as function pointers are immortal.
+ASTBIFData* ast_bif_data_init(AST* fn(size_t, AST**, Scope*));
+// Destroy an `ASTBIFData`.
+void ast_bif_data_destroy(ASTBIFData* bif);
 
 // A call (to a function).
 typedef struct {
@@ -85,8 +87,10 @@ typedef struct {
 
 // Create a new `ASTCallData`.
 ASTCallData* ast_call_data_init(char* to, size_t argc, AST** argv);
-// Destroy an `ASTCallData`.
+// Destroy an `ASTCallData` recursively.
 void ast_call_data_destroy(ASTCallData* call);
+// Destroy an `ASTCallData`.
+void ast_call_data_destroy_psv(ASTCallData *call);
 // Print an `ASTCallData`.
 void ast_call_print(ASTCallData*, int i);
 
@@ -100,6 +104,8 @@ typedef struct {
 ASTVDefData* ast_vdef_data_init(char* name, AST* val);
 // Destroys the `ASTVDefData`, `ASTVDefData->name`, and `ASTVDefData->val`.
 void ast_vdef_data_destroy(ASTVDefData* vdef);
+// Destroy an `ASTVDefData`.
+void ast_vdef_data_destroy_psv(ASTVDefData* vdef);
 // Print an `ASTVDefData`.
 void ast_vdef_print(ASTVDefData*, int depth);
 
@@ -125,6 +131,8 @@ typedef struct {
 ASTBlockData* ast_block_data_init(AST** inside, size_t ln);
 // Destroy an `ASTBlockData`, recursively.
 void ast_block_data_destroy(ASTBlockData* block);
+// Destroy an `ASTBlockData`.
+void ast_block_data_destroy_psv(ASTBlockData *block);
 // Print an `ASTBlockData`.
 void ast_block_print(ASTBlockData*, int i);
 
@@ -137,8 +145,10 @@ typedef struct {
 
 // Create a new `ASTFDefData`.
 ASTFDefData* ast_fdef_data_init(char* name, size_t argc, AST** argv, AST* body);
-// Destroy an `ASTFDefData`.
+// Destroy an `ASTFDefData`, recursively.
 void ast_fdef_data_destroy(ASTFDefData* fdef);
+// Destroy an `ASTFDefData`.
+void ast_fdef_data_destroy_psv(ASTFDefData* fdef);
 // Print an `ASTFDefData`.
 void ast_fdef_print(ASTFDefData* fdef, int i);
 
@@ -153,4 +163,7 @@ 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);
+AST* builtin_sum(size_t argc, AST** argv, Scope* parent);
 
 // Subtract nums.
-AST* builtin_sub(size_t argc, AST** argv);
+AST* builtin_sub(size_t argc, AST** argv, Scope* parent);
 
 // Multiply nums.
-AST* builtin_mul(size_t argc, AST** argv);
+AST* builtin_mul(size_t argc, AST** argv, Scope* parent);
 
 // Divide nums.
-AST* builtin_div(size_t argc, AST** argv);
+AST* builtin_div(size_t argc, AST** argv, Scope* parent);
 
 struct builtin_data {
     char* name;
-    AST* (*fn)(size_t argc, AST** argv);
+    AST* (*fn)(size_t argc, AST** argv, Scope* parent);
 };
 
 static struct builtin_data BUILTIN_FNS[] = {

src/include/exec.h

@@ -2,25 +2,31 @@
 #define EXEC_H
 
 #include "ast.h"
-#include "stack.h"
+#include "scope.h"
 
 // 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);
+AST* exec_exp(AST* ast, Scope* parent);
 // Execute the expressions of a block.
-AST* exec_block(AST* ast);
+AST* exec_block(AST* ast, Scope* parent);
 // Execute a call.
-AST* exec_call(AST* ast);
+AST* exec_call(AST* ast, Scope* parent);
 // Execute a custom function call.
 AST* exec_cf(AST* ast, size_t argc, AST** argv);
-// Execute a variable reference.
-AST* exec_vref(AST* ast);
 // Execute a variable definition.
-AST* exec_vdef(AST* ast);
+AST* exec_vdef(AST* ast, Scope* parent);
+// Execute a variable reference.
+AST* exec_vref(AST* ast, Scope* parent);
 // Execute a function definition.
-AST* exec_fdef(AST* ast);
+AST* exec_fdef(AST* ast, Scope* parent);
 // 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/gc.h

@@ -0,0 +1,31 @@
+#ifndef GC_H
+#define GC_H
+
+#include <stdlib.h>
+
+// The type a GC can refer to.
+typedef enum {
+    GC_TYPE_AST,
+    GC_TYPE_SCOPE,
+    GC_TYPE_MAX = GC_TYPE_SCOPE
+} GCType;
+
+// Added to each AST and Scope; keep track of what's actually still accessible.
+typedef struct GC_STRUCT {
+    void* p;               // Pointer to the data.
+    struct GC_STRUCT* nxt; // The next GC in the linked list.
+    GCType type;           // What type of data.
+    bool marked;           // Whether the data is still accessible.
+} GC;
+
+GC* gc_init(void* p, GCType type, GC*);
+// Does not free ->p or ->nxt.
+void gc_destroy(GC* gc);
+
+// Allocate for an object in the heap, and keep track of it in the GC.
+void* gc_alloc(size_t sz, GCType type);
+
+// Free everything, immediately.
+void gc_hack_free();
+
+#endif

src/include/scope.h

@@ -0,0 +1,22 @@
+#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. // TODO: REMOVE.
+} 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/lexer.c

@@ -26,7 +26,7 @@ void argarr_destroy(ArgArr* argarr) {
 void argarr_destroypsv(ArgArr* argarr) { free(argarr); }
 
 void argarr_add(ArgArr* argarr, AST* arg) {
-    if ((argarr->ln + 1) * argarr->sz > argarr->sz) {
+    if ((argarr->ln + 1) * sizeof(AST*) > argarr->sz) {
         argarr->sz *= 2;
         argarr->buf = realloc(argarr->buf, argarr->sz);
         log_dbgf(

src/main.c

@@ -4,10 +4,8 @@
 #include "include/ast.h"
 #include "include/dstr.h"
 #include "include/exec.h"
-#include "include/global.h"
-#include "include/htab.h"
+#include "include/gc.h"
 #include "include/lexer.h"
-#include "include/stack.h"
 #include "include/util.h"
 
 #include "../build/grammars/grammar.tab.h"
@@ -17,17 +15,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);
+        ast_print(root);
+        AST* eval = exec_start(root);
+        ast_print(eval);
+        // ast_destroy(eval);
+        // ast_destroy(root);
+        gc_hack_free();
         exit(0);
     }
 
@@ -62,12 +59,9 @@ int main(int argc, char** argv) {
             ast_print(root);
 #endif
 
-            ast_print(exec_start(root));
-            HTab* global = stack_pop(scope);
-            htab_destroy(global);
-            stack_destroy(scope);
-
-            ast_destroy(root);
+            AST* eval = exec_start(root);
+            ast_print(eval);
+            gc_hack_free();
         }
 
         dstr_destroy(ln);

src/scope.c

@@ -0,0 +1,37 @@
+#include "include/scope.h"
+#include "include/gc.h"
+#include "include/htab.h"
+#include "include/util.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+Scope* scope_init(Scope* inherit) {
+    Scope* scope = gc_alloc(sizeof(Scope), GC_TYPE_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) {
+    if (!scope) return;
+    log_dbgf("%p: destroying", scope);
+    htab_destroy(scope->here);
+    scope->inherit = NULL;
+    free(scope);
+}
+
+inline void scope_add(Scope* scope, char* key, void* val) {
+    htab_ins(scope->here, key, val);
+}