.

lib/code.c

@@ -2,6 +2,7 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #  error Sorry, big endian architectures are not supported at this time.
@@ -15,13 +16,14 @@
 #define CONST_START         0x10
 
 struct Code {
-    uint8_t*  bytecode;
-    size_t    bytecode_sz;
-    uint32_t* const_addr;
-    uint32_t* fn_addr;
+    uint8_t const* bytecode;
+    size_t         bytecode_sz;
+    uint32_t*      const_addr;
+    uint32_t       fn_count;
+    uint32_t*      fn_addr;
 };
 
-Code* code_new()
+Code* code_new(void)
 {
     Code* code = xcalloc(1, sizeof(Code));
     return code;
@@ -29,6 +31,8 @@ Code* code_new()
 
 void code_destroy(Code* code)
 {
+    free(code->const_addr);
+    free(code->fn_addr);
     free(code);
 }
 
@@ -46,6 +50,7 @@ TYC_RESULT code_load_bytecode(Code* code, uint8_t* bytecode, size_t bytecode_sz)
     code->bytecode = bytecode;
     code->bytecode_sz = bytecode_sz;
 
+    /*
     for (size_t i = 0; i < bytecode_sz; ++i) {
         if (i % 16 == 0)
             printf("%04X: ", i);
@@ -53,32 +58,71 @@ TYC_RESULT code_load_bytecode(Code* code, uint8_t* bytecode, size_t bytecode_sz)
         if (i % 16 == 15)
             printf("\n");
     }
+    printf("\n");
+    */
+
+    uint32_t n_consts = code_n_consts(code);
+    code->const_addr = calloc(n_consts, sizeof(uint32_t));
+    uint32_t addr = CONST_START;
+    for (size_t i = 0; i < n_consts; ++i) {
+        code->const_addr[i] = addr;
+        switch (code_const_type(code, i)) {
+            case TC_STRING: {
+                uint32_t sz = (uint32_t) strlen((const char*) &bytecode[code->const_addr[i] + 1]);
+                addr += sz + 2;  // 2 = constant type + NULL terminator
+                break;
+            }
+            case TC_REAL:
+                addr += 5;  // 5 = constant type + float
+                break;
+            case TC_INVALID_TYPE:
+            default:
+                __builtin_unreachable();
+        }
+    }
+
+    addr += 4;  // skip debug start address
+    memcpy(&code->fn_count, &bytecode[addr], sizeof(uint32_t));  // number of functions
+    addr += 4;
+
+    code->fn_addr = calloc(code->fn_count, sizeof(uint32_t));
+    code->fn_addr[0] = addr;
+    for (size_t i = 1; i < code->fn_count; ++i) {
+        uint32_t addr_next;
+        memcpy(&addr_next, &bytecode[addr], sizeof(uint32_t));
+        addr = code->fn_addr[i] = addr_next;
+    }
 
     return T_OK;
 }
 
-size_t code_n_consts(Code const* code)
+uint32_t code_n_consts(Code const* code)
 {
-    uint32_t n_consts = *(uint32_t*) &code->bytecode[N_CONST_ADDR];
+    uint32_t n_consts; memcpy(&n_consts, &code->bytecode[N_CONST_ADDR], sizeof(uint32_t));
     return n_consts;
 }
 
 TYC_CONST_TYPE code_const_type(Code const* code, size_t n)
 {
-    return TC_REAL;  // TODO
+    uint8_t t = code->bytecode[code->const_addr[n]];
+    if (t >= TC_INVALID_TYPE)
+        return TC_INVALID_TYPE;
+    return t;
 }
 
 T_REAL code_const_real(Code const* code, size_t n)
 {
-    return 0.f;  // TODO
+    float f;
+    memcpy(&f, &code->bytecode[code->const_addr[n] + 1], sizeof(float));
+    return f;
 }
 
 const char* code_const_string(Code const* code, size_t n)
 {
-    return "";  // TODO
+    return (const char*) &code->bytecode[code->const_addr[n] + 1];
 }
 
-size_t code_n_functions(Code const* code)
+uint32_t code_n_functions(Code const* code)
 {
-    return 0;  // TODO
+    return code->fn_count;
 }