add declarations to translator

src/translator/declaration/declaration.c

@@ -0,0 +1,29 @@
+#include "../translator.h"
+#include "declaration.h"
+#include "../../parser/declaration/declaration.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+size_t translate_parsed_declaration(Translated *translated,
+                                  ParsedValue *parsedValue) {
+  DArray *delcarations = (DArray *)parsedValue->data;
+  set_registers(translated, 2);
+  size_t first = 0;
+  for (size_t i = 0; i < delcarations->size; i++) {
+    // TODO: add function delclaration
+    ParsedSingleDeclaration*singleDeclaration = darray_get(delcarations, i);
+    size_t temp = translate_parsed(translated, singleDeclaration->from);
+    if (i==0) first = temp;
+    size_t length = strlen(singleDeclaration->name);
+    size_t offset = arena_push(&translated->constants, singleDeclaration->name, length);
+    push_instruction_code(translated, OP_LOAD_CONST);
+    push_instruction_code(translated, 1);
+    push_instruction_code(translated, TYPE_OP_STRING);
+    push_instruction_code(translated,length);
+    push_instruction_code(translated, offset);
+    push_instruction_code(translated, OP_DECLARE);
+    push_instruction_code(translated, 0);
+    push_instruction_code(translated, 1);
+  }
+  return first;
+}

src/translator/declaration/declaration.h

@@ -0,0 +1,10 @@
+#ifndef BYTECODE_DECLARATION_H
+#define BYTECODE_DECLARATION_H
+#include "../translator.h"
+
+size_t translate_parsed_string(Translated *translated, ParsedValue *parsedValue);
+
+size_t translate_parsed_declaration(Translated *translated,
+                                  ParsedValue *parsedValue);
+
+#endif

src/translator/string/string.c

@@ -1,18 +1,20 @@
 #include "../translator.h"
 #include "../../parser/string/string.h"
+#include "string.h"
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 
-void translate_parsed_string(Translated *translated, ParsedValue *parsedValue) {
+size_t translate_parsed_string(Translated *translated, ParsedValue *parsedValue) {
   ParsedString *parsedString = (ParsedString*)parsedValue->data;
   size_t string_pos = arena_push(&translated->constants, parsedString->string, parsedString->length);
   set_registers(translated, 1);
-  push_instruction_code(translated, OP_LOAD_CONST);
+  size_t start = push_instruction_code(translated, OP_LOAD_CONST);
   push_instruction_code(translated, 0);
-  push_instruction_code(translated, OP_TYPE_STRING);
+  push_instruction_code(translated, TYPE_OP_STRING);
   push_instruction_code(translated,parsedString->length);
   push_instruction_code(translated, string_pos);
   fwrite(parsedString->string, 1, parsedString->length, stdout);
   putchar('\n');
+  return start;
 }

src/translator/string/string.h

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

src/translator/translator.c

@@ -1,5 +1,6 @@
 #include "translator.h"
 #include "string/string.h"
+#include "declaration/declaration.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -51,6 +52,12 @@ Translated init_translator() {
   return translated;
 }
 
+void set_instruction_code(Translated * translator, size_t offset, uint64_t code) {
+  code = htole64(code);
+  size_t* ptr = (translator->bytecode.data+offset);
+  *ptr = code;
+}
+
 size_t push_instruction_code(Translated * translator, uint64_t code) {
   code = htole64(code);
   size_t offset = translator->bytecode.size;
@@ -62,11 +69,14 @@ void set_registers(Translated * translator, size_t count) {
   if (count>translator->registerCount) translator->registerCount = count;
 }
 
-void translate_parsed(Translated * translator, ParsedValue * parsedValue) {
+size_t translate_parsed(Translated * translator, ParsedValue * parsedValue) {
   switch (parsedValue->type) {
     case AST_STRING:
-      translate_parsed_string(translator,parsedValue);
+      return translate_parsed_string(translator,parsedValue);
+    case AST_DECLARATION:
+      return translate_parsed_declaration(translator,parsedValue);
   }
+  return 0;
 }
 
 void translate(Translated * translator, DArray *ast) {

src/translator/translator.h

@@ -2,14 +2,13 @@
 #define TRANSLATOR_H
 
 #include "../dynamic_array/darray.h"
+#include "../memory.h"
+#include "../parser/parser.h"
 #include <stddef.h>
 #include <stdint.h>
-#include "../dynamic_array/darray.h"
-#include "../parser/parser.h"
-#include "../memory.h"
 
-typedef enum { OP_LOAD_CONST=255 } OperationType;
-typedef enum { OP_TYPE_STRING=255 } types;
+typedef enum { OP_LOAD_CONST = 255, OP_DECLARE, OP_LOAD_NULL, OP_JUMP } OperationType;
+typedef enum { TYPE_OP_STRING = 255 } types;
 
 typedef struct {
   void *data;
@@ -23,18 +22,22 @@ typedef struct {
   ConstantArena constants;
 } Translated;
 
-void * arena_get(ConstantArena *arena, size_t offset);
+void *arena_get(ConstantArena *arena, size_t offset);
 
 size_t arena_push(ConstantArena *arena, const void *data, size_t length);
 
-size_t push_instruction_code(Translated * translator, uint64_t code);
+void set_instruction_code(Translated * translator, size_t offset, uint64_t code);
 
-void set_registers(Translated * translator, size_t count);
+size_t push_instruction_code(Translated *translator, uint64_t code);
+
+void set_registers(Translated *translator, size_t count);
 
 Translated init_translator();
 
-void translate(Translated * translator, DArray *ast);
+size_t translate_parsed(Translated * translator, ParsedValue * parsedValue);
 
-void free_translator(Translated * translated);
+void translate(Translated *translator, DArray *ast);
+
+void free_translator(Translated *translated);
 
 #endif