initial

qirt.c

@@ -0,0 +1,4157 @@
+#include "qirt.h"
+
+#include <stdio.h>
+
+#define GC_THREADS
+#include <gc.h>
+#include <pthread.h>
+
+static bool __debug_enabled = false;
+static pthread_t __main_tid;
+
+void *qi_malloc(qi_size_t size) {
+  void *ptr = GC_MALLOC(size);
+
+  if (!ptr)
+    abort();
+
+  return ptr;
+}
+
+void *qi_malloc_atomic(qi_size_t size) {
+  void *ptr = GC_MALLOC_ATOMIC(size);
+
+  if (!ptr)
+    abort();
+
+  return ptr;
+}
+
+void *qi_realloc(void *old_ptr, qi_size_t size) {
+  void *ptr = GC_realloc(old_ptr, size);
+
+  if (!ptr)
+    abort();
+
+  return ptr;
+}
+
+void *qi_calloc(qi_size_t count, qi_size_t size) {
+  void *ptr = GC_MALLOC(count * size);
+
+  if (!ptr)
+    abort();
+
+  return ptr;
+}
+
+char *qi_strdup(const char *s) {
+  char *ptr = GC_strdup(s);
+
+  if (!ptr)
+    abort();
+
+  return ptr;
+}
+
+void qi_free(void *ptr) { GC_FREE(ptr); }
+
+qi_list_t *qi_list_make(void) {
+  qi_list_t *list = qi_malloc(sizeof(qi_list_t));
+  list->value = NULL;
+  list->next = NULL;
+
+  return list;
+}
+
+qi_size_t qi_list_length(qi_list_t *list) {
+  qi_size_t length = 0;
+
+  if (qi_list_empty(list))
+    return length;
+
+  do {
+    list = list->next, length++;
+  } while (list);
+
+  return length;
+}
+
+void *qi_list_index(qi_list_t *list, qi_ssize_t index) {
+  qi_size_t length;
+
+  if (qi_list_empty(list))
+    return NULL;
+
+  if (index == 0)
+    return list->value;
+
+  length = qi_list_length(list);
+
+  if (index < 0)
+    index += ((qi_ssize_t)length);
+
+  if (index < 0 || index >= length)
+    return NULL;
+
+  for (qi_size_t i = 0; i < ((qi_size_t)index); i++)
+    list = list->next;
+
+  return list->value;
+}
+
+qi_list_t *qi_list_push(qi_list_t *list, void *value) {
+  qi_list_t *head = list;
+
+  if (qi_list_empty(list)) {
+    list->value = value;
+
+    return head;
+  }
+
+  while (list->next)
+    list = list->next;
+
+  list = list->next = qi_list_make();
+  list->value = value;
+
+  return head;
+}
+
+qi_list_t *qi_list_insert(qi_list_t **list, qi_ssize_t index, void *value) {
+  qi_list_t *head = *list;
+
+  if (index == -1)
+    return qi_list_push(head, value);
+
+  qi_size_t length = qi_list_length(head);
+
+  if (index < 0)
+    index += (qi_ssize_t)length;
+
+  if (index < 0 || index > length)
+    return NULL;
+
+  if (index == -1)
+    return qi_list_push(head, value);
+
+  if (index == 0) {
+    if (qi_list_empty(head))
+      return qi_list_push(head, value);
+
+    qi_list_t *temp = qi_list_make();
+    temp->value = value;
+    temp->next = head;
+
+    *list = temp;
+
+    return temp;
+  }
+
+  qi_list_t *temp0 = *list;
+  for (qi_size_t i = 0; i < ((qi_size_t)index) - 1; i++)
+    temp0 = temp0->next;
+
+  qi_list_t *temp = temp0->next;
+
+  temp0->next = qi_list_make();
+  temp0->next->value = value;
+  temp0->next->next = temp;
+
+  return head;
+}
+
+qi_list_t *qi_list_delete(qi_list_t **list, qi_ssize_t index) {
+  qi_list_t *head = *list;
+
+  if (qi_list_empty(head))
+    return NULL;
+
+  qi_size_t length = qi_list_length(head);
+
+  if (index < 0)
+    index += (qi_ssize_t)length;
+
+  if (index < 0 || index >= length)
+    return NULL;
+
+  if (index == 0) {
+    head->value = NULL;
+
+    if (!head->next)
+      return head;
+
+    *list = head->next;
+
+    return *list;
+  }
+
+  qi_list_t *temp0 = *list;
+  for (qi_size_t i = 0; i < ((qi_size_t)index) - 1; i++)
+    temp0 = temp0->next;
+
+  qi_list_t *temp = temp0->next;
+  temp->value = NULL;
+  temp0->next = temp->next;
+
+  return head;
+}
+
+void *qi_list_set(qi_list_t *list, qi_ssize_t index, void *value) {
+  qi_size_t length = qi_list_length(list);
+
+  if (index < 0)
+    index += ((qi_ssize_t)length);
+
+  if (index == ((qi_ssize_t)length)) {
+    qi_list_push(list, value);
+
+    return value;
+  }
+
+  if (index < 0 || index >= length)
+    return NULL;
+
+  for (qi_size_t i = 0; i < ((qi_size_t)index); i++)
+    list = list->next;
+
+  list->value = value;
+
+  return value;
+}
+
+void *qi_list_pop(qi_list_t *list) {
+  if (qi_list_empty(list))
+    return NULL;
+
+  if (!list->next) {
+    void *value = list->value;
+    list->value = NULL;
+
+    return value;
+  }
+
+  qi_list_t *head = list;
+
+  while (list) {
+    if (!list->next) {
+      void *value = list->value;
+      list->value = NULL;
+      head->next = NULL;
+
+      return value;
+    }
+
+    head = list;
+    list = list->next;
+  }
+
+  return NULL;
+}
+
+bool qi_list_contains(qi_list_t *list, void *value) {
+  if (qi_list_empty(list))
+    return false;
+
+  while (list) {
+    if (list->value == value)
+      return true;
+
+    list = list->next;
+  }
+
+  return false;
+}
+
+qi_list_t *qi_list_copy(qi_list_t *list) {
+  qi_list_t *newlist = qi_list_make();
+
+  if (qi_list_empty(list))
+    return newlist;
+
+  qi_list_t *head = list;
+  while (list)
+    qi_list_push(newlist, list->value), list = list->next;
+
+  return newlist;
+}
+
+qi_table_t *qi_table_make(void) {
+  qi_table_t *table = qi_malloc(sizeof(qi_table_t));
+  table->used = 0;
+
+  table->capacity = QI_TABLE_MIN_SIZE;
+  table->entries = qi_calloc(table->capacity, sizeof(qi_table_entry_t));
+
+  return table;
+}
+
+static uint64_t MM86128(void *key, const int len, uint32_t seed) {
+#define ROTL32(x, r) ((x << r) | (x >> (32 - r)))
+#define FMIX32(h)                                                              \
+  h ^= h >> 16;                                                                \
+  h *= 0x85ebca6b;                                                             \
+  h ^= h >> 13;                                                                \
+  h *= 0xc2b2ae35;                                                             \
+  h ^= h >> 16;
+  const uint8_t *data = (const uint8_t *)key;
+  const int nblocks = len / 16;
+  uint32_t h1 = seed;
+  uint32_t h2 = seed;
+  uint32_t h3 = seed;
+  uint32_t h4 = seed;
+  uint32_t c1 = 0x239b961b;
+  uint32_t c2 = 0xab0e9789;
+  uint32_t c3 = 0x38b34ae5;
+  uint32_t c4 = 0xa1e38b93;
+  const uint32_t *blocks = (const uint32_t *)(data + nblocks * 16);
+  for (int i = -nblocks; i; i++) {
+    uint32_t k1 = blocks[i * 4 + 0];
+    uint32_t k2 = blocks[i * 4 + 1];
+    uint32_t k3 = blocks[i * 4 + 2];
+    uint32_t k4 = blocks[i * 4 + 3];
+    k1 *= c1;
+    k1 = ROTL32(k1, 15);
+    k1 *= c2;
+    h1 ^= k1;
+    h1 = ROTL32(h1, 19);
+    h1 += h2;
+    h1 = h1 * 5 + 0x561ccd1b;
+    k2 *= c2;
+    k2 = ROTL32(k2, 16);
+    k2 *= c3;
+    h2 ^= k2;
+    h2 = ROTL32(h2, 17);
+    h2 += h3;
+    h2 = h2 * 5 + 0x0bcaa747;
+    k3 *= c3;
+    k3 = ROTL32(k3, 17);
+    k3 *= c4;
+    h3 ^= k3;
+    h3 = ROTL32(h3, 15);
+    h3 += h4;
+    h3 = h3 * 5 + 0x96cd1c35;
+    k4 *= c4;
+    k4 = ROTL32(k4, 18);
+    k4 *= c1;
+    h4 ^= k4;
+    h4 = ROTL32(h4, 13);
+    h4 += h1;
+    h4 = h4 * 5 + 0x32ac3b17;
+  }
+  const uint8_t *tail = (const uint8_t *)(data + nblocks * 16);
+  uint32_t k1 = 0;
+  uint32_t k2 = 0;
+  uint32_t k3 = 0;
+  uint32_t k4 = 0;
+  switch (len & 15) {
+  case 15:
+    k4 ^= tail[14] << 16;
+  case 14:
+    k4 ^= tail[13] << 8;
+  case 13:
+    k4 ^= tail[12] << 0;
+    k4 *= c4;
+    k4 = ROTL32(k4, 18);
+    k4 *= c1;
+    h4 ^= k4;
+  case 12:
+    k3 ^= tail[11] << 24;
+  case 11:
+    k3 ^= tail[10] << 16;
+  case 10:
+    k3 ^= tail[9] << 8;
+  case 9:
+    k3 ^= tail[8] << 0;
+    k3 *= c3;
+    k3 = ROTL32(k3, 17);
+    k3 *= c4;
+    h3 ^= k3;
+  case 8:
+    k2 ^= tail[7] << 24;
+  case 7:
+    k2 ^= tail[6] << 16;
+  case 6:
+    k2 ^= tail[5] << 8;
+  case 5:
+    k2 ^= tail[4] << 0;
+    k2 *= c2;
+    k2 = ROTL32(k2, 16);
+    k2 *= c3;
+    h2 ^= k2;
+  case 4:
+    k1 ^= tail[3] << 24;
+  case 3:
+    k1 ^= tail[2] << 16;
+  case 2:
+    k1 ^= tail[1] << 8;
+  case 1:
+    k1 ^= tail[0] << 0;
+    k1 *= c1;
+    k1 = ROTL32(k1, 15);
+    k1 *= c2;
+    h1 ^= k1;
+  }
+  h1 ^= len;
+  h2 ^= len;
+  h3 ^= len;
+  h4 ^= len;
+  h1 += h2;
+  h1 += h3;
+  h1 += h4;
+  h2 += h1;
+  h3 += h1;
+  h4 += h1;
+  FMIX32(h1);
+  FMIX32(h2);
+  FMIX32(h3);
+  FMIX32(h4);
+  h1 += h2;
+  h1 += h3;
+  h1 += h4;
+  h2 += h1;
+  h3 += h1;
+  h4 += h1;
+  return (((uint64_t)h2) << 32) | h1;
+}
+
+static uint32_t QI_HASH_SEED = 0;
+
+void *qi_table_get(qi_table_t *table, char *key) {
+  if (qi_table_empty(table))
+    return NULL;
+
+  uint64_t hash = MM86128(key, strlen(key), QI_HASH_SEED);
+  qi_size_t index = hash % table->capacity;
+
+  qi_size_t i = index;
+
+  while (table->entries[i].key) {
+    if (!table->entries[i].is_deleted &&
+        strcmp(table->entries[i].key, key) == 0)
+      return table->entries[i].value;
+
+    i++;
+
+    if (i >= table->capacity)
+      i = 0;
+
+    if (i == index)
+      break;
+  }
+
+  return NULL;
+}
+
+bool qi_table_has(qi_table_t *table, char *key) {
+  if (qi_table_empty(table))
+    return false;
+
+  uint64_t hash = MM86128(key, strlen(key), QI_HASH_SEED);
+  qi_size_t index = hash % table->capacity;
+
+  qi_size_t i = index;
+
+  while (table->entries[i].key) {
+    if (!table->entries[i].is_deleted &&
+        strcmp(table->entries[i].key, key) == 0)
+      return true;
+
+    i++;
+
+    if (i >= table->capacity)
+      i = 0;
+
+    if (i == index)
+      break;
+  }
+
+  return false;
+}
+
+static void qi_table_entry_set(qi_table_entry_t *entries, char *key,
+                               void *value, qi_size_t capacity,
+                               qi_size_t *used) {
+  uint64_t hash = MM86128(key, strlen(key), QI_HASH_SEED);
+  qi_size_t index = hash % capacity;
+
+  qi_size_t i = index;
+
+  while (entries[i].key) {
+    if (strcmp(entries[i].key, key) == 0) {
+      entries[i].value = value;
+
+      if (entries[i].is_deleted) {
+        if (used)
+          (*used)++;
+
+        entries[i].is_deleted = false;
+      }
+
+      return;
+    } else if (entries[i].is_deleted)
+      break;
+
+    i++;
+
+    if (i >= capacity)
+      i = 0;
+
+    if (i == index)
+      break;
+  }
+
+  if (used)
+    (*used)++;
+
+  entries[i].key = key;
+  entries[i].value = value;
+  entries[i].is_deleted = false;
+}
+
+qi_table_t *qi_table_set(qi_table_t *table, char *key, void *value) {
+  if (table->used >= table->capacity) {
+    qi_size_t capacity = table->capacity + QI_TABLE_MIN_SIZE;
+    qi_table_entry_t *entries = qi_calloc(capacity, sizeof(qi_table_entry_t));
+
+    for (qi_size_t i = 0; i < table->capacity; i++) {
+      qi_table_entry_t entry = table->entries[i];
+
+      if (entry.key && !entry.is_deleted)
+        qi_table_entry_set(entries, entry.key, entry.value, capacity, NULL);
+    }
+
+    qi_free(table->entries);
+
+    table->entries = entries;
+    table->capacity = capacity;
+  }
+
+  qi_table_entry_set(table->entries, key, value, table->capacity, &table->used);
+
+  return table;
+}
+
+qi_list_t *qi_table_keys(qi_table_t *table) {
+  qi_list_t *list = qi_list_make();
+
+  qi_table_iterate(table, { qi_list_push(list, entry.key); });
+
+  return list;
+}
+
+bool qi_table_delete(qi_table_t *table, char *key) {
+  uint64_t hash = MM86128(key, strlen(key), QI_HASH_SEED);
+  qi_size_t index = hash % table->capacity;
+
+  qi_size_t i = index;
+
+  while (table->entries[i].key) {
+    if (!table->entries[i].is_deleted &&
+        strcmp(table->entries[i].key, key) == 0) {
+      table->entries[i].value = NULL;
+      table->entries[i].is_deleted = true;
+
+      table->used--;
+
+      if (table->capacity > QI_TABLE_MIN_SIZE &&
+          table->used <= table->capacity - QI_TABLE_MIN_SIZE) {
+        qi_size_t capacity = table->capacity - QI_TABLE_MIN_SIZE;
+        qi_table_entry_t *entries =
+            qi_calloc(capacity, sizeof(qi_table_entry_t));
+
+        for (qi_size_t i = 0; i < table->capacity; i++) {
+          qi_table_entry_t entry = table->entries[i];
+
+          if (entry.key && !entry.is_deleted)
+            qi_table_entry_set(entries, entry.key, entry.value, capacity, NULL);
+        }
+
+        qi_free(table->entries);
+
+        table->entries = entries;
+        table->capacity = capacity;
+      }
+
+      return true;
+    }
+
+    i++;
+
+    if (i >= table->capacity)
+      i = 0;
+
+    if (i == index)
+      break;
+  }
+
+  return false;
+}
+
+qi_table_t *qi_table_copy(qi_table_t *table) {
+  qi_table_t *newtable = qi_table_make();
+  qi_table_iterate(table, { qi_table_set(newtable, entry.key, entry.value); });
+
+  return newtable;
+}
+
+static qi_buffer_t *qi_buffer_make(void) {
+  qi_buffer_t *buf = qi_malloc(sizeof(qi_buffer_t));
+
+  buf->str = NULL;
+  buf->used = buf->allocated = 0;
+
+  return buf;
+}
+
+static void qi_buffer_append(qi_buffer_t *buf, char c) {
+  buf->used++;
+
+  if (buf->used > buf->allocated) {
+    buf->allocated++;
+
+    buf->str = qi_realloc(buf->str, sizeof(char) * buf->allocated);
+  }
+
+  buf->str[buf->used - 1] = c;
+}
+
+static void qi_buffer_append_str(qi_buffer_t *buf, char *s) {
+  while (*s)
+    qi_buffer_append(buf, *s++);
+}
+
+static char *qi_buffer_read(qi_buffer_t *buf) {
+  if (buf->used == 0 || buf->str[buf->used - 1])
+    qi_buffer_append(buf, 0);
+
+  return buf->str;
+}
+
+void qi_add_defer(qi_state_t *state, qi_ssize_t index, qi_defer_t defer) {
+  if (qi_list_empty(state->scopes))
+    return;
+
+  qi_scope_t *scope = qi_list_last(state->scopes);
+  qi_list_insert(&scope->defers, index, (void *)defer);
+}
+
+qi_defer_t qi_pop_defer(qi_state_t *state, qi_ssize_t index) {
+  if (qi_list_empty(state->scopes))
+    return NULL;
+
+  qi_scope_t *scope = qi_list_last(state->scopes);
+  qi_defer_t defer = qi_list_index(scope->defers, index);
+
+  if (defer)
+    qi_list_delete(&scope->defers, index);
+
+  return defer;
+}
+
+void qi_new_scope(qi_state_t *state) {
+  qi_scope_t *scope = qi_malloc(sizeof(qi_scope_t));
+  scope->scope = qi_table_make();
+  scope->defers = qi_list_make();
+
+  scope->is_barrier = false;
+
+  scope->lock = qi_lock_create();
+
+  qi_list_push(state->scopes, scope);
+}
+
+bool qi_old_scope(qi_state_t *state) {
+  qi_scope_t *scope;
+  qi_list_t *defers;
+
+  if (qi_list_empty(state->scopes))
+    return false;
+
+  scope = qi_list_last(state->scopes);
+  if (scope->is_barrier)
+    return false;
+
+  defers = scope->defers;
+
+  if (qi_list_empty(defers)) {
+    qi_list_pop(state->scopes);
+
+    return true;
+  }
+
+  scope->defers = qi_list_make();
+
+  while (defers) {
+    qi_defer_t defer = (qi_defer_t)(defers->value);
+
+    defer(state);
+
+    defers = defers->next;
+  }
+
+  qi_list_pop(state->scopes);
+
+  return true;
+}
+
+qi_value_t *qi_call_meta(qi_state_t *state, bool *fail_flag, qi_value_t *value,
+                         char *name, qi_size_t count, ...);
+
+void qi_value_finalizer(GC_PTR _value, GC_PTR _state) {
+  qi_state_t *state = (qi_state_t *)_state;
+  qi_value_t *value = (qi_value_t *)_value;
+
+  if (value->type == QI_TABLE && value->value.table.metatable)
+    qi_call_meta(state, NULL, value, "__fin", 1, value);
+  else if (value->type == QI_FILE && value->value.file.is_open &&
+           value->value.file.fd != stdin && value->value.file.fd != stderr &&
+           value->value.file.fd != stdout) {
+    fclose(value->value.file.fd);
+
+    value->value.file.is_open = false;
+  }
+
+  if (value->type == QI_TABLE || value->type == QI_LIST) {
+    if (value->lock)
+      qi_lock_destroy(value->lock);
+
+    value->lock = NULL;
+  }
+}
+
+qi_value_t *qi_make_value(qi_type_t type) {
+  qi_value_t *value;
+
+  if (type == QI_NUMBER || type == QI_BOOLEAN || type == QI_FILE)
+    value = qi_malloc_atomic(sizeof(qi_value_t));
+  else
+    value = qi_malloc(sizeof(qi_value_t));
+
+  value->type = type;
+  value->lock = NULL;
+
+  return value;
+}
+
+qi_value_t *qi_make_number(qi_state_t *state, double number) {
+  qi_value_t *value;
+
+  if (isnan(number))
+    return state->nan;
+  else if (number == INFINITY)
+    return state->infinity;
+  else if (number == -INFINITY)
+    return state->ninfinity;
+  else if (number >= 0 && number < 256 && number == (double)((qi_size_t)number))
+    return state->numbers[(qi_size_t)number];
+  else if (number < 0 && number >= -8 &&
+           fabs(number) == (double)((qi_size_t)fabs(number)))
+    return state->nnumbers[((qi_size_t)fabs(number)) - 1];
+
+  value = qi_make_value(QI_NUMBER);
+  value->value.number = number;
+
+  return value;
+}
+
+qi_value_t *qi_make_string(qi_state_t *state, char *string) {
+  qi_value_t *value;
+
+  qi_size_t len = strlen(string);
+
+  if (len == 0)
+    return state->empty_string;
+  else if (len <= 24) {
+    qi_lock_acquire(state->intern_strs_lock);
+
+    value = qi_table_get(state->intern_strs, string);
+
+    qi_lock_release(state->intern_strs_lock);
+
+    if (value)
+      return value;
+  }
+
+  value = qi_make_value(QI_STRING);
+  value->value.string = string;
+
+  if (len <= 24) {
+    qi_lock_acquire(state->intern_strs_lock);
+
+    qi_table_set(state->intern_strs, string, value);
+
+    qi_lock_release(state->intern_strs_lock);
+  }
+
+  return value;
+}
+
+qi_value_t *qi_make_string_copy(qi_state_t *state, char *string) {
+  return qi_make_string(state, qi_strdup(string));
+}
+
+qi_value_t *qi_make_bytes(qi_state_t *state, unsigned char *bytes,
+                          qi_size_t size) {
+  qi_value_t *value;
+  if (size == 0)
+    return state->empty_bytes;
+
+  value = qi_make_value(QI_BYTES);
+  value->value.bytes = qi_malloc(sizeof(qi_bytes_t));
+  value->value.bytes->data = bytes;
+  value->value.bytes->size = size;
+
+  return value;
+}
+
+qi_value_t *qi_make_char(qi_state_t *state, char c) {
+  qi_value_t *value = qi_make_value(QI_STRING);
+
+  char string[2];
+  string[0] = c;
+  string[1] = 0;
+
+  value->value.string = qi_strdup(string);
+
+  return value;
+}
+
+qi_value_t *qi_make_file(qi_state_t *state, FILE *file, char *mode) {
+  qi_value_t *value = qi_make_value(QI_FILE);
+  value->value.file.fd = file;
+  strncpy(value->value.file.mode, mode, 4);
+  value->value.file.is_open = true;
+
+  GC_register_finalizer(value, qi_value_finalizer, (void *)state, NULL, NULL);
+
+  return value;
+}
+
+qi_value_t *qi_make_list(qi_state_t *state, qi_list_t *list) {
+  qi_value_t *value = qi_make_value(QI_LIST);
+  value->lock = qi_lock_create();
+  value->value.list = list;
+
+  GC_register_finalizer(value, qi_value_finalizer, (void *)state, NULL, NULL);
+
+  return value;
+}
+
+qi_value_t *qi_make_tuple(qi_state_t *state, qi_list_t *tuple) {
+  qi_value_t *value;
+
+  if (!tuple || qi_list_empty(tuple))
+    return state->empty_tuple;
+
+  value = qi_make_value(QI_TUPLE);
+  value->value.list = tuple;
+
+  return value;
+}
+
+qi_value_t *qi_make_table(qi_state_t *state, qi_table_t *table) {
+  qi_value_t *value = qi_make_value(QI_TABLE);
+  value->lock = qi_lock_create();
+  value->value.table.table = table;
+  value->value.table.metatable = state->nil;
+
+  GC_register_finalizer(value, qi_value_finalizer, (void *)state, NULL, NULL);
+
+  return value;
+}
+
+qi_value_t *qi_make_function(qi_state_t *state, char *name, qi_size_t pargc,
+                             qi_handle_t handle, qi_table_t *captured) {
+  qi_value_t *value = qi_make_value(QI_FUNCTION);
+  value->value.function.name = name;
+  value->value.function.pargc = pargc;
+  value->value.function.handle = handle;
+  value->value.function.captured = captured;
+
+  value->value.function.is_builtin = false;
+  value->value.function.is_pm = false;
+
+  return value;
+}
+
+qi_value_t *qi_make_builtin_function(qi_state_t *state, char *name,
+                                     qi_size_t pargc, qi_handle_t handle) {
+  qi_value_t *value = qi_make_value(QI_FUNCTION);
+  value->value.function.name = name;
+  value->value.function.pargc = pargc;
+  value->value.function.handle = handle;
+  value->value.function.captured = NULL;
+
+  value->value.function.is_builtin = true;
+  value->value.function.is_pm = false;
+
+  return value;
+}
+
+qi_value_t *qi_make_data(qi_state_t *state, unsigned int tag, void *data) {
+  qi_value_t *value = qi_make_value(QI_DATA);
+  value->value.data.tag = tag;
+  value->value.data.data = data;
+
+  return value;
+}
+
+static qi_value_t *qi_get_pseudomethod(qi_state_t *state, qi_value_t *value,
+                                       char *name) {
+  qi_lock_acquire(state->pseudomethods_lock);
+
+  char pseudomethod_name[64];
+  snprintf(pseudomethod_name, sizeof(pseudomethod_name), "%s.%s",
+           qi_repr_type(value->type), name);
+
+  qi_value_t *meta = qi_table_get(state->pseudomethods, pseudomethod_name);
+
+  qi_lock_release(state->pseudomethods_lock);
+
+  return meta;
+}
+
+qi_value_t *qi_add_pseudomethod(qi_state_t *state, char *name, qi_size_t pargc,
+                                qi_handle_t handle) {
+  qi_value_t *method = qi_make_function(state, name, pargc + 1, handle, NULL);
+  method->value.function.is_pm = true;
+
+  qi_lock_acquire(state->pseudomethods_lock);
+
+  qi_table_set(state->pseudomethods, name, method);
+
+  qi_lock_release(state->pseudomethods_lock);
+
+  return method;
+}
+
+qi_value_t *qi_get_method(qi_state_t *state, qi_value_t *value, char *name) {
+  if (value->type != QI_TABLE)
+    return qi_get_pseudomethod(state, value, name);
+
+  qi_value_t *method = NULL;
+
+  LOCKED(value, {
+    if (qi_has_metatable(value))
+      method = qi_table_get(qi_get_metatable(value), name);
+  });
+
+  if (!method)
+    return qi_get_pseudomethod(state, value, name);
+
+  return method;
+}
+
+qi_value_t *qi_call_meta(qi_state_t *state, bool *fail_flag, qi_value_t *value,
+                         char *name, qi_size_t count, ...) {
+  qi_value_t *meta = qi_get_method(state, value, name);
+  if (!meta)
+    return NULL;
+
+  qi_list_t *args = qi_list_make();
+
+  va_list vargs;
+  va_start(vargs, count);
+
+  for (qi_size_t i = 0; i < count; i++)
+    qi_list_push(args, va_arg(vargs, qi_value_t *));
+
+  va_end(vargs);
+
+  qi_value_t *ret = NULL;
+
+  if (fail_flag) {
+    qi_try(
+        state, { ret = qi_call(state, meta, args); },
+        {
+          if (trap->value == state->nil) {
+            *fail_flag = true;
+
+            ret = NULL;
+          } else
+            qi_throw(state, trap->value);
+        },
+        NULL);
+  } else
+    ret = qi_call(state, meta, args);
+
+  return ret;
+}
+
+char *_qi_type(qi_state_t *state, qi_value_t *value) {
+  qi_value_t *meta;
+  if ((meta = qi_call_meta(state, NULL, value, "__type", 1, value))) {
+    if (meta->type != QI_STRING)
+      qi_throw_format(state, "__type returned non-string value (%s)",
+                      _qi_type(state, meta));
+
+    char *name = meta->value.string;
+    for (int i = 0; i < sizeof(qi_type_names); i++)
+      if (strcmp(qi_type_names[i], name) == 0)
+        qi_throw_format(state,
+                        "__type returned type name should not match builtin "
+                        "type names (got '%s')",
+                        name);
+
+    return name;
+  }
+
+  if (value->type == QI_TABLE) {
+    qi_lock_acquire(value->lock);
+
+    if (qi_has_metatable(value)) {
+      qi_lock_release(value->lock);
+
+      return (char *)qi_repr_type(QI_OBJECT);
+    }
+
+    qi_lock_release(value->lock);
+  }
+
+  return (char *)qi_repr_type(value->type);
+}
+
+char *_qi_repr(qi_state_t *state, qi_list_t *tempstack, qi_value_t *value,
+               bool quote) {
+  char string[128];
+  qi_buffer_t *buffer;
+  qi_list_t *temp;
+  bool flag;
+
+  qi_value_t *meta;
+  if ((meta = qi_call_meta(state, NULL, value, quote ? "__repr" : "__str", 1,
+                           value))) {
+    if (meta->type != QI_STRING)
+      qi_throw_format(state, "%s returned non-string value (%s)",
+                      quote ? "__repr" : "__str", _qi_type(state, meta));
+
+    return meta->value.string;
+  } else if (quote &&
+             (meta = qi_call_meta(state, NULL, value, "__str", 1, value))) {
+    if (meta->type != QI_STRING)
+      qi_throw_format(state, "__str returned non-string value (%s)",
+                      _qi_type(state, meta));
+
+    return meta->value.string;
+  }
+
+  if (value == state->nil)
+    return qi_strdup("nil");
+  else if (value == state->_true)
+    return qi_strdup("true");
+  else if (value == state->_false)
+    return qi_strdup("false");
+  else if (value == state->zero)
+    return qi_strdup("0");
+  else if (value == state->one)
+    return qi_strdup("1");
+  else if (value == state->nan)
+    return qi_strdup("NAN");
+  else if (value == state->infinity)
+    return qi_strdup("INFINITY");
+  else if (value == state->ninfinity)
+    return qi_strdup("-INFINITY");
+  else if (value == state->empty_string) {
+    if (quote)
+      return qi_strdup("\"\"");
+
+    return qi_strdup("");
+  } else if (value == state->empty_bytes)
+    return qi_strdup("bytes([])");
+  else if (value == state->empty_tuple)
+    return qi_strdup("()");
+
+  switch (value->type) {
+  case QI_NULL:
+    return qi_strdup("nil");
+
+  case QI_BOOLEAN:
+    return qi_strdup(value->value.boolean ? "True" : "False");
+
+  case QI_NUMBER:
+    if (isnan(value->value.number))
+      return qi_strdup("NAN");
+    else if (value->value.number == INFINITY)
+      return qi_strdup("INFINITY");
+    else if (value->value.number == -INFINITY)
+      return qi_strdup("-INFINITY");
+
+    snprintf(string, sizeof(string), "%.15g", value->value.number);
+
+    return qi_strdup(string);
+
+  case QI_STRING:
+    buffer = qi_buffer_make();
+
+    if (quote)
+      qi_buffer_append(buffer, '"');
+
+    for (qi_size_t i = 0; i < strlen(value->value.string); i++) {
+      char c = value->value.string[i];
+
+      if (quote) {
+        switch (c) {
+        case '"':
+        case '\\':
+          qi_buffer_append(buffer, '\\');
+          break;
+
+        case '\n':
+          qi_buffer_append(buffer, '\\');
+          qi_buffer_append(buffer, 'n');
+          continue;
+
+        case '\t':
+          qi_buffer_append(buffer, '\\');
+          qi_buffer_append(buffer, 't');
+          continue;
+
+        case '\r':
+          qi_buffer_append(buffer, '\\');
+          qi_buffer_append(buffer, 'r');
+          continue;
+        }
+
+        if (!isprint(c)) {
+          char temp[8];
+          snprintf(temp, sizeof(temp), "\\x%02x", (unsigned char)c);
+
+          qi_buffer_append_str(buffer, temp);
+          continue;
+        }
+      }
+
+      qi_buffer_append(buffer, c);
+    }
+
+    if (quote)
+      qi_buffer_append(buffer, '"');
+
+    return qi_buffer_read(buffer);
+
+  case QI_BYTES:
+    if (!quote) {
+      if (value->value.bytes->size == 0)
+        return qi_strdup("");
+
+      buffer = qi_buffer_make();
+
+      qi_buffer_append_str(buffer, (char *)value->value.bytes->data);
+
+      return qi_buffer_read(buffer);
+    }
+
+    if (value->value.bytes->size == 0)
+      return qi_strdup("bytes([])");
+
+    buffer = qi_buffer_make();
+
+    qi_buffer_append_str(buffer, "bytes([");
+
+    for (qi_size_t i = 0; i < value->value.bytes->size; i++) {
+      snprintf(string, sizeof(string), "%d", value->value.bytes->data[i]);
+
+      qi_buffer_append_str(buffer, string);
+
+      if (i != value->value.bytes->size - 1)
+        qi_buffer_append_str(buffer, ", ");
+    }
+
+    qi_buffer_append_str(buffer, "])");
+
+    return qi_buffer_read(buffer);
+
+  case QI_FILE:
+    snprintf(string, sizeof(string), "<file %d>", fileno(value->value.file.fd));
+
+    return qi_strdup(string);
+
+  case QI_LIST:
+    if (qi_list_contains(tempstack, value))
+      return qi_strdup("[...]");
+
+    LOCKED(value, {
+      if (qi_list_empty(value->value.list)) {
+        qi_lock_release(value->lock);
+
+        return qi_strdup("[]");
+      }
+
+      qi_list_push(tempstack, value);
+
+      buffer = qi_buffer_make();
+
+      qi_buffer_append(buffer, '[');
+
+      temp = value->value.list;
+
+      while (temp) {
+        qi_buffer_append_str(buffer,
+                             _qi_repr(state, tempstack, temp->value, true));
+
+        if (temp->next)
+          qi_buffer_append_str(buffer, ", ");
+
+        temp = temp->next;
+      }
+
+      qi_buffer_append(buffer, ']');
+    });
+
+    return qi_buffer_read(buffer);
+
+  case QI_TUPLE:
+    if (qi_list_empty(value->value.list))
+      return qi_strdup("()");
+
+    if (qi_list_contains(tempstack, value))
+      return qi_strdup("(...)");
+
+    qi_list_push(tempstack, value);
+
+    buffer = qi_buffer_make();
+
+    qi_buffer_append(buffer, '(');
+
+    temp = value->value.list;
+
+    if (!temp->next) {
+      qi_buffer_append_str(buffer,
+                           _qi_repr(state, tempstack, temp->value, true));
+
+      qi_buffer_append_str(buffer, ", ");
+    } else
+      while (temp) {
+        qi_buffer_append_str(buffer,
+                             _qi_repr(state, tempstack, temp->value, true));
+
+        if (temp->next)
+          qi_buffer_append_str(buffer, ", ");
+
+        temp = temp->next;
+      }
+
+    qi_buffer_append(buffer, ')');
+
+    return qi_buffer_read(buffer);
+
+  case QI_TABLE:
+    if (qi_list_contains(tempstack, value))
+      return qi_strdup("{...}");
+
+    LOCKED(value, {
+      if (qi_table_empty(value->value.table.table)) {
+        qi_lock_release(value->lock);
+
+        return qi_strdup(qi_has_metatable(value) ? "<object {}>" : "{}");
+      }
+
+      qi_list_push(tempstack, value);
+
+      buffer = qi_buffer_make();
+      flag = true;
+
+      if (qi_has_metatable(value))
+        qi_buffer_append_str(buffer, "<object ");
+
+      qi_buffer_append(buffer, '{');
+
+      qi_table_iterate(value->value.table.table, {
+        if (flag)
+          flag = false;
+        else
+          qi_buffer_append_str(buffer, ", ");
+
+        qi_buffer_append(buffer, '"');
+        qi_buffer_append_str(buffer, entry.key);
+        qi_buffer_append(buffer, '"');
+        qi_buffer_append_str(buffer, ": ");
+
+        qi_buffer_append_str(buffer,
+                             _qi_repr(state, tempstack, entry.value, true));
+      });
+
+      qi_buffer_append(buffer, '}');
+
+      if (qi_has_metatable(value))
+        qi_buffer_append(buffer, '>');
+    });
+
+    return qi_buffer_read(buffer);
+
+  case QI_FUNCTION:
+    snprintf(string, sizeof(string),
+             value->value.function.is_builtin ? "<built-in function %s>"
+                                              : "<function %s>",
+             value->value.function.name);
+
+    return qi_strdup(string);
+
+  case QI_DATA:
+    snprintf(string, sizeof(string), "<data %d>", value->value.data.tag);
+
+    return qi_strdup(string);
+
+  default:
+    return qi_strdup("<unknown>");
+  }
+}
+
+static void __fprint_pthread_t(FILE *fd, pthread_t td) {
+  unsigned char *ptr = (unsigned char *)(void *)&td;
+
+  fprintf(fd, "0x");
+
+  for (qi_size_t i = 0; i < sizeof(td); i++)
+    fprintf(fd, "%02x", (unsigned)(ptr[i]));
+}
+
+void qi_finalize(void) { GC_invoke_finalizers(); }
+
+void qi_fatal(qi_state_t *state, char *format, ...) {
+  va_list args;
+  va_start(args, format);
+
+  if (state->_debug_data)
+    fprintf(stderr, "%s:\n  ", state->_debug_data);
+
+  if (!qi_thread_main()) {
+    fputs("Runtime error (thread ", stderr);
+    __fprint_pthread_t(stderr, pthread_self());
+    fputs("): ", stderr);
+  } else
+    fputs("Runtime error: ", stderr);
+  vfprintf(stderr, format, args);
+  fputs(".\n", stderr);
+
+  va_end(args);
+
+  if (__debug_enabled && !qi_list_empty(state->calltrace)) {
+    fputs("Traceback (more recent call last):\n", stderr);
+
+    qi_list_t *list = state->calltrace;
+
+    for (qi_size_t i = 0; list; i++) {
+      qi_list_t *entry = list->value;
+
+      qi_value_t *func = qi_list_index(entry, 0);
+      const char *debug_data = qi_list_index(entry, 1);
+
+      if (debug_data)
+        fprintf(stderr, "  %s, call to %s\n", debug_data,
+                func->value.function.name);
+      else
+        fprintf(stderr, "  File N/A, line N/A, call to %s\n",
+                func->value.function.name);
+
+      list = list->next;
+    }
+  }
+
+  if (!qi_thread_main())
+    pthread_exit(NULL);
+  else {
+    qi_finalize();
+
+    exit(1);
+  }
+}
+
+static void __qi_unset_trap(qi_state_t *state) {
+  qi_trap_t *trap = qi_list_pop(state->traps);
+  if (trap->finally)
+    trap->finally(state);
+}
+
+qi_trap_t *qi_set_trap(qi_state_t *state, qi_defer_t finally) {
+  qi_trap_t *trap = qi_malloc(sizeof(qi_trap_t));
+
+  trap->value = NULL;
+  trap->finally = finally;
+  trap->scope = qi_list_last(state->scopes);
+  trap->scopes_count = qi_list_length(state->scopes);
+  trap->calltrace_size =
+      !__debug_enabled ? 0 : qi_list_length(state->calltrace);
+
+  qi_list_push(state->traps, trap);
+
+  qi_add_defer(state, 0, __qi_unset_trap);
+
+  return trap;
+}
+
+void qi_unset_trap(qi_state_t *state, qi_trap_t *trap) {
+  qi_list_delete(&trap->scope->defers, 0);
+  qi_list_pop(state->traps);
+
+  if (trap->value) {
+    for (size_t i = 0, k = qi_list_length(state->scopes) - trap->scopes_count;
+         i < k; i++)
+      qi_old_scope(state);
+
+    if (__debug_enabled)
+      for (size_t i = 0,
+                  k = qi_list_length(state->calltrace) - trap->calltrace_size;
+           i < k; i++)
+        qi_list_pop(state->calltrace);
+  }
+}
+
+void qi_throw(qi_state_t *state, qi_value_t *value) {
+  if (qi_list_empty(state->traps)) {
+    while (qi_old_scope(state))
+      ;
+
+    qi_fatal(state, "uncaught exception: %s", qi_repr(state, value, false));
+  }
+
+  qi_trap_t *trap = qi_list_last(state->traps);
+  trap->value = value;
+
+  longjmp(trap->label, 1);
+}
+
+void qi_throw_format(qi_state_t *state, char *format, ...) {
+  char buffer[512];
+
+  va_list args;
+  va_start(args, format);
+
+  vsnprintf(buffer, sizeof(buffer), format, args);
+
+  va_end(args);
+
+  qi_throw(state, qi_make_string_copy(state, buffer));
+}
+
+qi_value_t *qi_find(qi_state_t *state, char *name) {
+  qi_ssize_t scopes_count = qi_list_length(state->scopes);
+
+  if (scopes_count > 0)
+    for (qi_ssize_t i = scopes_count - 1; i >= 0; i--) {
+      qi_scope_t *scope = qi_list_index(state->scopes, i);
+      if (scope->is_barrier)
+        continue;
+
+      qi_lock_acquire(scope->lock);
+
+      qi_symbol_t *symbol = qi_table_get(scope->scope, name);
+
+      qi_lock_release(scope->lock);
+
+      if (symbol)
+        return symbol->value;
+    }
+
+  return NULL;
+}
+
+qi_value_t *qi_get(qi_state_t *state, char *name) {
+  qi_value_t *value;
+  if (strcmp(name, "STDIN") == 0)
+    return state->_stdin;
+  else if (strcmp(name, "STDERR") == 0)
+    return state->_stderr;
+  else if (strcmp(name, "STDOUT") == 0)
+    return state->_stdout;
+  else if (strcmp(name, "NAN") == 0)
+    return state->nan;
+  else if (strcmp(name, "INFINITY") == 0)
+    return state->infinity;
+
+  value = qi_find(state, name);
+  if (!value)
+    qi_throw_format(state, "undefined symbol: '%s'", name);
+
+  return value;
+}
+
+static void _qi_decl(qi_state_t *state, char *name, qi_value_t *value,
+                     bool is_constant) {
+  qi_scope_t *scope = qi_list_last(state->scopes);
+  qi_symbol_t *symbol;
+
+  qi_lock_acquire(scope->lock);
+
+  symbol = qi_table_get(scope->scope, name);
+
+  if (symbol) {
+    if (is_constant || symbol->is_constant) {
+      qi_lock_release(scope->lock);
+
+      qi_throw_format(state, "redeclaration of constant symbol: '%s'", name);
+    }
+
+    symbol->value = value;
+  } else {
+    symbol = qi_malloc(sizeof(qi_symbol_t));
+    symbol->value = value;
+    symbol->is_constant = is_constant;
+
+    qi_table_set(scope->scope, name, symbol);
+  }
+
+  qi_lock_release(scope->lock);
+}
+
+void qi_decl_const(qi_state_t *state, char *name, qi_value_t *value) {
+  _qi_decl(state, name, value, true);
+}
+
+void qi_decl(qi_state_t *state, char *name, qi_value_t *value) {
+  _qi_decl(state, name, value, false);
+}
+
+qi_value_t *_qi_set(qi_state_t *state, bool is_pre, bool is_constant,
+                    char *name, qi_value_t *value) {
+  qi_ssize_t scopes_count = qi_list_length(state->scopes);
+
+  if (scopes_count > 1)
+    for (qi_ssize_t i = scopes_count - 1; i >= 0; i--) {
+      qi_scope_t *scope = qi_list_index(state->scopes, i);
+      if (scope->is_barrier)
+        continue;
+
+      qi_lock_acquire(scope->lock);
+
+      qi_symbol_t *symbol = qi_table_get(scope->scope, name);
+
+      if (symbol) {
+        if (is_constant || symbol->is_constant) {
+          qi_lock_release(scope->lock);
+
+          qi_throw_format(state, "redeclaration of constant symbol: '%s'",
+                          name);
+        }
+
+        qi_value_t *old = symbol->value;
+
+        symbol->value = value;
+
+        qi_lock_release(scope->lock);
+
+        return !is_pre && old ? old : value;
+      }
+
+      qi_lock_release(scope->lock);
+    }
+
+  qi_symbol_t *symbol = qi_malloc(sizeof(qi_symbol_t));
+  symbol->value = value;
+  symbol->is_constant = is_constant;
+
+  qi_scope_t *scope = qi_list_last(state->scopes);
+
+  qi_lock_acquire(scope->lock);
+
+  qi_table_set(scope->scope, name, symbol);
+
+  qi_lock_release(scope->lock);
+
+  return value;
+}
+
+size_t _qi_length(qi_state_t *state, qi_value_t *value) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, value, "__len", 1, value))) {
+    if (meta->type != QI_NUMBER)
+      qi_throw_format(state, "__len returned non-number value (%s)",
+                      _qi_type(state, meta));
+
+    return meta->value.number;
+  }
+
+  if (fail)
+    goto leave;
+
+  if (value == state->empty_string || value == state->empty_bytes ||
+      value == state->empty_tuple)
+    return 0;
+
+  switch (value->type) {
+  case QI_STRING:
+    return strlen(value->value.string);
+
+  case QI_BYTES:
+    return value->value.bytes->size;
+
+  case QI_LIST: {
+    qi_size_t length = 0;
+
+    LOCKED(value, { length = qi_list_length(value->value.list); });
+
+    return length;
+  }
+
+  case QI_TUPLE:
+    return qi_list_length(value->value.list);
+
+  case QI_TABLE: {
+    qi_size_t length = 0;
+
+    LOCKED(value, { length = qi_table_length(value->value.table.table); });
+
+    return length;
+  }
+
+  default:
+    break;
+  }
+
+leave:
+  qi_throw_format(state, "cannot get length of %s", _qi_type(state, value));
+
+  return 0;
+}
+
+qi_value_t *qi_del(qi_state_t *state, qi_value_t *value, qi_value_t *index) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, value, "__del", 2, value, index)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  switch (value->type) {
+  case QI_LIST:
+    if (index->type == QI_NUMBER) {
+      bool res;
+
+      LOCKED(value, {
+        res = qi_list_delete(&value->value.list, index->value.number) != NULL;
+      });
+
+      if (!res)
+        qi_throw_format(state, "list index out of range: %s",
+                        qi_repr(state, index, true));
+
+      return value;
+    }
+    break;
+
+  case QI_TABLE:
+    if (index->type == QI_STRING) {
+      bool res;
+
+      LOCKED(value, {
+        res = qi_table_delete(value->value.table.table, index->value.string);
+      });
+
+      if (!res)
+        qi_throw_format(state, "no such key: %s", qi_repr(state, index, true));
+
+      return value;
+    }
+    break;
+
+  default:
+    break;
+  }
+
+leave:
+  qi_throw_format(state, "cannot index %s with %s", _qi_type(state, value),
+                  _qi_type(state, index));
+
+  return NULL;
+}
+
+bool _qi_truthy(qi_state_t *state, qi_value_t *value) {
+  qi_value_t *meta;
+  if ((meta = qi_call_meta(state, NULL, value, "__bool", 1, value))) {
+    if (meta->type != QI_BOOLEAN)
+      qi_throw_format(state, "__bool returned non-boolean value (%s)",
+                      _qi_type(state, meta));
+
+    return meta->value.boolean;
+  }
+
+  switch (value->type) {
+  case QI_NULL:
+    return false;
+
+  case QI_BOOLEAN:
+    return value->value.boolean;
+
+  case QI_NUMBER:
+    return value->value.number != 0;
+
+  case QI_STRING:
+  case QI_BYTES:
+  case QI_LIST:
+  case QI_TUPLE:
+  case QI_TABLE:
+    return _qi_length(state, value) != 0;
+
+  default:
+    return true;
+  }
+
+  return true;
+}
+
+qi_value_t *qi_cast(qi_state_t *state, qi_type_t type, qi_value_t *value) {
+  if (value->type == type)
+    return value;
+
+  bool fail = false;
+
+  switch (type) {
+  case QI_BOOLEAN:
+    return qi_truthy(state, value);
+
+  case QI_NUMBER: {
+    qi_value_t *meta;
+    if ((meta = qi_call_meta(state, &fail, value, "__num", 1, value))) {
+      if (meta->type != QI_NUMBER)
+        qi_throw_format(state, "__num returned non-number value (%s)",
+                        _qi_type(state, meta));
+
+      return meta;
+    }
+
+    if (fail)
+      goto leave;
+
+    switch (value->type) {
+    case QI_NULL:
+      return state->zero;
+
+    case QI_BOOLEAN:
+      return qi_make_number(state, value->value.boolean);
+
+    case QI_STRING:
+      return qi_make_number(state, strtod(value->value.string, NULL));
+
+    default:
+      break;
+    }
+  } break;
+
+  case QI_STRING:
+    if (value->type == QI_BYTES) {
+      qi_buffer_t *buffer = qi_buffer_make();
+
+      for (qi_size_t i = 0; i < value->value.bytes->size; i++)
+        qi_buffer_append(buffer, value->value.bytes->data[i]);
+
+      return qi_make_string(state, qi_buffer_read(buffer));
+    }
+
+    return qi_make_string(state, qi_repr(state, value, false));
+
+  case QI_BYTES: {
+    qi_value_t *meta;
+    if ((meta = qi_call_meta(state, &fail, value, "__bytes", 1, value))) {
+      if (meta->type != QI_BYTES)
+        qi_throw_format(state, "__bytes returned non-bytes value (%s)",
+                        _qi_type(state, meta));
+
+      return meta;
+    }
+
+    if (fail)
+      goto leave;
+
+    switch (value->type) {
+    case QI_STRING:
+      return qi_make_bytes(state, (unsigned char *)(value->value.string),
+                           strlen(value->value.string));
+
+    case QI_LIST: {
+      qi_size_t length;
+      unsigned char *temp;
+
+      LOCKED(value, {
+        qi_list_t *list = value->value.list;
+        length = qi_list_length(list);
+        temp = qi_malloc(length);
+
+        if (!qi_list_empty(list))
+          for (qi_size_t i = 0; list; i++) {
+            qi_value_t *byte = list->value;
+
+            if (byte->type != QI_NUMBER) {
+              qi_lock_release(value->lock);
+
+              qi_throw_format(state,
+                              "cannot cast %s to %s (expected list of numbers)",
+                              _qi_type(state, value), qi_repr_type(type));
+            }
+
+            temp[i] = (unsigned char)(byte->value.number);
+
+            list = list->next;
+          }
+      });
+
+      return qi_make_bytes(state, temp, length);
+    }
+
+    default:
+      break;
+    }
+  } break;
+
+  case QI_LIST: {
+    qi_value_t *meta;
+    if ((meta = qi_call_meta(state, &fail, value, "__list", 1, value))) {
+      if (meta->type != QI_LIST)
+        qi_throw_format(state, "__list returned non-list value (%s)",
+                        _qi_type(state, meta));
+
+      return meta;
+    }
+
+    if (fail)
+      goto leave;
+
+    switch (value->type) {
+    case QI_STRING: {
+      qi_list_t *list = qi_list_make();
+
+      for (qi_size_t i = 0; i < strlen(value->value.string); i++)
+        qi_list_push(list, qi_make_char(state, value->value.string[i]));
+
+      return qi_make_list(state, list);
+    }
+
+    case QI_BYTES: {
+      qi_list_t *list = qi_list_make();
+
+      for (qi_size_t i = 0; i < value->value.bytes->size; i++)
+        qi_list_push(list, qi_make_number(state, value->value.bytes->data[i]));
+
+      return qi_make_list(state, list);
+    }
+
+    case QI_TABLE: {
+      qi_list_t *list = qi_list_make();
+      qi_list_t *keys;
+
+      LOCKED(value, { keys = qi_table_keys(value->value.table.table); });
+
+      if (!qi_list_empty(keys))
+        while (keys) {
+          qi_list_push(list, qi_make_string(state, keys->value));
+
+          keys = keys->next;
+        }
+
+      return qi_make_list(state, list);
+    }
+
+    case QI_TUPLE: {
+      qi_list_t *list = qi_list_make();
+      qi_list_t *temp = value->value.list;
+
+      if (!qi_list_empty(temp))
+        while (temp) {
+          qi_list_push(list, temp->value);
+
+          temp = temp->next;
+        }
+
+      return qi_make_list(state, list);
+    }
+
+    default:
+      break;
+    }
+  } break;
+
+  case QI_TABLE: {
+    qi_value_t *meta;
+    if ((meta = qi_call_meta(state, &fail, value, "__table", 1, value))) {
+      if (meta->type != QI_TABLE)
+        qi_throw_format(state, "__table returned non-table value (%s)",
+                        _qi_type(state, meta));
+
+      return meta;
+    }
+
+    if (fail)
+      goto leave;
+
+    switch (value->type) {
+    case QI_LIST:
+    case QI_TUPLE: {
+      qi_table_t *table = qi_table_make();
+
+      if (value->type == QI_LIST)
+        qi_lock_acquire(value->lock);
+
+      qi_list_t *list = value->value.list;
+      if (!qi_list_empty(list))
+        while (list) {
+          qi_value_t *pair = list->value;
+
+          if (pair->type == QI_LIST)
+            qi_lock_acquire(pair->lock);
+
+          if ((pair->type != QI_LIST && pair->type != QI_TUPLE) ||
+              qi_list_length(pair->value.list) != 2) {
+            if (value->type == QI_LIST)
+              qi_lock_release(value->lock);
+            if (pair->type == QI_LIST)
+              qi_lock_release(pair->lock);
+
+            qi_throw_format(state,
+                            "cannot cast %s to %s (expected sequence of pairs)",
+                            _qi_type(state, value), qi_repr_type(type));
+          }
+
+          qi_value_t *left = pair->value.list->value;
+
+          if (left->type != QI_STRING) {
+            if (value->type == QI_LIST)
+              qi_lock_release(value->lock);
+            if (pair->type == QI_LIST)
+              qi_lock_release(pair->lock);
+
+            qi_throw_format(state,
+                            "cannot cast %s to %s (expected first element of "
+                            "pair to be a string)",
+                            _qi_type(state, value), qi_repr_type(type));
+          }
+
+          qi_value_t *right = pair->value.list->next->value;
+
+          if (pair->type == QI_LIST)
+            qi_lock_release(pair->lock);
+
+          qi_table_set(table, left->value.string, right);
+
+          list = list->next;
+        }
+
+      if (value->type == QI_LIST)
+        qi_lock_release(value->lock);
+
+      return qi_make_table(state, table);
+    }
+
+    default:
+      break;
+    }
+  } break;
+
+  case QI_TUPLE: {
+    qi_value_t *meta;
+    if ((meta = qi_call_meta(state, &fail, value, "__tuple", 1, value))) {
+      if (meta->type != QI_TUPLE)
+        qi_throw_format(state, "__tuple returned non-tuple value (%s)",
+                        _qi_type(state, meta));
+
+      return meta;
+    }
+
+    if (fail)
+      goto leave;
+
+    switch (value->type) {
+    case QI_LIST: {
+      qi_list_t *list = qi_list_make();
+
+      LOCKED(value, {
+        qi_list_t *temp = value->value.list;
+
+        if (!qi_list_empty(temp))
+          while (temp) {
+            qi_list_push(list, temp->value);
+
+            temp = temp->next;
+          }
+      });
+
+      return qi_make_tuple(state, list);
+    }
+
+    case QI_STRING: {
+      qi_list_t *list = qi_list_make();
+
+      for (qi_size_t i = 0; i < strlen(value->value.string); i++)
+        qi_list_push(list, qi_make_char(state, value->value.string[i]));
+
+      return qi_make_tuple(state, list);
+    }
+
+    default:
+      break;
+    }
+  }
+
+  default:
+    break;
+  }
+
+leave:
+  qi_throw_format(state, "cannot cast %s to %s", _qi_type(state, value),
+                  qi_repr_type(type));
+
+  return NULL;
+}
+
+qi_value_t *qi_iter(qi_state_t *state, qi_value_t *value) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, value, "__iter", 1, value)))
+    return qi_iter(state, meta);
+
+  if (fail)
+    qi_throw_format(state, "cannot iterate %s", _qi_type(state, value));
+
+  return qi_to_list(state, value);
+}
+
+qi_value_t *qi_index(qi_state_t *state, qi_value_t *value, qi_value_t *index) {
+  qi_value_t *meta;
+  bool fail = false;
+  if (index->type == QI_STRING &&
+      (meta = qi_get_method(state, value, index->value.string))) {
+    if (meta->type == QI_FUNCTION && !meta->value.function.is_builtin) {
+      qi_value_t *newmeta = qi_make_function(
+          state,
+          meta->value.function.is_pm ? meta->value.function.name
+                                     : index->value.string,
+          meta->value.function.pargc, meta->value.function.handle,
+          meta->value.function.captured);
+
+      if (!is_meta_name(index))
+        newmeta->value.function._this = value;
+
+      return newmeta;
+    }
+
+    return meta;
+  } else if ((meta = qi_call_meta(state, &fail, value, "__index", 2, value,
+                                  index)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  switch (value->type) {
+  case QI_STRING:
+    if (index->type == QI_NUMBER) {
+      qi_size_t length = strlen(value->value.string);
+      qi_ssize_t i = (qi_ssize_t)(index->value.number);
+      if (i < 0)
+        i += (qi_ssize_t)length;
+
+      if (i < 0 || i >= (qi_ssize_t)length)
+        qi_throw_format(state, "string index out of range: %s",
+                        qi_repr(state, index, true));
+
+      return qi_make_char(state, value->value.string[i]);
+    }
+    break;
+
+  case QI_BYTES:
+    if (index->type == QI_NUMBER) {
+      qi_size_t length = value->value.bytes->size;
+      qi_ssize_t i = (qi_ssize_t)(index->value.number);
+      if (i < 0)
+        i += (qi_ssize_t)length;
+
+      if (i < 0 || i >= (qi_ssize_t)length)
+        qi_throw_format(state, "bytes index out of range: %s",
+                        qi_repr(state, index, true));
+
+      return qi_make_number(state, value->value.bytes->data[i]);
+    }
+
+    break;
+
+  case QI_LIST:
+    if (index->type == QI_NUMBER) {
+      qi_value_t *indexed;
+
+      LOCKED(value, {
+        indexed =
+            qi_list_index(value->value.list, (qi_ssize_t)(index->value.number));
+      });
+
+      if (!indexed)
+        qi_throw_format(state, "list index out of range: %s",
+                        qi_repr(state, index, true));
+
+      return indexed;
+    }
+    break;
+
+  case QI_TUPLE:
+    if (index->type == QI_NUMBER) {
+      qi_value_t *indexed =
+          qi_list_index(value->value.list, (qi_ssize_t)(index->value.number));
+
+      if (!indexed)
+        qi_throw_format(state, "tuple index out of range: %s",
+                        qi_repr(state, index, true));
+
+      return indexed;
+    }
+    break;
+
+  case QI_TABLE:
+    if (index->type == QI_STRING) {
+      qi_value_t *indexed;
+
+      LOCKED(value, {
+        indexed = qi_table_get(value->value.table.table, index->value.string);
+      });
+
+      if (!indexed)
+        qi_throw_format(state, "no such key in table: %s",
+                        qi_repr(state, index, true));
+
+      return indexed;
+    }
+    break;
+
+  default:
+    break;
+  }
+
+leave:
+  qi_throw_format(state, "cannot index %s with %s", _qi_type(state, value),
+                  _qi_type(state, index));
+
+  return NULL;
+}
+
+qi_value_t *qi_index_set(qi_state_t *state, bool is_pre, qi_value_t *value,
+                         qi_value_t *index, qi_value_t *newvalue) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, value, "__index_set", 3, value, index,
+                           newvalue)))
+    return meta;
+  else if (fail)
+    goto leave;
+  else if (value->type == QI_TABLE && qi_has_metatable(value) &&
+           index->type == QI_STRING) {
+    if (qi_table_has(qi_get_metatable(value), index->value.string)) {
+      qi_value_t *old;
+
+      if (!is_pre)
+        old = qi_table_get(qi_get_metatable(value), index->value.string);
+
+      qi_table_set(qi_get_metatable(value), index->value.string, newvalue);
+
+      return !is_pre && old ? old : newvalue;
+    }
+  }
+
+  switch (value->type) {
+  case QI_LIST:
+    if (index->type == QI_NUMBER) {
+      qi_value_t *old;
+
+      LOCKED(value, {
+        if (!is_pre)
+          old = qi_list_index(value->value.list,
+                              (qi_ssize_t)(index->value.number));
+
+        newvalue = qi_list_set(value->value.list,
+                               (qi_ssize_t)(index->value.number), newvalue);
+      });
+
+      if (!newvalue)
+        qi_throw_format(state, "list index out of range: %s",
+                        qi_repr(state, index, true));
+
+      return !is_pre && old ? old : newvalue;
+    }
+    break;
+
+  case QI_TABLE:
+    if (index->type == QI_STRING) {
+      qi_value_t *old;
+
+      LOCKED(value, {
+        if (!is_pre)
+          old = qi_table_get(value->value.table.table, index->value.string);
+
+        qi_table_set(value->value.table.table, index->value.string, newvalue);
+      });
+
+      return !is_pre && old ? old : newvalue;
+    }
+    break;
+
+  default:
+    break;
+  }
+
+leave:
+  qi_throw_format(state, "cannot index-set %s with %s", _qi_type(state, value),
+                  _qi_type(state, index));
+
+  return NULL;
+}
+
+static qi_value_t *_qi_call(qi_state_t *state, qi_value_t *value,
+                            qi_list_t *pargs, const char *debug_data) {
+  if (value->type != QI_FUNCTION) {
+    qi_value_t *meta;
+    if ((meta =
+             qi_call_meta(state, NULL, value, "__call", 2, value,
+                          qi_make_list(state, pargs ? pargs : qi_list_make()))))
+      return meta;
+
+    qi_throw_format(state, "cannot call %s", _qi_type(state, value));
+  }
+
+  if (value->value.function._this) {
+    qi_list_t *temp = qi_list_make();
+    temp->value = value->value.function._this;
+    temp->next = pargs;
+
+    pargs = temp;
+  }
+
+  qi_size_t pargc = !pargs ? 0 : qi_list_length(pargs);
+
+  if (pargc < value->value.function.pargc)
+    qi_throw_format(state,
+                    "not enough positional arguments in call to '%s': need at "
+                    "least %zu, got %zu",
+                    value->value.function.name, value->value.function.pargc,
+                    pargc);
+
+  if (__debug_enabled)
+    qi_push_trace(state, value, debug_data);
+
+  if (!value->value.function.is_builtin) {
+    qi_new_scope(state);
+
+    qi_decl_const(state, "it", value);
+    qi_decl(state, "arguments",
+            qi_make_list(state, pargs ? pargs : qi_list_make()));
+
+    if (value->value.function.captured) {
+      qi_table_iterate(value->value.function.captured,
+                       { qi_decl(state, entry.key, entry.value); });
+    }
+  }
+
+  qi_value_t *result = value->value.function.handle(state, pargc, pargs);
+
+  if (!value->value.function.is_builtin)
+    qi_old_scope(state);
+
+  if (__debug_enabled)
+    qi_pop_trace(state);
+
+  return result;
+}
+
+qi_value_t *qi_call(qi_state_t *state, qi_value_t *value, qi_list_t *pargs) {
+  return _qi_call(state, value, pargs, NULL);
+}
+
+qi_value_t *qi_call_debug(qi_state_t *state, qi_value_t *value,
+                          qi_list_t *pargs, const char *debug_data) {
+  return _qi_call(state, value, pargs, debug_data);
+}
+
+bool _qi_equals(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  if ((meta = qi_call_meta(state, NULL, a, "__equals", 2, a, b))) {
+    if (meta->type != QI_BOOLEAN)
+      qi_throw_format(state, "__equals returned non-boolean value (%s)",
+                      _qi_type(state, meta));
+
+    return meta->value.boolean;
+  } else if ((meta = qi_call_meta(state, NULL, b, "__equals", 2, b, a))) {
+    if (meta->type != QI_BOOLEAN)
+      qi_throw_format(state, "__equals returned non-boolean value (%s)",
+                      _qi_type(state, meta));
+
+    return meta->value.boolean;
+  }
+
+  if (a->type != b->type)
+    return false;
+
+  switch (a->type) {
+  case QI_NULL:
+    return true;
+
+  case QI_BOOLEAN:
+    return a->value.boolean == b->value.boolean;
+
+  case QI_NUMBER:
+    if (isnan(a->value.number) && isnan(b->value.number))
+      return true;
+
+    return a->value.number == b->value.number;
+
+  case QI_STRING:
+    return strcmp(a->value.string, b->value.string) == 0;
+
+  case QI_BYTES:
+    if (a->value.bytes->size != b->value.bytes->size)
+      return false;
+
+    return memcmp(a->value.bytes->data, b->value.bytes->data,
+                  a->value.bytes->size) == 0;
+
+  case QI_FILE:
+    return fileno(a->value.file.fd) == fileno(b->value.file.fd);
+
+  case QI_LIST:
+    qi_lock_acquire(a->lock);
+    qi_lock_acquire(b->lock);
+
+    if (a->value.list == b->value.list) {
+      qi_lock_release(a->lock);
+      qi_lock_release(b->lock);
+
+      return true;
+    }
+
+    if (qi_list_length(a->value.list) != qi_list_length(b->value.list)) {
+      qi_lock_release(a->lock);
+      qi_lock_release(b->lock);
+
+      return false;
+    }
+
+    for (qi_size_t i = 0; i < qi_list_length(a->value.list); i++)
+      if (!_qi_equals(state, qi_list_index(a->value.list, i),
+                      qi_list_index(b->value.list, i))) {
+        qi_lock_release(a->lock);
+        qi_lock_release(b->lock);
+
+        return false;
+      }
+
+    qi_lock_release(a->lock);
+    qi_lock_release(b->lock);
+
+    return true;
+
+  case QI_TUPLE:
+    if (a->value.list == b->value.list)
+      return true;
+
+    if (qi_list_length(a->value.list) != qi_list_length(b->value.list))
+      return false;
+
+    for (qi_size_t i = 0; i < qi_list_length(a->value.list); i++)
+      if (!_qi_equals(state, qi_list_index(a->value.list, i),
+                      qi_list_index(b->value.list, i)))
+        return false;
+
+    return true;
+
+  case QI_TABLE:
+    qi_lock_acquire(a->lock);
+    qi_lock_acquire(b->lock);
+
+    if (a->value.table.table == b->value.table.table) {
+      qi_lock_release(a->lock);
+      qi_lock_release(b->lock);
+
+      return true;
+    }
+
+    if (qi_table_length(a->value.table.table) !=
+        qi_table_length(b->value.table.table)) {
+      qi_lock_release(a->lock);
+      qi_lock_release(b->lock);
+
+      return false;
+    }
+
+    qi_table_iterate(a->value.table.table, {
+      qi_value_t *a_value = entry.value;
+      qi_value_t *b_value = qi_table_get(b->value.table.table, entry.key);
+      if (!b_value) {
+        qi_lock_release(a->lock);
+        qi_lock_release(b->lock);
+
+        return false;
+      }
+
+      if (!_qi_equals(state, a_value, b_value)) {
+        qi_lock_release(a->lock);
+        qi_lock_release(b->lock);
+
+        return false;
+      }
+    });
+
+    qi_lock_release(a->lock);
+    qi_lock_release(b->lock);
+
+    return true;
+
+  case QI_FUNCTION:
+    return strcmp(a->value.function.name, b->value.function.name) == 0 &&
+           a->value.function.handle == b->value.function.handle;
+
+  case QI_DATA:
+    return a->value.data.tag == b->value.data.tag &&
+           a->value.data.data == b->value.data.data;
+
+  default:
+    return true;
+  }
+
+  return true;
+}
+
+bool _qi_in(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, b, "__in", 2, b, a))) {
+    if (meta->type != QI_BOOLEAN)
+      qi_throw_format(state, "__in returned non-boolean value (%s)",
+                      _qi_type(state, meta));
+
+    return meta->value.boolean;
+  }
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_STRING && b->type == QI_STRING)
+    return strstr(b->value.string, a->value.string) != NULL;
+  else if (a->type == QI_NUMBER && b->type == QI_BYTES) {
+    for (qi_size_t i = 0; i < b->value.bytes->size; i++)
+      if (b->value.bytes->data[i] == (unsigned char)(a->value.number))
+        return true;
+
+    return false;
+  } else if (b->type == QI_LIST) {
+    LOCKED(b, {
+      qi_list_t *list = b->value.list;
+
+      if (qi_list_empty(list)) {
+        qi_lock_release(b->lock);
+
+        return false;
+      }
+
+      while (list) {
+        if (_qi_equals(state, a, list->value)) {
+          qi_lock_release(b->lock);
+
+          return true;
+        }
+
+        list = list->next;
+      }
+    });
+
+    return false;
+  } else if (b->type == QI_TUPLE) {
+    qi_list_t *list = b->value.list;
+
+    if (qi_list_empty(list))
+      return false;
+
+    while (list) {
+      if (_qi_equals(state, a, list->value))
+        return true;
+
+      list = list->next;
+    }
+
+    return false;
+  } else if (a->type == QI_STRING && b->type == QI_TABLE) {
+    bool res = false;
+
+    LOCKED(b, {
+      qi_table_t *table = b->value.table.table;
+
+      if (!qi_table_empty(table))
+        res = qi_table_has(table, a->value.string);
+    });
+
+    return res;
+  }
+
+leave:
+  qi_throw_format(state, "unsupported operand types for in: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return false;
+}
+
+qi_value_t *qi_add(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, a, "__add", 2, a, b)))
+    return meta;
+  else if (fail)
+    goto leave;
+  else if ((meta = qi_call_meta(state, &fail, b, "__add", 2, b, a)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_STRING && b->type == QI_STRING) {
+    if (!*a->value.string && !*b->value.string)
+      return state->empty_string;
+    else if (!*a->value.string)
+      return qi_make_string(state, b->value.string);
+    else if (!*b->value.string)
+      return qi_make_string(state, a->value.string);
+
+    char *string =
+        qi_malloc(strlen(a->value.string) + strlen(b->value.string) + 1);
+    strcpy(string, a->value.string);
+    strcat(string, b->value.string);
+
+    return qi_make_string(state, string);
+  } else if (a->type == QI_BYTES && b->type == QI_BYTES) {
+    if (a->value.bytes->size == 0 && b->value.bytes->size == 0)
+      return state->empty_bytes;
+    else if (a->value.bytes->size == 0)
+      return qi_make_bytes(state, b->value.bytes->data, b->value.bytes->size);
+    else if (b->value.bytes->size == 0)
+      return qi_make_bytes(state, a->value.bytes->data, a->value.bytes->size);
+
+    qi_size_t size = a->value.bytes->size + b->value.bytes->size;
+    unsigned char *bytes = qi_malloc(size);
+
+    memcpy(bytes, a->value.bytes->data, a->value.bytes->size);
+    memcpy(bytes + a->value.bytes->size, b->value.bytes->data,
+           b->value.bytes->size);
+
+    return qi_make_bytes(state, bytes, size);
+  } else if ((a->type == QI_LIST && b->type == QI_LIST) ||
+             (a->type == QI_TUPLE && b->type == QI_TUPLE)) {
+    if (a == state->empty_tuple && b == state->empty_tuple)
+      return state->empty_tuple;
+    else if (a == state->empty_tuple)
+      return b;
+    else if (b == state->empty_tuple)
+      return b;
+
+    qi_list_t *newlist = qi_list_make();
+    qi_list_t *list;
+
+    if (a->type == QI_LIST) {
+      qi_lock_acquire(a->lock);
+      qi_lock_acquire(b->lock);
+    }
+
+    list = a->value.list;
+    if (!qi_list_empty(list))
+      while (list) {
+        qi_list_push(newlist, list->value);
+
+        list = list->next;
+      }
+
+    if (a->type == QI_LIST)
+      qi_lock_release(a->lock);
+
+    list = b->value.list;
+    if (!qi_list_empty(list))
+      while (list) {
+        qi_list_push(newlist, list->value);
+
+        list = list->next;
+      }
+
+    if (a->type == QI_LIST)
+      qi_lock_release(b->lock);
+
+    if (a->type == QI_TUPLE)
+      return qi_make_tuple(state, newlist);
+
+    return qi_make_list(state, newlist);
+  } else if (a->type == QI_TABLE && b->type == QI_TABLE) {
+    qi_table_t *newtable = qi_table_make();
+
+    qi_lock_acquire(a->lock);
+    qi_lock_acquire(b->lock);
+
+    qi_table_iterate(a->value.table.table,
+                     { qi_table_set(newtable, entry.key, entry.value); });
+
+    qi_lock_release(a->lock);
+
+    qi_table_iterate(b->value.table.table,
+                     { qi_table_set(newtable, entry.key, entry.value); });
+
+    qi_lock_release(b->lock);
+
+    return qi_make_table(state, newtable);
+  } else if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state, a->value.number + b->value.number);
+
+leave:
+  qi_throw_format(state, "unsupported operand types for +: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_sub(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, a, "__sub", 2, a, b)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state, a->value.number - b->value.number);
+
+leave:
+  qi_throw_format(state, "unsupported operand types for -: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_mul(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, a, "__mul", 2, a, b)))
+    return meta;
+  else if (fail)
+    goto leave;
+  else if ((meta = qi_call_meta(state, &fail, b, "__mul", 2, b, a)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state, a->value.number * b->value.number);
+
+leave:
+  qi_throw_format(state, "unsupported operand types for *: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_div(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, a, "__div", 2, a, b)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER) {
+    if (b->value.number == 0) {
+      if (a->value.number == 0)
+        return state->nan;
+
+      return state->infinity;
+    }
+
+    return qi_make_number(state, a->value.number / b->value.number);
+  }
+
+leave:
+  qi_throw_format(state, "unsupported operand types for /: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_idiv(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, a, "__idiv", 2, a, b)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER) {
+    if (b->value.number == 0) {
+      if (a->value.number == 0)
+        return state->nan;
+
+      return state->infinity;
+    }
+
+    return qi_make_number(state, (long)(a->value.number / b->value.number));
+  }
+
+leave:
+  qi_throw_format(state, "unsupported operand types for //: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_mod(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, a, "__mod", 2, a, b)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER) {
+    if (b->value.number == 0) {
+      if (a->value.number == 0)
+        return state->nan;
+
+      return state->infinity;
+    }
+
+    return qi_make_number(state, fmod(a->value.number, b->value.number));
+  }
+
+leave:
+  qi_throw_format(state, "unsupported operand types for %: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_pow(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, a, "__pow", 2, a, b)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state, powf(a->value.number, b->value.number));
+
+leave:
+  qi_throw_format(state, "unsupported operand types for **: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_band(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, a, "__band", 2, a, b)))
+    return meta;
+  else if (fail)
+    goto leave;
+  else if ((meta = qi_call_meta(state, &fail, b, "__band", 2, b, a)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state,
+                          (int)(a->value.number) & (int)(b->value.number));
+
+leave:
+  qi_throw_format(state, "unsupported operand types for &: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_bor(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, a, "__bor", 2, a, b)))
+    return meta;
+  else if (fail)
+    goto leave;
+  else if ((meta = qi_call_meta(state, &fail, b, "__bor", 2, b, a)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state,
+                          (int)(a->value.number) | (int)(b->value.number));
+
+leave:
+  qi_throw_format(state, "unsupported operand types for |: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_xor(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+
+  if ((meta = qi_call_meta(state, &fail, a, "__xor", 2, a, b)))
+    return meta;
+  else if (fail)
+    goto leave;
+  else if ((meta = qi_call_meta(state, &fail, b, "__xor", 2, b, a)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state,
+                          (int)(a->value.number) ^ (int)(b->value.number));
+
+leave:
+  qi_throw_format(state, "unsupported operand types for ^: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_shl(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, a, "__shl", 2, a, b)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state, (int)(a->value.number)
+                                     << (int)(b->value.number));
+
+leave:
+  qi_throw_format(state, "unsupported operand types for <<: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+qi_value_t *qi_shr(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, a, "__shr", 2, a, b)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return qi_make_number(state,
+                          (int)(a->value.number) >> (int)(b->value.number));
+
+leave:
+  qi_throw_format(state, "unsupported operand types for >>: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return NULL;
+}
+
+bool _qi_lt(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, a, "__lt", 2, a, b))) {
+    if (meta->type != QI_BOOLEAN)
+      qi_throw_format(state, "__lt returned non-boolean value (%s)",
+                      _qi_type(state, meta));
+
+    return meta->value.boolean;
+  }
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return a->value.number < b->value.number;
+  else if (a->type == QI_STRING && b->type == QI_STRING &&
+           (strlen(a->value.string) == strlen(b->value.string) == 1))
+    return a->value.string[0] < b->value.string[0];
+
+leave:
+  qi_throw_format(state, "unsupported operand types for <: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return false;
+}
+
+bool _qi_gt(qi_state_t *state, qi_value_t *a, qi_value_t *b) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, a, "__gt", 2, a, b))) {
+    if (meta->type != QI_BOOLEAN)
+      qi_throw_format(state, "__gt returned non-boolean value (%s)",
+                      _qi_type(state, meta));
+
+    return meta->value.boolean;
+  }
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER && b->type == QI_NUMBER)
+    return a->value.number > b->value.number;
+  else if (a->type == QI_STRING && b->type == QI_STRING &&
+           (strlen(a->value.string) == strlen(b->value.string) == 1))
+    return a->value.string[0] > b->value.string[0];
+
+leave:
+  qi_throw_format(state, "unsupported operand types for >: %s and %s",
+                  _qi_type(state, a), _qi_type(state, b));
+
+  return false;
+}
+
+qi_value_t *qi_negate(qi_state_t *state, qi_value_t *a) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, a, "__negate", 1, a)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER)
+    return qi_make_number(state, -a->value.number);
+
+leave:
+  qi_throw_format(state, "unsupported operand type for unary -: %s",
+                  _qi_type(state, a));
+
+  return NULL;
+}
+
+qi_value_t *qi_bnot(qi_state_t *state, qi_value_t *a) {
+  qi_value_t *meta;
+  bool fail = false;
+  if ((meta = qi_call_meta(state, &fail, a, "__bnot", 1, a)))
+    return meta;
+
+  if (fail)
+    goto leave;
+
+  if (a->type == QI_NUMBER)
+    return qi_make_number(state, ~(int)(a->value.number));
+
+leave:
+  qi_throw_format(state, "unsupported operand type for unary ~: %s",
+                  _qi_type(state, a));
+
+  return NULL;
+}
+
+static void qi_set_barrier(qi_state_t *state) {
+  qi_scope_t *scope = qi_malloc(sizeof(qi_scope_t));
+  scope->scope = NULL;
+  scope->defers = NULL;
+  scope->is_barrier = true;
+  scope->lock = NULL;
+
+  qi_list_push(state->scopes, scope);
+}
+
+static qi_state_t *qi_state_clone(qi_state_t *state) {
+  qi_state_t *newstate = qi_malloc(sizeof(qi_state_t));
+  memcpy(newstate, state, sizeof(qi_state_t));
+
+  newstate->traps = qi_list_make();
+  newstate->scopes = qi_list_copy(state->scopes);
+  qi_set_barrier(newstate);
+
+  if (__debug_enabled)
+    newstate->calltrace = qi_list_copy(state->calltrace);
+
+  return newstate;
+}
+
+static void *__thread_wrapper(void *_args) {
+  qi_list_t *args = (qi_list_t *)_args;
+
+  qi_state_t *state = qi_list_index(args, 0);
+
+  qi_value_t *fn = qi_list_index(args, 1);
+  qi_list_t *pargs = qi_list_index(args, 2);
+
+  qi_value_t *value = qi_call(state, fn, qi_list_empty(pargs) ? NULL : pargs);
+
+  pthread_exit((void *)value);
+
+  return NULL;
+}
+
+void *qi_thread_create(qi_state_t *state, qi_value_t *fn, qi_list_t *args) {
+  pthread_t *td = qi_malloc_atomic(sizeof(pthread_t));
+
+  qi_list_t *_args = qi_list_make();
+  qi_list_push(_args, qi_state_clone(state));
+  qi_list_push(_args, fn);
+  qi_list_push(_args, args);
+
+  pthread_create(td, NULL, __thread_wrapper, (void *)_args);
+
+  return (void *)td;
+}
+
+void qi_thread_exit(qi_state_t *state, qi_value_t *value) {
+  if (!qi_thread_main())
+    while (qi_old_scope(state))
+      ;
+
+  if (!qi_thread_main())
+    pthread_exit((void *)value);
+  else
+    pthread_exit(NULL);
+}
+
+bool qi_thread_main(void) { return pthread_self() == __main_tid; }
+
+qi_value_t *qi_thread_join(qi_state_t *state, void *_td) {
+  pthread_t *td = (pthread_t *)_td;
+
+  qi_value_t *ret = state->nil;
+
+  pthread_join(*td, (void *)&ret);
+
+  if (!ret)
+    return state->nil;
+
+  return ret;
+}
+
+void *qi_lock_create(void) {
+  pthread_mutex_t *mutex = qi_malloc_atomic(sizeof(pthread_mutex_t));
+  if (pthread_mutex_init(mutex, NULL) != 0)
+    return NULL;
+
+  return (void *)mutex;
+}
+
+void qi_lock_destroy(void *lock) {
+  pthread_mutex_t *mutex = (pthread_mutex_t *)lock;
+  pthread_mutex_destroy(mutex);
+}
+
+bool qi_lock_acquired(void *lock) {
+  pthread_mutex_t *mutex = (pthread_mutex_t *)lock;
+  if (pthread_mutex_trylock(mutex) == 0) {
+    pthread_mutex_unlock(mutex);
+
+    return false;
+  }
+
+  return true;
+}
+
+void qi_lock_acquire(void *lock) {
+  pthread_mutex_t *mutex = (pthread_mutex_t *)lock;
+  pthread_mutex_lock(mutex);
+}
+
+bool qi_lock_tryacquire(void *lock) {
+  pthread_mutex_t *mutex = (pthread_mutex_t *)lock;
+  if (pthread_mutex_trylock(mutex) == 0)
+    return true;
+
+  return false;
+}
+
+void qi_lock_release(void *lock) {
+  pthread_mutex_t *mutex = (pthread_mutex_t *)lock;
+  pthread_mutex_unlock(mutex);
+}
+
+qi_value_t *qi_builtin_print(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  bool first = true;
+
+  for (int i = 0; i < pargc; i++) {
+    qi_value_t *a = qi_list_index(pargs, i);
+
+    if (first)
+      first = false;
+    else
+      fputc(' ', stdout);
+
+    fprintf(stdout, "%s", qi_show(state, a));
+  }
+
+  return state->nil;
+}
+
+qi_value_t *qi_builtin_println(qi_state_t *state, qi_size_t pargc,
+                               qi_list_t *pargs) {
+  qi_builtin_print(state, pargc, pargs);
+
+  fputc('\n', stdout);
+
+  return state->nil;
+}
+
+qi_value_t *qi_builtin_set_meta_table(qi_state_t *state, qi_size_t pargc,
+                                      qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_TABLE)
+    qi_throw_format(state, "expected first argument to be: table, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_TABLE)
+    qi_throw_format(state, "expected second argument to be: table, but got: %s",
+                    _qi_type(state, b));
+
+  LOCKED(a, { a->value.table.metatable = b; });
+
+  return a;
+}
+
+qi_value_t *qi_builtin_get_meta_table(qi_state_t *state, qi_size_t pargc,
+                                      qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_TABLE)
+    qi_throw_format(state, "expected first argument to be: table, but got: %s",
+                    _qi_type(state, a));
+
+  qi_value_t *value;
+
+  LOCKED(a, { value = a->value.table.metatable; });
+
+  return value;
+}
+
+qi_value_t *qi_builtin_has_meta_table(qi_state_t *state, qi_size_t pargc,
+                                      qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_TABLE)
+    qi_throw_format(state, "expected first argument to be: table, but got: %s",
+                    _qi_type(state, a));
+
+  bool res = false;
+
+  LOCKED(a, { res = qi_has_metatable(a); });
+
+  return res ? state->_true : state->_false;
+}
+
+qi_value_t *qi_builtin_delete_meta_table(qi_state_t *state, qi_size_t pargc,
+                                         qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_TABLE)
+    qi_throw_format(state, "expected first argument to be: table, but got: %s",
+                    _qi_type(state, a));
+
+  LOCKED(a, { a->value.table.metatable = state->nil; });
+
+  return state->nil;
+}
+
+qi_value_t *qi_builtin_has_method(qi_state_t *state, qi_size_t pargc,
+                                  qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_TABLE)
+    qi_throw_format(state, "expected first argument to be: table, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_STRING)
+    qi_throw_format(state,
+                    "expected second argument to be: string, but got: %s",
+                    _qi_type(state, b));
+
+  qi_value_t *value;
+  bool res = false;
+
+  LOCKED(a, {
+    res =
+        qi_has_metatable(a) &&
+        (value = qi_table_get(qi_get_metatable(a), b->value.string)) != NULL &&
+        value->type == QI_FUNCTION;
+  });
+
+  return res ? state->_true : state->_false;
+}
+
+qi_value_t *qi_builtin_delete_method(qi_state_t *state, qi_size_t pargc,
+                                     qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_TABLE)
+    qi_throw_format(state, "expected first argument to be: table, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_STRING)
+    qi_throw_format(state,
+                    "expected second argument to be: string, but got: %s",
+                    _qi_type(state, b));
+
+  LOCKED(a, {
+    if (qi_has_metatable(a))
+      if (!qi_table_delete(qi_get_metatable(a), b->value.string)) {
+        qi_lock_release(a->lock);
+
+        qi_throw_format(state, "no such method: '%s'", b->value.string);
+      }
+  });
+
+  return state->nil;
+}
+
+qi_value_t *qi_builtin_set_global(qi_state_t *state, qi_size_t pargc,
+                                  qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+  qi_value_t *c = qi_list_index(pargs, 2);
+  if (!c)
+    c = state->zero;
+  else if (c->type != QI_NUMBER)
+    qi_throw_format(state, "expected third argument to be: number, but got: %s",
+                    _qi_type(state, c));
+
+  if (a->type != QI_STRING)
+    qi_throw_format(state, "expected first argument to be: string, but got: %s",
+                    _qi_type(state, a));
+
+  char *name = a->value.string;
+
+  qi_symbol_t *symbol;
+
+  qi_size_t offset = (qi_size_t)(c->value.number);
+  qi_scope_t *scope;
+
+  if (offset > 0) {
+    scope = qi_list_index(state->scopes, -((qi_ssize_t)offset));
+
+    if (!scope)
+      qi_throw_format(state, "illegal scope index: %s",
+                      qi_repr(state, c, true));
+  } else
+    scope = qi_list_first(state->scopes);
+
+  qi_lock_acquire(scope->lock);
+
+  symbol = qi_table_get(scope->scope, name);
+  if (symbol) {
+    if (symbol->is_constant) {
+      qi_lock_release(scope->lock);
+
+      qi_throw_format(state, "redeclaration of constant symbol: '%s'", name);
+    }
+
+    qi_value_t *ret = symbol->value;
+    symbol->value = b;
+
+    qi_lock_release(scope->lock);
+
+    return ret;
+  }
+
+  symbol = qi_malloc(sizeof(qi_symbol_t));
+  symbol->value = b;
+  symbol->is_constant = false;
+
+  qi_table_set(scope->scope, name, symbol);
+
+  qi_lock_release(scope->lock);
+
+  return b;
+}
+
+qi_value_t *qi_builtin_get_global(qi_state_t *state, qi_size_t pargc,
+                                  qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+  if (!b)
+    b = state->zero;
+  else if (b->type != QI_NUMBER)
+    qi_throw_format(state,
+                    "expected second argument to be: number, but got: %s",
+                    _qi_type(state, b));
+
+  if (a->type != QI_STRING)
+    qi_throw_format(state, "expected first argument to be: string, but got: %s",
+                    _qi_type(state, a));
+
+  char *name = a->value.string;
+
+  qi_value_t *ret = state->nil;
+
+  qi_size_t offset = (qi_size_t)(b->value.number);
+  qi_scope_t *scope;
+
+  if (offset > 0) {
+    scope = qi_list_index(state->scopes, -((qi_ssize_t)offset));
+
+    if (!scope)
+      qi_throw_format(state, "illegal scope index: %s",
+                      qi_repr(state, b, true));
+  } else
+    scope = qi_list_first(state->scopes);
+
+  qi_lock_acquire(scope->lock);
+
+  qi_symbol_t *symbol = qi_table_get(scope->scope, name);
+
+  if (symbol)
+    ret = symbol->value;
+
+  qi_lock_release(scope->lock);
+
+  return ret;
+}
+
+qi_value_t *qi_builtin_get_globals(qi_state_t *state, qi_size_t pargc,
+                                   qi_list_t *pargs) {
+  qi_table_t *table = qi_table_make();
+
+  qi_scope_t *scope = qi_list_first(state->scopes);
+
+  qi_lock_acquire(scope->lock);
+
+  qi_table_iterate(scope->scope, {
+    qi_symbol_t *symbol = entry.value;
+
+    qi_table_set(table, entry.key, symbol->value);
+  });
+
+  qi_lock_release(scope->lock);
+
+  return qi_make_table(state, table);
+}
+
+#define is_valid_mode(fmod)                                                    \
+  (strcmp((fmod), "w") == 0 || strcmp((fmod), "r") == 0 ||                     \
+   strcmp((fmod), "a") == 0 || strcmp((fmod), "a+") == 0 ||                    \
+   strcmp((fmod), "w+") == 0 || strcmp((fmod), "r+") == 0)
+qi_value_t *qi_builtin_fopen(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_STRING)
+    qi_throw_format(state, "expected first argument to be: string, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_STRING)
+    qi_throw_format(state,
+                    "expected second argument to be: string, but got: %s",
+                    _qi_type(state, b));
+
+  if (!is_valid_mode(b->value.string))
+    qi_throw_format(state, "invalid mode: %s", qi_repr(state, b, true));
+
+  char mode[4];
+  snprintf(mode, sizeof(mode), "%sb", b->value.string);
+
+  FILE *file = fopen(a->value.string, mode);
+  if (!file)
+    qi_throw_format(state, "cannot open file: %s", qi_repr(state, a, true));
+
+  return qi_make_file(state, file, b->value.string);
+}
+
+#define is_valid_read_mode(fmod)                                               \
+  (strcmp((fmod), "a+") == 0 || strcmp((fmod), "r") == 0 ||                    \
+   strcmp((fmod), "w+") == 0 || strcmp((fmod), "r+") == 0)
+qi_value_t *qi_builtin_fread(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_NUMBER)
+    qi_throw_format(state,
+                    "expected second argument to be: number, but got: %s",
+                    _qi_type(state, b));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  if (!is_valid_read_mode(a->value.file.mode))
+    qi_throw_format(state, "file is not readable");
+
+  qi_size_t size;
+  if (b->value.number < 0) {
+    fseek(a->value.file.fd, 0, SEEK_END);
+    size = ftell(a->value.file.fd);
+    fseek(a->value.file.fd, 0, SEEK_SET);
+  } else
+    size = (qi_size_t)(b->value.number);
+
+  unsigned char *data = qi_malloc(size);
+
+  qi_size_t count = fread(data, sizeof(unsigned char), size, a->value.file.fd);
+
+  return qi_make_bytes(state, data, count);
+}
+
+qi_value_t *qi_builtin_fgets(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_NUMBER)
+    qi_throw_format(state,
+                    "expected second argument to be: number, but got: %s",
+                    _qi_type(state, b));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  if (!is_valid_read_mode(a->value.file.mode))
+    qi_throw_format(state, "file is not readable");
+
+  qi_size_t size = (qi_size_t)(b->value.number);
+  char *data = qi_malloc(size + 1);
+
+  if (!fgets(data, size, a->value.file.fd))
+    qi_throw_format(state, "reached EOF");
+
+  return qi_make_string(state, data);
+}
+
+qi_value_t *qi_builtin_fgetc(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  if (!is_valid_read_mode(a->value.file.mode))
+    qi_throw_format(state, "file is not readable");
+
+  int c = fgetc(a->value.file.fd);
+
+  return qi_make_number(state, c);
+}
+
+#define is_valid_write_mode(fmod)                                              \
+  (strcmp((fmod), "a") == 0 || strcmp((fmod), "a+") == 0 ||                    \
+   strcmp((fmod), "w") == 0 || strcmp((fmod), "w+") == 0 ||                    \
+   strcmp((fmod), "r+") == 0)
+qi_value_t *qi_builtin_fputc(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_NUMBER &&
+      (b->type != QI_STRING || strlen(b->value.string) != 1))
+    qi_throw_format(state,
+                    "expected second argument to be: number or string of "
+                    "length 1, but got: %s",
+                    _qi_type(state, b));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  if (!is_valid_write_mode(a->value.file.mode))
+    qi_throw_format(state, "file is not writeable");
+
+  fputc(b->type == QI_NUMBER ? b->value.number : b->value.string[0],
+        a->value.file.fd);
+
+  return state->nil;
+}
+
+qi_value_t *qi_builtin_fwrite(qi_state_t *state, qi_size_t pargc,
+                              qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_BYTES)
+    qi_throw_format(state, "expected second argument to be: bytes, but got: %s",
+                    _qi_type(state, b));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  if (!is_valid_write_mode(a->value.file.mode))
+    qi_throw_format(state, "file is not writeable");
+
+  qi_size_t count = fwrite(b->value.bytes->data, sizeof(unsigned char),
+                           b->value.bytes->size, a->value.file.fd);
+
+  return qi_make_number(state, count);
+}
+
+qi_value_t *qi_builtin_fputs(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_STRING)
+    qi_throw_format(state,
+                    "expected second argument to be: string, but got: %s",
+                    _qi_type(state, b));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  if (!is_valid_write_mode(a->value.file.mode))
+    qi_throw_format(state, "file is not writeable");
+
+  qi_size_t count = fputs(b->value.string, a->value.file.fd);
+
+  return qi_make_number(state, count);
+}
+
+qi_value_t *qi_builtin_fseek(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+  qi_value_t *c = qi_list_index(pargs, 2);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_NUMBER)
+    qi_throw_format(state,
+                    "expected second argument to be: number, but got: %s",
+                    _qi_type(state, b));
+
+  if (c->type != QI_NUMBER)
+    qi_throw_format(state, "expected third argument to be: number, but got: %s",
+                    _qi_type(state, c));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  qi_size_t offset = (qi_size_t)(b->value.number);
+  unsigned int origin = (unsigned int)(c->value.number);
+
+  fseek(a->value.file.fd, offset, origin);
+
+  return state->nil;
+}
+
+qi_value_t *qi_builtin_ftell(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  qi_size_t position = ftell(a->value.file.fd);
+
+  return qi_make_number(state, position);
+}
+
+qi_value_t *qi_builtin_fflush(qi_state_t *state, qi_size_t pargc,
+                              qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "file is closed");
+
+  fflush(a->value.file.fd);
+
+  return state->nil;
+}
+
+qi_value_t *qi_builtin_fclose(qi_state_t *state, qi_size_t pargc,
+                              qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  if (!a->value.file.is_open)
+    qi_throw_format(state, "already closed");
+
+  if (a->value.file.fd == stdin || a->value.file.fd == stderr ||
+      a->value.file.fd == stdout)
+    qi_throw_format(state, "cannot close standard streams");
+
+  fclose(a->value.file.fd);
+  a->value.file.is_open = false;
+
+  return a;
+}
+
+qi_value_t *qi_builtin_fclosed(qi_state_t *state, qi_size_t pargc,
+                               qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_FILE)
+    qi_throw_format(state, "expected first argument to be: file, but got: %s",
+                    _qi_type(state, a));
+
+  return a->value.file.is_open ? state->_false : state->_true;
+}
+
+qi_value_t *qi_builtin_chr(qi_state_t *state, qi_size_t pargc,
+                           qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_NUMBER)
+    qi_throw_format(state, "expected first argument to be: number, but got: %s",
+                    _qi_type(state, a));
+
+  unsigned char c = (int)(a->value.number);
+
+  return qi_make_char(state, c);
+}
+
+qi_value_t *qi_builtin_ord(qi_state_t *state, qi_size_t pargc,
+                           qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_STRING || strlen(a->value.string) != 1)
+    qi_throw_format(
+        state, "expected first argument to be: string of length 1, but got: %s",
+        _qi_type(state, a));
+
+  return qi_make_number(state, a->value.string[0]);
+}
+
+qi_value_t *qi_builtin_len(qi_state_t *state, qi_size_t pargc,
+                           qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_length(state, a);
+}
+
+qi_value_t *qi_builtin_type(qi_state_t *state, qi_size_t pargc,
+                            qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_type(state, a);
+}
+
+qi_value_t *qi_builtin_list_copy(qi_state_t *state, qi_size_t pargc,
+                                 qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_LIST)
+    qi_throw_format(state, "expected first argument to be: list, but got: %s",
+                    _qi_type(state, a));
+
+  qi_list_t *list;
+
+  LOCKED(a, { list = qi_list_copy(a->value.list); });
+
+  return qi_make_list(state, list);
+}
+
+qi_value_t *qi_builtin_list_push(qi_state_t *state, qi_size_t pargc,
+                                 qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_LIST)
+    qi_throw_format(state, "expected first argument to be: list, but got: %s",
+                    _qi_type(state, a));
+
+  LOCKED(a, { qi_list_push(a->value.list, b); });
+
+  return a;
+}
+
+qi_value_t *qi_builtin_list_insert(qi_state_t *state, qi_size_t pargc,
+                                   qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+  qi_value_t *c = qi_list_index(pargs, 2);
+
+  if (a->type != QI_LIST)
+    qi_throw_format(state, "expected first argument to be: list, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_NUMBER)
+    qi_throw_format(state,
+                    "expected second argument to be: number, but got: %s",
+                    _qi_type(state, b));
+
+  bool res = false;
+
+  LOCKED(a,
+         { res = qi_list_insert(&a->value.list, b->value.number, c) != NULL; });
+
+  if (!res)
+    qi_throw_format(state, "list index out of range: %s",
+                    qi_repr(state, b, true));
+
+  return a;
+}
+
+qi_value_t *qi_builtin_list_delete(qi_state_t *state, qi_size_t pargc,
+                                   qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_LIST)
+    qi_throw_format(state, "expected first argument to be: list, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_NUMBER)
+    qi_throw_format(state,
+                    "expected second argument to be: number, but got: %s",
+                    _qi_type(state, b));
+
+  qi_del(state, a, b);
+
+  return a;
+}
+
+qi_value_t *qi_builtin_list_pop(qi_state_t *state, qi_size_t pargc,
+                                qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_LIST)
+    qi_throw_format(state, "expected first argument to be: list, but got: %s",
+                    _qi_type(state, a));
+
+  qi_value_t *value = NULL;
+
+  LOCKED(a, { value = qi_list_pop(a->value.list); });
+
+  if (!value)
+    qi_throw_format(state, "pop from empty list");
+
+  return value;
+}
+
+qi_value_t *qi_copy_object(qi_state_t *state, qi_value_t *value) {
+  if (value->type != QI_TABLE)
+    return value;
+
+  qi_value_t *newvalue;
+  LOCKED(value, {
+    qi_table_t *table = qi_table_copy(value->value.table.table);
+    newvalue = qi_make_table(state, table);
+    if (qi_has_metatable(value) && newvalue->value.table.metatable != value)
+      newvalue->value.table.metatable =
+          qi_copy_object(state, newvalue->value.table.metatable);
+  });
+
+  return newvalue;
+}
+
+qi_value_t *qi_builtin_table_copy(qi_state_t *state, qi_size_t pargc,
+                                  qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_TABLE)
+    qi_throw_format(state, "expected first argument to be: table, but got: %s",
+                    _qi_type(state, a));
+
+  return qi_copy_object(state, a);
+}
+
+qi_value_t *qi_builtin_table_delete(qi_state_t *state, qi_size_t pargc,
+                                    qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_TABLE)
+    qi_throw_format(state, "expected first argument to be: table, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_STRING)
+    qi_throw_format(state,
+                    "expected second argument to be: string, but got: %s",
+                    _qi_type(state, b));
+
+  qi_del(state, a, b);
+
+  return a;
+}
+
+qi_value_t *qi_builtin_func_call(qi_state_t *state, qi_size_t pargc,
+                                 qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+  qi_value_t *b = qi_list_index(pargs, 1);
+
+  if (a->type != QI_FUNCTION)
+    qi_throw_format(state,
+                    "expected first argument to be: function, but got: %s",
+                    _qi_type(state, a));
+
+  if (b->type != QI_LIST && b->type != QI_TUPLE)
+    qi_throw_format(
+        state, "expected second argument to be: list or tuple, but got: %s",
+        _qi_type(state, b));
+
+  qi_list_t *list = NULL;
+
+  if (b->type == QI_TUPLE) {
+    if (!qi_list_empty(b->value.list))
+      list = qi_list_copy(b->value.list);
+  } else {
+    LOCKED(b, {
+      if (!qi_list_empty(b->value.list))
+        list = qi_list_copy(b->value.list);
+    });
+  }
+
+  return qi_call(state, a, list);
+}
+
+qi_value_t *qi_builtin_func_name(qi_state_t *state, qi_size_t pargc,
+                                 qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_FUNCTION)
+    qi_throw_format(state,
+                    "expected first argument to be: function, but got: %s",
+                    _qi_type(state, a));
+
+  return qi_make_string(state, a->value.function.name);
+}
+
+qi_value_t *qi_builtin_func_argc(qi_state_t *state, qi_size_t pargc,
+                                 qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_FUNCTION)
+    qi_throw_format(state,
+                    "expected first argument to be: function, but got: %s",
+                    _qi_type(state, a));
+
+  return qi_make_number(state, a->value.function.pargc);
+}
+
+qi_value_t *qi_builtin_data_tag(qi_state_t *state, qi_size_t pargc,
+                                qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  if (a->type != QI_DATA)
+    qi_throw_format(state, "expected first argument to be: data, but got: %s",
+                    _qi_type(state, a));
+
+  return qi_make_number(state, a->value.data.tag);
+}
+
+qi_value_t *qi_builtin_repr(qi_state_t *state, qi_size_t pargc,
+                            qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_make_string(state, qi_repr(state, a, true));
+}
+
+qi_value_t *qi_builtin_str(qi_state_t *state, qi_size_t pargc,
+                           qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_to_string(state, a);
+}
+
+qi_value_t *qi_builtin_bool(qi_state_t *state, qi_size_t pargc,
+                            qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_to_boolean(state, a);
+}
+
+qi_value_t *qi_builtin_num(qi_state_t *state, qi_size_t pargc,
+                           qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_to_number(state, a);
+}
+
+qi_value_t *qi_builtin_bytes(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_to_bytes(state, a);
+}
+
+qi_value_t *qi_builtin_list(qi_state_t *state, qi_size_t pargc,
+                            qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_to_list(state, a);
+}
+
+qi_value_t *qi_builtin_tuple(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_to_tuple(state, a);
+}
+
+qi_value_t *qi_builtin_table(qi_state_t *state, qi_size_t pargc,
+                             qi_list_t *pargs) {
+  qi_value_t *a = qi_list_index(pargs, 0);
+
+  return qi_to_table(state, a);
+}
+
+qi_value_t *qi_pseudomethod_list_push(qi_state_t *state, qi_size_t pargc,
+                                      qi_list_t *pargs) {
+  return qi_builtin_list_push(state, pargc, pargs);
+}
+
+qi_value_t *qi_pseudomethod_list_pop(qi_state_t *state, qi_size_t pargc,
+                                     qi_list_t *pargs) {
+  return qi_builtin_list_pop(state, pargc, pargs);
+}
+
+qi_value_t *qi_pseudomethod_func_call(qi_state_t *state, qi_size_t pargc,
+                                      qi_list_t *pargs) {
+  return qi_builtin_func_call(state, pargc, pargs);
+}
+
+qi_value_t *qi_pseudomethod_file__enter(qi_state_t *state, qi_size_t pargc,
+                                        qi_list_t *pargs) {
+  return pargs->value;
+}
+
+qi_value_t *qi_pseudomethod_file__leave(qi_state_t *state, qi_size_t pargc,
+                                        qi_list_t *pargs) {
+  return qi_builtin_fclose(state, pargc, pargs);
+}
+
+qi_value_t *qi_pseudomethod_file_write(qi_state_t *state, qi_size_t pargc,
+                                       qi_list_t *pargs) {
+  return qi_builtin_fwrite(state, pargc, pargs);
+}
+
+qi_value_t *qi_pseudomethod_file_read(qi_state_t *state, qi_size_t pargc,
+                                      qi_list_t *pargs) {
+  if (pargc < 2) {
+    qi_list_t *new_pargs = qi_list_make();
+    qi_list_push(new_pargs, pargs->value);
+    qi_list_push(new_pargs, qi_make_number(state, -1));
+
+    return qi_builtin_fread(state, 2, new_pargs);
+  }
+
+  return qi_builtin_fread(state, pargc, pargs);
+}
+
+qi_value_t *qi_pseudomethod_file_rewind(qi_state_t *state, qi_size_t pargc,
+                                        qi_list_t *pargs) {
+  qi_list_t *new_pargs = qi_list_make();
+  qi_list_push(new_pargs, pargs->value);
+  qi_list_push(new_pargs, qi_make_number(state, 0));
+  qi_list_push(new_pargs, qi_make_number(state, SEEK_SET));
+
+  return qi_builtin_fseek(state, 3, new_pargs);
+}
+
+static void qi_state_setup(qi_state_t *state) {
+  QI_HASH_SEED = time(NULL);
+
+  state->nil = qi_make_value(QI_NULL);
+
+  state->_true = qi_make_value(QI_BOOLEAN);
+  state->_true->value.boolean = true;
+
+  state->_false = qi_make_value(QI_BOOLEAN);
+  state->_false->value.boolean = false;
+
+  state->zero = qi_make_value(QI_NUMBER);
+  state->zero->value.number = 0;
+
+  state->one = qi_make_value(QI_NUMBER);
+  state->one->value.number = 1;
+
+  for (int i = 1; i <= 8; i++) {
+    state->nnumbers[i - 1] = qi_make_value(QI_NUMBER);
+    state->nnumbers[i - 1]->value.number = -i;
+  }
+
+  state->numbers[0] = state->zero;
+  state->numbers[1] = state->one;
+
+  for (int i = 2; i < 256; i++) {
+    state->numbers[i] = qi_make_value(QI_NUMBER);
+    state->numbers[i]->value.number = i;
+  }
+
+  state->intern_strs = qi_table_make();
+  state->intern_strs_lock = qi_lock_create();
+
+  state->pseudomethods = qi_table_make();
+  state->pseudomethods_lock = qi_lock_create();
+
+  state->nan = qi_make_value(QI_NUMBER);
+  state->nan->value.number = NAN;
+
+  state->infinity = qi_make_value(QI_NUMBER);
+  state->infinity->value.number = INFINITY;
+
+  state->ninfinity = qi_make_value(QI_NUMBER);
+  state->ninfinity->value.number = -INFINITY;
+
+  state->empty_string = qi_make_value(QI_STRING);
+  state->empty_string->value.string = qi_strdup("");
+
+  state->empty_bytes = qi_make_value(QI_BYTES);
+  state->empty_bytes->value.bytes = qi_malloc(sizeof(qi_bytes_t));
+  state->empty_bytes->value.bytes->data = (unsigned char *)qi_strdup("");
+  state->empty_bytes->value.bytes->size = 0;
+
+  state->empty_tuple = qi_make_value(QI_TUPLE);
+  state->empty_tuple->value.list = qi_list_make();
+
+  state->_stdin = qi_make_value(QI_FILE);
+  state->_stdin->value.file.fd = stdin;
+  strcpy(state->_stdin->value.file.mode, "r");
+  state->_stdin->value.file.is_open = true;
+
+  state->_stderr = qi_make_value(QI_FILE);
+  state->_stderr->value.file.fd = stderr;
+  strcpy(state->_stderr->value.file.mode, "w");
+  state->_stderr->value.file.is_open = true;
+
+  state->_stdout = qi_make_value(QI_FILE);
+  state->_stdout->value.file.fd = stdout;
+  strcpy(state->_stdout->value.file.mode, "w");
+  state->_stdout->value.file.is_open = true;
+
+  state->traps = qi_list_make();
+  state->scopes = qi_list_make();
+  qi_new_scope(state);
+
+  if (__debug_enabled)
+    state->calltrace = qi_list_make();
+  else
+    state->calltrace = NULL;
+
+  qi_decl_const(state, "nil", state->nil);
+  qi_decl_const(state, "true", state->_true);
+  qi_decl_const(state, "false", state->_false);
+  qi_decl_const(state, "NAN", state->nan);
+  qi_decl_const(state, "INFINITY", state->infinity);
+
+  qi_decl_const(state, "STDIN", state->_stdin);
+  qi_decl_const(state, "STDERR", state->_stderr);
+  qi_decl_const(state, "STDOUT", state->_stdout);
+
+  qi_add_builtin(state, "print", 1, qi_builtin_print);
+  qi_add_builtin(state, "println", 1, qi_builtin_println);
+
+  qi_add_builtin(state, "set_meta_table", 2, qi_builtin_set_meta_table);
+  qi_add_builtin(state, "get_meta_table", 1, qi_builtin_get_meta_table);
+  qi_add_builtin(state, "has_meta_table", 1, qi_builtin_has_meta_table);
+  qi_add_builtin(state, "delete_meta_table", 1, qi_builtin_delete_meta_table);
+  qi_add_builtin(state, "has_method", 2, qi_builtin_has_method);
+  qi_add_builtin(state, "delete_method", 2, qi_builtin_delete_method);
+
+  qi_add_builtin(state, "set_global", 2, qi_builtin_set_global);
+  qi_add_builtin(state, "get_global", 1, qi_builtin_get_global);
+  qi_add_builtin(state, "get_globals", 0, qi_builtin_get_globals);
+
+  qi_add_builtin(state, "fopen", 2, qi_builtin_fopen);
+  qi_add_builtin(state, "fread", 2, qi_builtin_fread);
+  qi_add_builtin(state, "fgets", 2, qi_builtin_fgets);
+  qi_add_builtin(state, "fgetc", 1, qi_builtin_fgetc);
+  qi_add_builtin(state, "fputc", 2, qi_builtin_fputc);
+  qi_add_builtin(state, "fwrite", 2, qi_builtin_fwrite);
+  qi_add_builtin(state, "fputs", 2, qi_builtin_fputs);
+  qi_add_builtin(state, "fseek", 3, qi_builtin_fseek);
+  qi_add_builtin(state, "ftell", 1, qi_builtin_ftell);
+  qi_add_builtin(state, "fflush", 1, qi_builtin_fflush);
+  qi_add_builtin(state, "fclose", 1, qi_builtin_fclose);
+  qi_add_builtin(state, "fclosed", 1, qi_builtin_fclosed);
+
+  qi_add_builtin(state, "chr", 1, qi_builtin_chr);
+  qi_add_builtin(state, "ord", 1, qi_builtin_ord);
+
+  qi_add_builtin(state, "len", 1, qi_builtin_len);
+  qi_add_builtin(state, "type", 1, qi_builtin_type);
+
+  qi_add_builtin(state, "list_copy", 1, qi_builtin_list_copy);
+  qi_add_builtin(state, "list_push", 2, qi_builtin_list_push);
+  qi_add_builtin(state, "list_insert", 3, qi_builtin_list_insert);
+  qi_add_builtin(state, "list_delete", 2, qi_builtin_list_delete);
+  qi_add_builtin(state, "list_pop", 1, qi_builtin_list_pop);
+
+  qi_add_builtin(state, "table_copy", 1, qi_builtin_table_copy);
+  qi_add_builtin(state, "table_delete", 2, qi_builtin_table_delete);
+
+  qi_add_builtin(state, "func_name", 1, qi_builtin_func_name);
+  qi_add_builtin(state, "func_argc", 1, qi_builtin_func_argc);
+  qi_add_builtin(state, "func_call", 2, qi_builtin_func_call);
+
+  qi_add_builtin(state, "data_tag", 1, qi_builtin_data_tag);
+
+  qi_add_builtin(state, "repr", 1, qi_builtin_repr);
+  qi_add_builtin(state, "str", 1, qi_builtin_str);
+  qi_add_builtin(state, "bool", 1, qi_builtin_bool);
+  qi_add_builtin(state, "num", 1, qi_builtin_num);
+  qi_add_builtin(state, "bytes", 1, qi_builtin_bytes);
+  qi_add_builtin(state, "list", 1, qi_builtin_list);
+  qi_add_builtin(state, "tuple", 1, qi_builtin_tuple);
+  qi_add_builtin(state, "table", 1, qi_builtin_table);
+
+  qi_add_pseudomethod(state, "file.__enter", 0, qi_pseudomethod_file__enter);
+  qi_add_pseudomethod(state, "file.__leave", 0, qi_pseudomethod_file__leave);
+  qi_add_pseudomethod(state, "file.write", 0, qi_pseudomethod_file_write);
+  qi_add_pseudomethod(state, "file.read", 0, qi_pseudomethod_file_read);
+  qi_add_pseudomethod(state, "file.rewind", 0, qi_pseudomethod_file_rewind);
+
+  qi_add_pseudomethod(state, "list.push", 1, qi_pseudomethod_list_push);
+  qi_add_pseudomethod(state, "list.pop", 0, qi_pseudomethod_list_pop);
+
+  qi_add_pseudomethod(state, "function.call", 1, qi_pseudomethod_func_call);
+
+  state->_debug_data = NULL;
+}
+
+static void _qi_state_init(qi_state_t **state, bool enable_debug) {
+  GC_INIT();
+  GC_set_java_finalization(1);
+  *state = qi_malloc(sizeof(qi_state_t));
+  __debug_enabled = enable_debug;
+  qi_state_setup(*state);
+  __main_tid = pthread_self();
+}
+
+void qi_state_init(qi_state_t **state) { _qi_state_init(state, false); }
+
+void qi_state_init_debug(qi_state_t **state) { _qi_state_init(state, true); }

qirt.h

@@ -0,0 +1,442 @@
+#ifndef _QI_RUNTIME_H
+#define _QI_RUNTIME_H
+
+#include <ctype.h>
+#include <math.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+typedef int bool;
+#define true 1
+#define false 0
+
+typedef unsigned long qi_size_t;
+typedef long qi_ssize_t;
+
+typedef struct _qi_list_t qi_list_t;
+
+struct _qi_list_t {
+  void *value;
+  qi_list_t *next;
+};
+
+#define qi_list_empty(list) (!(list)->value)
+#define qi_list_first(list) ((list)->value)
+#define qi_list_last(list) (qi_list_index((list), -1))
+
+typedef struct _qi_table_t qi_table_t;
+typedef struct _qi_table_entry_t qi_table_entry_t;
+
+struct _qi_table_entry_t {
+  char *key;
+  void *value;
+
+  bool is_deleted;
+};
+
+struct _qi_table_t {
+  qi_table_entry_t *entries;
+
+  qi_size_t used;
+  qi_size_t capacity;
+};
+
+#define QI_TABLE_MIN_SIZE 32
+
+#define qi_table_length(table) ((table)->used)
+#define qi_table_empty(table) ((table)->used == 0)
+#define qi_table_iterate(table, code)                                          \
+  {                                                                            \
+    if (!qi_table_empty(table)) {                                              \
+      qi_size_t i = 0;                                                         \
+      while (i < (table)->capacity) {                                          \
+        qi_table_entry_t entry = (table)->entries[i];                          \
+        if (entry.key && !entry.is_deleted) {                                  \
+          code;                                                                \
+        }                                                                      \
+        i++;                                                                   \
+      }                                                                        \
+    }                                                                          \
+  }
+
+typedef struct {
+  char *str;
+
+  qi_size_t used;
+  qi_size_t allocated;
+} qi_buffer_t;
+
+typedef enum {
+  QI_NULL,
+  QI_BOOLEAN,
+  QI_NUMBER,
+  QI_STRING,
+  QI_BYTES,
+  QI_FILE,
+  QI_LIST,
+  QI_TUPLE,
+  QI_TABLE,
+  QI_FUNCTION,
+  QI_DATA,
+
+  QI_OBJECT
+} qi_type_t;
+
+static const char qi_type_names[12][10] = {
+    "nil",  "boolean", "number", "string",   "bytes", "file",
+    "list", "tuple",   "table",  "function", "data",  "object"};
+
+#define qi_repr_type(type) (qi_type_names[(type)])
+
+typedef struct _qi_state_t qi_state_t;
+typedef struct _qi_value_t qi_value_t;
+
+typedef qi_value_t *(*qi_handle_t)(qi_state_t *, qi_size_t, qi_list_t *);
+
+typedef struct {
+  unsigned char *data;
+  qi_size_t size;
+} qi_bytes_t;
+
+struct _qi_value_t {
+  qi_type_t type;
+  void *lock;
+
+  union {
+    bool boolean;
+    double number;
+    char *string;
+    qi_bytes_t *bytes;
+    struct qi_file_t {
+      FILE *fd;
+      char mode[4];
+      bool is_open;
+    } file;
+    qi_list_t *list;
+    struct {
+      qi_table_t *table;
+      qi_value_t *metatable;
+    } table;
+    struct qi_function_t {
+      qi_handle_t handle;
+
+      char *name;
+      qi_size_t pargc;
+
+      qi_table_t *captured;
+
+      qi_value_t *_this;
+
+      bool is_builtin;
+      bool is_pm;
+    } function;
+    struct {
+      unsigned int tag;
+      void *data;
+    } data;
+  } value;
+};
+
+struct _qi_state_t {
+  qi_value_t *nil;
+  qi_value_t *_true;
+  qi_value_t *_false;
+  qi_value_t *zero;
+  qi_value_t *one;
+  qi_value_t *nan;
+  qi_value_t *infinity;
+  qi_value_t *ninfinity;
+  qi_value_t *empty_string;
+  qi_value_t *empty_bytes;
+  qi_value_t *empty_tuple;
+  qi_value_t *_stdin;
+  qi_value_t *_stderr;
+  qi_value_t *_stdout;
+  qi_value_t *nnumbers[8];
+  qi_value_t *numbers[256];
+
+  qi_table_t *pseudomethods;
+  void *pseudomethods_lock;
+
+  qi_table_t *intern_strs;
+  void *intern_strs_lock;
+
+  qi_list_t *traps;
+  qi_list_t *scopes;
+  qi_list_t *calltrace;
+
+  const char *_debug_data;
+};
+
+typedef struct _qi_scope_t qi_scope_t;
+
+struct _qi_scope_t {
+  qi_table_t *scope;
+  qi_list_t *defers;
+
+  bool is_barrier;
+
+  void *lock;
+};
+
+typedef void (*qi_defer_t)(qi_state_t *);
+
+#define qi_has_metatable(obj) ((obj)->value.table.metatable->type == QI_TABLE)
+#define qi_get_metatable(obj) ((obj)->value.table.metatable->value.table.table)
+#define _is_meta_name(name) (strncmp((name), "__", 2) == 0)
+#define is_meta_name(name)                                                     \
+  ((name)->type == QI_STRING && _is_meta_name((name)->value.string))
+
+#define qi_type(state, value)                                                  \
+  (qi_make_string((state), _qi_type((state), (value))))
+#define qi_repr(state, value, quote)                                           \
+  (_qi_repr((state), qi_list_make(), (value), (quote)))
+#define qi_show(state, value)                                                  \
+  (qi_repr(state, value, (value)->type != QI_STRING))
+
+typedef struct _qi_trap_t qi_trap_t;
+
+struct _qi_trap_t {
+  qi_value_t *value;
+
+  qi_defer_t finally;
+
+  qi_scope_t *scope;
+
+  qi_size_t scopes_count;
+  qi_size_t calltrace_size;
+
+  jmp_buf label;
+};
+
+#define qi_try(state, code, handle, defer)                                     \
+  {                                                                            \
+    qi_trap_t *trap = qi_set_trap(state, defer);                               \
+    if (setjmp(trap->label)) {                                                 \
+      qi_unset_trap(state, trap);                                              \
+      if (trap->finally)                                                       \
+        qi_add_defer(state, 0, trap->finally);                                 \
+      handle;                                                                  \
+      if (trap->finally) {                                                     \
+        qi_pop_defer(state, 0);                                                \
+        trap->finally(state);                                                  \
+      }                                                                        \
+    } else {                                                                   \
+      code;                                                                    \
+      qi_unset_trap(state, trap);                                              \
+      if (trap->finally)                                                       \
+        trap->finally(state);                                                  \
+    }                                                                          \
+  }
+
+typedef struct _qi_symbol_t qi_symbol_t;
+
+struct _qi_symbol_t {
+  qi_value_t *value;
+
+  bool is_constant;
+};
+
+#define qi_set(state, is_pre, name, value)                                     \
+  (_qi_set((state), is_pre, false, (name), (value)))
+#define qi_bind(state, is_pre, name, value)                                    \
+  (_qi_set((state), is_pre, true, (name), (value)))
+
+#define qi_length(state, value)                                                \
+  (qi_make_number((state), _qi_length((state), (value))))
+#define qi_truthy(state, value)                                                \
+  (qi_make_boolean((state), _qi_truthy((state), (value))))
+
+#define qi_to_boolean(state, x) (qi_cast((state), QI_BOOLEAN, (x)))
+#define qi_to_number(state, x) (qi_cast((state), QI_NUMBER, (x)))
+#define qi_to_string(state, x) (qi_cast((state), QI_STRING, (x)))
+#define qi_to_bytes(state, x) (qi_cast((state), QI_BYTES, (x)))
+#define qi_to_list(state, x) (qi_cast((state), QI_LIST, (x)))
+#define qi_to_tuple(state, x) (qi_cast((state), QI_TUPLE, (x)))
+#define qi_to_table(state, x) (qi_cast((state), QI_TABLE, (x)))
+
+#define qi_get_boolean(state, x)                                               \
+  ((x)->type == QI_BOOLEAN ? (x)->value.boolean                                \
+                           : qi_to_boolean(state, x)->value.boolean)
+#define qi_get_number(state, x)                                                \
+  ((x)->type == QI_NUMBER ? (x)->value.number                                  \
+                          : qi_to_number(state, x)->value.number)
+#define qi_get_string(state, x)                                                \
+  ((x)->type == QI_STRING ? (x)->value.string                                  \
+                          : qi_to_string(state, x)->value.string)
+#define qi_get_bytes(state, x)                                                 \
+  ((x)->type == QI_BYTES ? (x)->value.bytes                                    \
+                         : qi_to_bytes(state, x)->value.bytes)
+#define qi_get_list(state, x)                                                  \
+  ((x)->type == QI_LIST ? (x)->value.list : qi_to_list(state, x)->value.list)
+#define qi_get_table(state, x)                                                 \
+  ((x)->type == QI_TABLE ? (x)->value.table.table                              \
+                         : qi_to_table(state, x)->value.table.table)
+#define qi_get_data(state, t, x)                                               \
+  ((x)->type != QI_DATA || (x)->value.data.tag != (t)                          \
+       ? (qi_throw_format((state), "expected data (tag: %d)", (t)), NULL)      \
+       : (x)->value.data.data)
+
+#define qi_push_trace(state, fn, debug_data)                                   \
+  (qi_list_push((state)->calltrace,                                            \
+                qi_list_push(qi_list_push(qi_list_make(), (value)),            \
+                             (void *)(debug_data))))
+#define qi_pop_trace(state) (qi_list_pop((state)->calltrace))
+
+#define qi_equals(state, a, b)                                                 \
+  (qi_make_boolean((state), _qi_equals((state), (a), (b))))
+#define qi_not_equals(state, a, b)                                             \
+  (qi_make_boolean((state), !_qi_equals((state), (a), (b))))
+#define qi_is(state, a, b) (qi_make_boolean((state), (a) == (b)))
+#define qi_not_is(state, a, b) (qi_make_boolean((state), (a) != (b)))
+
+#define qi_in(state, a, b) (qi_make_boolean((state), _qi_in((state), (a), (b))))
+#define qi_not_in(state, a, b)                                                 \
+  (qi_make_boolean((state), !_qi_in((state), (a), (b))))
+
+#define qi_lt(state, a, b) (qi_make_boolean((state), _qi_lt((state), (a), (b))))
+#define qi_gt(state, a, b) (qi_make_boolean((state), _qi_gt((state), (a), (b))))
+
+#define _qi_le(state, a, b)                                                    \
+  (_qi_equals((state), (a), (b)) || _qi_lt((state), (a), (b)))
+#define _qi_ge(state, a, b)                                                    \
+  (_qi_equals((state), (a), (b)) || _qi_gt((state), (a), (b)))
+#define qi_le(state, a, b) (qi_make_boolean((state), _qi_le((state), (a), (b))))
+#define qi_ge(state, a, b) (qi_make_boolean((state), _qi_ge((state), (a), (b))))
+
+#define _qi_or(state, a, b)                                                    \
+  (_qi_truthy((state), (a)) || _qi_truthy((state), (b)))
+#define qi_or(state, a, b) (qi_make_boolean((state), _qi_or((state), (a), (b))))
+#define _qi_and(state, a, b)                                                   \
+  (_qi_truthy((state), (a)) && _qi_truthy((state), (b)))
+#define qi_and(state, a, b)                                                    \
+  (qi_make_boolean((state), _qi_and((state), (a), (b))))
+
+#define _qi_not(state, a) (!_qi_truthy((state), (a)))
+#define qi_not(state, a) (qi_make_boolean((state), _qi_not((state), (a))))
+
+#define qi_add_builtin(state, name, pargc, handle)                             \
+  (qi_decl_const((state), name,                                                \
+                 qi_make_builtin_function(state, name, pargc, handle)))
+
+#define LOCKED(value, code)                                                    \
+  {                                                                            \
+    if ((value)->lock)                                                         \
+      qi_lock_acquire((value)->lock);                                          \
+    code;                                                                      \
+    if ((value)->lock)                                                         \
+      qi_lock_release((value)->lock);                                          \
+  }
+
+void *qi_malloc(qi_size_t size);
+void *qi_malloc_atomic(qi_size_t size);
+void *qi_realloc(void *old_ptr, qi_size_t size);
+void *qi_calloc(qi_size_t count, qi_size_t size);
+char *qi_strdup(const char *s);
+void qi_free(void *);
+qi_list_t *qi_list_make(void);
+qi_size_t qi_list_length(qi_list_t *list);
+void *qi_list_index(qi_list_t *list, qi_ssize_t index);
+qi_list_t *qi_list_push(qi_list_t *list, void *value);
+qi_list_t *qi_list_insert(qi_list_t **list, qi_ssize_t index, void *value);
+qi_list_t *qi_list_delete(qi_list_t **list, qi_ssize_t index);
+void *qi_list_set(qi_list_t *list, qi_ssize_t index, void *value);
+void *qi_list_pop(qi_list_t *list);
+bool qi_list_contains(qi_list_t *list, void *value);
+qi_list_t *qi_list_copy(qi_list_t *list);
+qi_table_t *qi_table_make(void);
+void *qi_table_get(qi_table_t *table, char *key);
+bool qi_table_has(qi_table_t *table, char *key);
+qi_table_t *qi_table_set(qi_table_t *table, char *key, void *value);
+qi_list_t *qi_table_keys(qi_table_t *table);
+bool qi_table_delete(qi_table_t *table, char *key);
+qi_table_t *qi_table_copy(qi_table_t *table);
+void qi_add_defer(qi_state_t *state, qi_ssize_t index, qi_defer_t defer);
+qi_defer_t qi_pop_defer(qi_state_t *state, qi_ssize_t index);
+void qi_new_scope(qi_state_t *state);
+bool qi_old_scope(qi_state_t *state);
+qi_value_t *qi_make_value(qi_type_t type);
+#define qi_make_boolean(state, x) ((x) ? (state)->_true : (state)->_false)
+qi_value_t *qi_make_number(qi_state_t *state, double number);
+qi_value_t *qi_make_string(qi_state_t *state, char *string);
+qi_value_t *qi_make_string_copy(qi_state_t *state, char *string);
+qi_value_t *qi_make_bytes(qi_state_t *state, unsigned char *bytes,
+                          qi_size_t size);
+qi_value_t *qi_make_char(qi_state_t *state, char c);
+qi_value_t *qi_make_file(qi_state_t *state, FILE *file, char *mode);
+qi_value_t *qi_make_list(qi_state_t *state, qi_list_t *list);
+qi_value_t *qi_make_tuple(qi_state_t *state, qi_list_t *tuple);
+qi_value_t *qi_make_table(qi_state_t *state, qi_table_t *table);
+qi_value_t *qi_make_function(qi_state_t *state, char *name, qi_size_t pargc,
+                             qi_handle_t handle, qi_table_t *captured);
+qi_value_t *qi_make_builtin_function(qi_state_t *state, char *name,
+                                     qi_size_t pargc, qi_handle_t handle);
+qi_value_t *qi_make_data(qi_state_t *state, unsigned int tag, void *data);
+qi_value_t *qi_add_pseudomethod(qi_state_t *state, char *name, qi_size_t pargc,
+                                qi_handle_t handle);
+qi_value_t *qi_get_method(qi_state_t *state, qi_value_t *value, char *name);
+qi_value_t *qi_call_meta(qi_state_t *state, bool *fail_flag, qi_value_t *value,
+                         char *name, qi_size_t count, ...);
+char *_qi_type(qi_state_t *state, qi_value_t *value);
+char *_qi_repr(qi_state_t *state, qi_list_t *tempstack, qi_value_t *value,
+               bool quote);
+void qi_finalize(void);
+void qi_fatal(qi_state_t *state, char *format, ...);
+qi_trap_t *qi_set_trap(qi_state_t *state, qi_defer_t finally);
+void qi_unset_trap(qi_state_t *state, qi_trap_t *trap);
+void qi_throw(qi_state_t *state, qi_value_t *value);
+void qi_throw_format(qi_state_t *state, char *format, ...);
+qi_value_t *qi_find(qi_state_t *state, char *name);
+qi_value_t *qi_get(qi_state_t *state, char *name);
+void qi_decl_const(qi_state_t *state, char *name, qi_value_t *value);
+void qi_decl(qi_state_t *state, char *name, qi_value_t *value);
+qi_value_t *_qi_set(qi_state_t *state, bool is_pre, bool is_constant,
+                    char *name, qi_value_t *value);
+size_t _qi_length(qi_state_t *state, qi_value_t *value);
+qi_value_t *qi_del(qi_state_t *state, qi_value_t *value, qi_value_t *index);
+bool _qi_truthy(qi_state_t *state, qi_value_t *value);
+qi_value_t *qi_cast(qi_state_t *state, qi_type_t type, qi_value_t *value);
+qi_value_t *qi_iter(qi_state_t *state, qi_value_t *value);
+qi_value_t *qi_index(qi_state_t *state, qi_value_t *value, qi_value_t *index);
+qi_value_t *qi_index_set(qi_state_t *state, bool is_pre, qi_value_t *value,
+                         qi_value_t *index, qi_value_t *newvalue);
+qi_value_t *qi_call(qi_state_t *state, qi_value_t *value, qi_list_t *pargs);
+qi_value_t *qi_call_debug(qi_state_t *state, qi_value_t *value,
+                          qi_list_t *pargs, const char *debug_data);
+bool _qi_equals(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+bool _qi_in(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_add(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_sub(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_mul(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_div(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_idiv(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_mod(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_pow(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_band(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_bor(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_xor(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_shl(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_shr(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+bool _qi_lt(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+bool _qi_gt(qi_state_t *state, qi_value_t *a, qi_value_t *b);
+qi_value_t *qi_negate(qi_state_t *state, qi_value_t *a);
+qi_value_t *qi_bnot(qi_state_t *state, qi_value_t *a);
+void *qi_thread_create(qi_state_t *state, qi_value_t *fn, qi_list_t *args);
+qi_value_t *qi_thread_join(qi_state_t *state, void *td);
+void qi_thread_exit(qi_state_t *state, qi_value_t *value);
+bool qi_thread_main(void);
+void *qi_lock_create(void);
+void qi_lock_destroy(void *lock);
+void qi_lock_acquire(void *lock);
+bool qi_lock_tryacquire(void *lock);
+bool qi_lock_acquired(void *lock);
+void qi_lock_release(void *lock);
+void qi_state_init(qi_state_t **state);
+void qi_state_init_debug(qi_state_t **state);
+
+#endif