translate and execute do wraps

src/translator/dowrap/dowrap.c

@@ -0,0 +1,48 @@
+#include "dowrap.h"
+#include <stddef.h>
+
+size_t translate_parsed_dowrap(Translated *translated, DArray *parsedDowrap) {
+  set_registers(translated, 1);
+
+  size_t first = translated->bytecode.size;
+
+  if (parsedDowrap->size) {
+    DArray return_jumps;
+    push_instruction_byte(translated, OP_NEW_SCOPE);
+    darray_init(&return_jumps, sizeof(size_t));
+    DArray *old_return_jumps = translated->return_jumps;
+    translated->return_jumps = &return_jumps;
+    for (size_t i = 0; i < parsedDowrap->size; i++) {
+      ParsedValue *parsedValue = darray_get(parsedDowrap, i);
+      translate_parsed(translated, parsedValue);
+    }
+    push_instruction_byte(translated, OP_LOAD_NULL);
+    push_instruction_byte(translated, 0);
+    if (!old_return_jumps) {
+      size_t return_jump_to = push_instruction_byte(translated, OP_POP_SCOPE);
+      for (size_t i = 0; i < return_jumps.size; i++) {
+        size_t *index = darray_get(&return_jumps, i);
+        set_instruction_code(translated, *index, return_jump_to);
+      }
+    } else {
+      push_instruction_byte(translated, OP_POP_SCOPE);
+      push_instruction_byte(translated, OP_JUMP);
+      size_t not_return_jump = push_instruction_code(translated, 0);
+      size_t return_jump_to = push_instruction_byte(translated, OP_POP_SCOPE);
+      push_instruction_byte(translated, OP_JUMP);
+      size_t return_up = push_instruction_code(translated, 0);
+      darray_push(old_return_jumps, &return_up);
+      for (size_t i = 0; i < return_jumps.size; i++) {
+        size_t *index = darray_get(&return_jumps, i);
+        set_instruction_code(translated, *index, return_jump_to);
+      }
+      set_instruction_code(translated, not_return_jump, translated->bytecode.size);
+    }
+    darray_free(&return_jumps, NULL);
+    translated->return_jumps = old_return_jumps;
+  } else {
+    push_instruction_byte(translated, OP_LOAD_NULL);
+    push_instruction_byte(translated, 0);
+  }
+  return first;
+}

src/translator/dowrap/dowrap.h

@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#ifndef TRANSLATE_DO_WRAP_H
+#define TRANSLATE_DO_WRAP_H
+#include "../translator.h"
+
+
+size_t translate_parsed_dowrap(Translated *translated, DArray *parsedDowrap);
+
+#endif // TRANSLATE_DO_WRAP_H

src/translator/translator.c

@@ -8,6 +8,7 @@
 #include "../hash_data/hash_data.h"
 #include "../hashmap/hashmap.h"
 #include "declaration/declaration.h"
+#include "dowrap/dowrap.h"
 #include "function/function.h"
 #include "identifier/identifier.h"
 #include "if/if.h"
@@ -85,7 +86,8 @@ size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
 
 Translated init_translator() {
   Translated translated;
-  translated.registerCount = 0;
+  translated.registerCount = 1;
+  translated.return_jumps=NULL;
   darray_init(&translated.bytecode, sizeof(uint8_t));
   darray_init(&translated.source_locations, sizeof(SourceLocation));
   arena_init(&translated.constants);
@@ -144,6 +146,8 @@ size_t translate_parsed(Translated *translated, ParsedValue *parsedValue) {
                                        (ParsedIdentifier *)parsedValue->data);
   case AST_IF:
     return translate_parsed_if(translated, (DArray *)parsedValue->data);
+  case AST_DOWRAP:
+    return translate_parsed_dowrap(translated, (DArray *)parsedValue->data);
   }
   return 0;
 }

src/translator/translator.h

@@ -26,6 +26,7 @@ typedef struct {
 
 typedef struct {
   uint8_t registerCount;
+  DArray *return_jumps;
   DArray bytecode;
   DArray source_locations;
   ConstantArena constants;