.

Makefile

@@ -77,7 +77,7 @@ uninstall:
 # executable files
 #
 
-LIB_SRC=lib/value.o lib/stack.o lib/array.o lib/heap.o lib/vm.o lib/utils.o
+LIB_SRC=lib/value.o lib/stack.o lib/array.o lib/table.o lib/heap.o lib/vm.o lib/utils.o
 
 tyche: CFLAGS += ${RELEASE_CFLAGS}
 tyche: LDFLAGS += ${RELEASE_LDFLAGS}

lib/array.c

@@ -24,12 +24,12 @@ void array_destroy(Array* a)
     free(a);
 }
 
-size_t array_len(Array* a)
+size_t array_len(Array const* a)
 {
     return a->n;
 }
 
-VALUE array_get(Array* a, size_t pos)
+VALUE array_get(Array const* a, size_t pos)
 {
     if (pos >= a->n)
         return create_value_nil();

lib/heap.c

@@ -83,7 +83,7 @@ HEAP_KEY heap_add_string(Heap* h, const char* value)
     return key;
 }
 
-TYC_RESULT heap_get_string(Heap* h, HEAP_KEY key, const char** value)
+TYC_RESULT heap_get_string(Heap const* h, HEAP_KEY key, const char** value)
 {
     khiter_t k = kh_get(HEAP, h->items, key);
     bool is_missing = (k == kh_end(h->items));
@@ -93,7 +93,7 @@ TYC_RESULT heap_get_string(Heap* h, HEAP_KEY key, const char** value)
     return T_OK;
 }
 
-size_t heap_size(Heap* h)
+size_t heap_size(Heap const* h)
 {
     return kh_size(h->items);
 }

lib/priv.h

@@ -52,20 +52,20 @@ Stack*     stack_new(void);
 void       stack_destroy(Stack* s);
 
 TYC_RESULT stack_push(Stack* s, VALUE v);
-TYC_RESULT stack_peek(Stack* s, VALUE* v_out);
+TYC_RESULT stack_peek(Stack const* s, VALUE* v_out);
 TYC_RESULT stack_pop(Stack* s, VALUE* v_out);
 
-size_t     stack_len(Stack* s);
+size_t     stack_len(Stack const* s);
 
-TYC_RESULT stack_at(Stack* s, int32_t key, VALUE* v);
+TYC_RESULT stack_at(Stack const* s, int32_t key, VALUE* v);
 TYC_RESULT stack_set(Stack* s, int32_t key, VALUE v);
 
-size_t     stack_top_fp(Stack* s);
+size_t     stack_top_fp(Stack const* s);
 TYC_RESULT stack_push_fp(Stack* s);
 TYC_RESULT stack_pop_fp(Stack* s);
-size_t     stack_fp_level(Stack* s);
+size_t     stack_fp_level(Stack const* s);
 
-size_t     stack_collectable_array(Stack* s, VALUE** values);
+size_t     stack_collectable_array(Stack const* s, VALUE** values);
 
 //
 // HEAP ARRAY
@@ -76,11 +76,24 @@ typedef struct Array Array;
 Array* array_new(void);
 void   array_destroy(Array* a);
 
-size_t array_len(Array* a);
+size_t array_len(Array const* a);
-VALUE  array_get(Array* a, size_t pos);
+VALUE  array_get(Array const* a, size_t pos);
 void   array_set(Array* a, size_t pos, VALUE v);
 void   array_append(Array* a, VALUE v);
 
+//
+// HEAP TABLE
+//
+
+typedef struct Table Table;
+
+Table* table_new(void);
+void   table_destroy(Table* t);
+
+size_t table_len(Table* t);
+VALUE  table_get(Table const* t, VALUE key);
+void   table_set(Table* t, VALUE key, VALUE value);
+
 //
 // HEAP
 //
@@ -93,9 +106,9 @@ Heap*    heap_new(void);
 void     heap_destroy(Heap* h);
 
 HEAP_KEY   heap_add_string(Heap* h, const char* value);
-TYC_RESULT heap_get_string(Heap* h, HEAP_KEY key, const char** value);
+TYC_RESULT heap_get_string(Heap const* h, HEAP_KEY key, const char** value);
 
-size_t   heap_size(Heap* h);
+size_t   heap_size(Heap const* h);
 
 void     heap_gc(Heap* h, VALUE const* roots, size_t n_roots);
 

lib/stack.c

@@ -51,12 +51,12 @@ TYC_RESULT stack_push(Stack* s, VALUE v)
     return T_OK;
 }
 
-size_t stack_top_fp(Stack* s)
+size_t stack_top_fp(Stack const* s)
 {
     return s->fp[s->fp_n - 1];
 }
 
-TYC_RESULT stack_peek(Stack* s, VALUE* v_out)
+TYC_RESULT stack_peek(Stack const* s, VALUE* v_out)
 {
     if (s->stack_n <= stack_top_fp(s))
         return T_ERR_STACK_UNDERFLOW;
@@ -74,12 +74,12 @@ TYC_RESULT stack_pop(Stack* s, VALUE* v_out)
     return T_OK;
 }
 
-size_t stack_len(Stack* s)
+size_t stack_len(Stack const* s)
 {
     return s->stack_n - stack_top_fp(s);
 }
 
-TYC_RESULT stack_at(Stack* s, int32_t key, VALUE* v)
+TYC_RESULT stack_at(Stack const* s, int32_t key, VALUE* v)
 {
     if (key >= 0) {
         if ((int) stack_top_fp(s) + key >= (int) s->stack_n)
@@ -131,12 +131,12 @@ TYC_RESULT stack_pop_fp(Stack* s)
     return T_OK;
 }
 
-size_t stack_fp_level(Stack* s)
+size_t stack_fp_level(Stack const* s)
 {
     return s->fp_n;
 }
 
-size_t stack_collectable_array(Stack* s, VALUE** values)
+size_t stack_collectable_array(Stack const* s, VALUE** values)
 {
     size_t j = 0;
     *values = xmalloc(stack_len(s) * sizeof(VALUE));

lib/table.c

@@ -0,0 +1,80 @@
+#include "priv.h"
+
+#include "khash.h"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+KHASH_MAP_INIT_INT64(TABLE_INT, VALUE)
+KHASH_MAP_INIT_STR(TABLE_STR, VALUE)
+#pragma GCC diagnostic pop
+
+struct Table {
+    khash_t(TABLE_INT) *tbl_int;
+    khash_t(TABLE_STR) *tbl_str;
+};
+
+Table* table_new(void)
+{
+    Table* t = xcalloc(1, sizeof(Table));
+    t->tbl_int = kh_init(TABLE_INT);
+    t->tbl_str = kh_init(TABLE_STR);
+    return t;
+}
+
+void table_destroy(Table* t)
+{
+    kh_destroy(TABLE_INT, t->tbl_int);
+    kh_destroy(TABLE_STR, t->tbl_str);
+    free(t);
+}
+
+size_t table_len(Table* t)
+{
+    return kh_size(t->tbl_int) + kh_size(t->tbl_str);
+}
+
+static int64_t value_hash(VALUE v)
+{
+    switch (value_type(v)) {
+        case TT_NIL:
+            return 0;
+        case TT_INTEGER:
+            return value_integer(v);
+        case TT_REAL: {
+            uint32_t vv;
+            float f = value_real(v);
+            memcpy(&vv, &f, sizeof(uint32_t));
+            break;
+        }
+        case TT_STRING_CONST:
+            return (int64_t) value_idx(v) | ((int64_t) 1 << 33);
+        case TT_ARRAY:
+            return (int64_t) value_idx(v) | ((int64_t) 1 << 34);
+        case TT_TABLE:
+            return (int64_t) value_idx(v) | ((int64_t) 1 << 35);
+        case TT_FUNCTION:
+            return (int64_t) value_idx(v) | ((int64_t) 1 << 36);
+        case TT_NATIVE_PTR:
+            return (int64_t) value_idx(v) | ((int64_t) 1 << 37);
+        case TT_STRING:
+        default:
+            __builtin_unreachable();
+    }
+
+    return 0;
+}
+
+VALUE table_get(Table const* t, VALUE key)
+{
+}
+
+void table_set(Table* t, VALUE key, VALUE value)
+{
+    /*
+    if (value_type(key) == TT_STRING) {
+        khiter_t k = kh_get(TABLE_STR, t->tbl_str, value_);
+
+    } else {
+    }
+     */
+}