start writing translator

src/main.c

@@ -3,10 +3,12 @@
 #include "lexer/token.h"
 #include "memory.h"
 #include "parser/parser.h"
+#include "translator/translator.h"
 
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>
+#include <unistd.h>
 
 int main(int argc, char *argv[]) {
   if (argc <= 1)
@@ -34,6 +36,21 @@ int main(int argc, char *argv[]) {
   parser(path, &ast, &tokens, false);
   darray_free(&tokens, free_token);
 
+  Translated translated = init_translator();
+
+  translate(&translated, &ast);
+
   darray_free(&ast, free_parsed);
+
+  file = fopen("out.car", "wb");
+  
+  fwrite(&translated.registerCount, sizeof(size_t), 1, file);
+  fwrite(&translated.constants.size, sizeof(size_t), 1, file);
+  fwrite(&translated.bytecode.size, sizeof(size_t), 1, file);
+  fwrite(translated.constants.data, 1, translated.constants.size, file);
+  
+  fclose(file);
+
+  free_translator(&translated);
   return 0;
 }

src/parser/parser.c

@@ -156,7 +156,7 @@ ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
       passed = true;
     }
   }
-
+  
   return output;
 }
 
@@ -188,6 +188,7 @@ void parser(char *file, DArray *parsed, DArray *tokens, bool inline_flag) {
 }
 
 void free_parsed(void *ptr) {
+
   if (!ptr) {
     fprintf(stderr, "panic: freeing NULL pointer\n");
     exit(EXIT_FAILURE);

src/translator/string/string.c

@@ -0,0 +1,8 @@
+#include "../translator.h"
+#include <stddef.h>
+#include <string.h>
+
+void translate_parsed_string(Translated *translated, ParsedValue *parsedValue) {
+  size_t string_pos = arena_push_string(&translated->constants, (char*)parsedValue->data);
+  // set_registers(translated, 1);
+}

src/translator/string/string.h

@@ -0,0 +1,7 @@
+#ifndef STRING_H
+#define STRING_H
+#include "../translator.h"
+
+void translate_parsed_string(Translated * translator, ParsedValue * parsedValue);
+
+#endif

src/translator/translator.c

@@ -1,14 +1,91 @@
 #include "translator.h"
-#include "../dynamic_array/darray.h"
+#include "string/string.h"
+#include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
-#include "../memory.h"
+#include <string.h>
 
-Translated *init_translator() {
-  Translated *translated = checked_malloc(sizeof(Translated));
-  if (!translated)
-    return NULL;
+void arena_init(ConstantArena *arena) {
+  arena->data = checked_malloc(CHUNK_SIZE);
+  arena->capacity = CHUNK_SIZE;
+  arena->size = 0;
+}
 
-  darray_init(&translated->bytecode, sizeof(uint8_t));
+void arena_resize(ConstantArena *arena, size_t new_size) {
+  new_size = ((new_size / CHUNK_SIZE) + 1)*CHUNK_SIZE;
+  if (new_size == arena->capacity)
+    return;
+  arena->data = realloc(arena->data, new_size);
+  if (!arena->data) {
+    fprintf(stderr, "error: failed to resize arena from %zu to %zu\n", new_size, arena->capacity);
+    exit(EXIT_FAILURE);
+  }
+  arena->capacity = new_size;
+}
+
+
+void arena_free(ConstantArena *arena) {
+  free(arena->data);
+  arena->capacity = 0;
+  arena->size = 0;
+}
+
+void * arena_get(ConstantArena *arena, size_t offset) {
+  return arena->data + offset;
+}
+
+
+size_t arena_push_string(ConstantArena *arena, const char *string) {
+  size_t length = strlen(string)+1;
+  arena_resize(arena, arena->size+length);
+  size_t offset = arena->size;
+  strcpy(arena->data + arena->size, string);
+  arena->size += length;
+  return offset;
+}
+
+size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
+  arena_resize(arena, arena->size+length);
+  size_t offset = arena->size;
+  memcpy(arena->data + arena->size, data, length);
+  arena->size += length;
+  return offset;
+}
+
+Translated init_translator() {
+  Translated translated;
+
+  darray_init(&translated.bytecode, sizeof(uint8_t));
+  arena_init(&translated.constants);
   return translated;
+}
+
+size_t push_instruction_code(Translated * translator, size_t code) {
+  size_t offset = translator->bytecode.size;
+  darray_push(&translator->bytecode, &code);
+  return offset;
+}
+
+void set_registers(Translated * translator, size_t count) {
+  if (count>translator->registerCount) translator->registerCount = count;
+}
+
+void translate_parsed(Translated * translator, ParsedValue * parsedValue) {
+  switch (parsedValue->type) {
+    case AST_STRING:
+      translate_parsed_string(translator,parsedValue);
+  }
+}
+
+void translate(Translated * translator, DArray *ast) {
+  for (size_t i = 0; i<ast->size; i++) {
+    ParsedValue * parsedValue = darray_get(ast, i);
+    translate_parsed(translator,parsedValue);
+  }
+}
+
+void free_translator(Translated * translated) {
+  darray_free(&translated->bytecode, NULL);
+  arena_free(&translated->constants);
 }

src/translator/translator.h

@@ -3,12 +3,38 @@
 
 #include "../dynamic_array/darray.h"
 #include <stddef.h>
+#include "../dynamic_array/darray.h"
+#include "../parser/parser.h"
+#include "../memory.h"
 
 typedef enum { OP_INIT_STRING } OperationType;
 
+typedef struct {
+  void *data;
+  size_t capacity;
+  size_t size;
+} ConstantArena;
+
 typedef struct {
   size_t registerCount;
   DArray bytecode;
+  ConstantArena constants;
 } Translated;
 
+void * arena_get(ConstantArena *arena, size_t offset);
+
+size_t arena_push_string(ConstantArena *arena, const char *string);
+
+size_t arena_push(ConstantArena *arena, const void *data, size_t length);
+
+size_t push_instruction_code(Translated * translator, size_t code);
+
+void set_registers(Translated * translator, size_t count);
+
+Translated init_translator();
+
+void translate(Translated * translator, DArray *ast);
+
+void free_translator(Translated * translated);
+
 #endif