add constant buffer compression

src/translator/translator.c

@@ -1,7 +1,7 @@
 #include "translator.h"
-#include "string/string.h"
 #include "declaration/declaration.h"
 #include "number/number.h"
+#include "string/string.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -15,30 +15,37 @@ void arena_init(ConstantArena *arena) {
 }
 
 void arena_resize(ConstantArena *arena, size_t new_size) {
-  size_t new_capacity = ((new_size / CHUNK_SIZE) + 1)*CHUNK_SIZE;
+  size_t new_capacity = ((new_size / CHUNK_SIZE) + 1) * CHUNK_SIZE;
   if (new_capacity == arena->capacity)
     return;
   arena->data = realloc(arena->data, new_capacity);
   if (!arena->data) {
-    fprintf(stderr, "error: failed to resize arena from %zu to %zu\n", new_capacity, arena->capacity);
+    fprintf(stderr, "error: failed to resize arena from %zu to %zu\n",
+            new_capacity, arena->capacity);
     exit(EXIT_FAILURE);
   }
   arena->capacity = new_capacity;
 }
 
-
 void arena_free(ConstantArena *arena) {
   free(arena->data);
   arena->capacity = 0;
   arena->size = 0;
 }
 
-void * arena_get(ConstantArena *arena, size_t offset) {
+void *arena_get(ConstantArena *arena, size_t offset) {
   return arena->data + offset;
 }
 
 size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
-  arena_resize(arena, arena->size+length);
+  if (arena->size >= length) {
+    for (size_t i = 0; i <= (arena->size - length); i++) {
+      if (memcmp(data, arena->data + i, length) == 0) {
+        return i;
+      }
+    }
+  }
+  arena_resize(arena, arena->size + length);
   size_t offset = arena->size;
   memcpy(arena->data + arena->size, data, length);
   arena->size += length;
@@ -53,48 +60,50 @@ Translated init_translator() {
   return translated;
 }
 
-void set_instruction_code(Translated * translator, size_t offset, uint64_t code) {
+void set_instruction_code(Translated *translator, size_t offset,
+                          uint64_t code) {
   code = htole64(code);
-  size_t* ptr = (translator->bytecode.data+offset);
+  size_t *ptr = (translator->bytecode.data + offset);
   *ptr = code;
 }
 
-size_t push_instruction_code(Translated * translator, uint64_t code) {
+size_t push_instruction_code(Translated *translator, uint64_t code) {
   code = htole64(code);
   size_t offset = translator->bytecode.size;
   darray_push(&translator->bytecode, &code);
   return offset;
 }
 
-void set_registers(Translated * translator, size_t count) {
+void set_registers(Translated *translator, size_t count) {
-  if (count>translator->registerCount) translator->registerCount = count;
+  if (count > translator->registerCount)
+    translator->registerCount = count;
 }
 
-size_t translate_parsed(Translated * translated, ParsedValue * parsedValue) {
+size_t translate_parsed(Translated *translated, ParsedValue *parsedValue) {
   switch (parsedValue->type) {
-    case AST_STRING:
+  case AST_STRING:
-      return translate_parsed_string(translated,parsedValue);
+    return translate_parsed_string(translated, parsedValue);
-    case AST_DECLARATION:
+  case AST_DECLARATION:
-      return translate_parsed_declaration(translated,parsedValue);
+    return translate_parsed_declaration(translated, parsedValue);
-    case AST_NUMBER:
+  case AST_NUMBER:
-      return translate_parsed_number(translated,parsedValue);
+    return translate_parsed_number(translated, parsedValue);
-    case AST_NULL:
+  case AST_NULL:
-      set_registers(translated, 1);
+    set_registers(translated, 1);
-      size_t output = push_instruction_code(translated, OP_LOAD_NULL);
+    size_t output = push_instruction_code(translated, OP_LOAD_NULL);
-      push_instruction_code(translated, 0);
+    push_instruction_code(translated, 0);
-      return output;
+    return output;
   }
   return 0;
 }
 
-void translate(Translated * translated, DArray *ast) {
+void translate(Translated *translated, DArray *ast) {
-  for (size_t i = 0; i<ast->size; i++) {
+  for (size_t i = 0; i < ast->size; i++) {
-    ParsedValue * parsedValue = darray_get(ast, i);
+    ParsedValue *parsedValue = darray_get(ast, i);
-    translate_parsed(translated,parsedValue);
+    translate_parsed(translated, parsedValue);
   }
 }
 
-void free_translator(Translated * translated) {
+void free_translator(Translated *translated) {
   darray_free(&translated->bytecode, NULL);
   arena_free(&translated->constants);
 }