Add initial boilerplate for closure capture

1 files changed, 16 insertions, 4 deletions

diff --git a/src/compiler.h b/src/compiler.h
index 1312d99..e91798a 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -508,18 +508,30 @@ compile_lambda(Object *obj) {
     current_context = prev_context;
     current_env = prev_env;
 
-    // Create tagged pointer with this lambda procedure.
+    // Add function address.
     context_printf("    mov     rax, %s\n", name);
     context_printf("    mov     [r15], rax\n");
+    context_printf("    mov     rax, %ld\n", array_size(obj->env->captured));
+    context_printf("    mov     [r15 + 8], rax\n");
+
+    // Add captured variables to the heap.
+    for (size_t i = 0; i < array_size(obj->env->captured); i++) {
+        ssize_t idx = find_var_index(current_env->locals, obj->env->captured[i]);
+        context_printf("    mov     rax, [rbp + %ld]\n", 8 * idx);
+        context_printf("    mov     [r15 + %ld], rax\n", 8 * (i + 2));
+        // TODO: What about capturing captured variables or parameters?
+        assert(idx != -1 && "unexpected index");
+    }
+
+    // Create tagged pointer with this lambda procedure.
     context_printf("    mov     rax, r15\n");
     context_printf("    or      rax, %zu\n", LAMBDA_TAG);
 
     // Push compiled object to the stack.
     context_printf("    push    rax\n");
 
-    // TODO: When we add closed variables they will be stored here, for now just
-    // incrementing by a 64 bit pointer size, as that is what we are storing.
-    context_printf("    add     r15, 8\n");
+    // Adjust the heap pointer depending on the number of variables captured.
+    context_printf("    add     r15, %ld\n", 8 * (array_size(obj->env->captured) + 2));
 
     context_printf("    ;; <-- compile_lambda\n");
 }